Basically an explicit scheme is one where there is a simple updating procedure that does not depend upon other values at the current level while an implicit one contains information at the current level which requires the solving of simultaneous equations.
For example consider the the system of odes
du/dt = f(u)
where u is a vector and f is a known function. Then we may approximate the time derivative over a time step h as
(explicit) u(n+1) = u(n) + h.f(u(n))
(implicit) u(n+1) = u(n) + h.f(u(n+1))
where u(n) is the value of u at t=nh. In the explicit formula the right-hand-side is known and so u(n+1) is easily calculated while in the implicit case the RHS depends upon the quantity you are trying to calculate. If f(u) = Au where A is a matrix independent of u then the implicit scheme requires solving the system of equations
(I-hA).u(n+1) = u(n)
and so a matrix inversion needs to be performed.
The main pros and cons of these two methods are that explicit schemes are easy to program with only simple calculations performed at each timestep while implicit schemes are more difficult and can involve many iterations per timestep. Explicit schemes however have a tendancy to be unstable and require very small timesteps while implicit schemes are very stable and can have much larger timesteps.
The book
Numerical solution of partial differential equations by G.D. Smith (1979). Oxford University Press
Implicit is good if you want to make arbitrary sized step sizes and still maintain stability. This is good when you want to work towards steady state for a problem. However, implicit schemes require a largely increase computational effort, especially for nonlinear equations.
Explicit methods are cheaper computationally but are conditionally stable, causing your step size in time to be dependent on the numerical method you choose, leading generally to many more time steps taken to get to a desired time than implicit methods. There are some adaptive schemes constructed based on explicit schemes that allow for handling with these time step issues in an optimal fashion, many of which are dependent on Runge-Kutta formulations.
The choice of your time integration approach really comes down to your problem and what you want. If you want steady state, implicit may be worth the effort. If you need something simple to implement, an adaptive explicit procedure would probably be the best.
By the way, a stiff system is where some of the eigenvalues of your ODE system have large frequencies, causing rapid changing solutions at the start (or even throughout) your simulation. Generally, these dampen out over time, allowing for large step sizes later. However, due to the high frequency nature initially, one needs to take small time steps in time to capture all the information. Adaptive procedures and implicit schemes are very useful for this sort of problem.
I would add to this discussion that there are "semi-implicit methods" like the Crank-Nicolson scheme (expanded "halfway between" the n and n+1 time levels) that are unconditionally stable for many problems. Wikipedia has a nice general description at https://en.wikipedia.org/wiki/Crank%E2%80%93Nicolson_method but texts like Computational Fluid Mechanics and Heat Transfer by Tannehill et al give authoritative details.
The best method is analytical, but not all differential equations have an analytical solution. It very much depends on your type of linear equation if they have an analytical solution or not. If you need to find the solution numerically then it still depends on the type (and your requirements) to know if implicit or explicit is best.
In conventional, impilicit methods are better methods than explicit ones for their higher accuracy and convergence. Explicit methods are conditionally stable. Implicit is good if you want to make arbitrary sized step sizes and still maintain stability. This is good when you want to work towards steady state for given problem. Implicit schemes require a largely increase computational effort for nonlinear equations. Explicit methods are cheaper computationally but are conditionally stable, causing your step size in time to be dependent on the numerical method you choose, leading generally to many more time steps taken to get to a desired time than implicit methods.