Both methods of prototyping are used when there's some aspect of the system that you don't entirely understand. However, the key difference is the lifecycle methodology that you use. With evolutionary prototyping, you typically understand some aspects of the system and aren't sure about others. In throwaway prototyping, you have a general lack of understanding that you need to complete before you can build a production-ready system.
Note that there are lots of kinds of throwaway prototyping, and neither are limited to the entire system. For example, using paper or whiteboard sketches of a user interface can be considered throwaway prototyping. Yes, you might go through several iterations and throw away a previous design, but you also won't use the final prototype in the system (it's not physically possible, for one).
If you're interested in general software engineering topics and the breadth of SE, I'd highly suggest picking up the Sommerville book that I quote. It's really good for covering the breadth of topics. If you're more interested in process models and methodologies and how you can apply them to various projects, I'd recommend the McConnell book - it has an entire chapter devoted to evolutionary prototyping and another chapter devoted to throwaway prototyping.
I also took a quick glance at the Wikipedia article on software prototyping. Some parts of it are a little weird (at least on my quick read), but there doesn't appear to be anything that I downright disagree with. Some of it is a little focused on one particular aspect, but it's not factually wrong that I see. I prefer the definitions below, but it might be an interesting read on various types of prototyping.
Exploratory development where the objective of the process is to work
with the customer to explore their requirements and deliver a final
system. The development starts with the parts of the system that are
understood. The system evolves by adding new features proposed by the
customer. (Sommerville: Software Engineering, 8th Edition)
Evolutionary Prototyping is a lifecycle model in which the system is
developed in increments so that it can readily be modified in response
to end-user and customer feedback. Most evolutionary-prototyping
efforts begin by prototyping the user interface and then evolving the
completed system from that, but prototyping can start with any
high-risk area. Evolutionary Prototyping is not the same as Throwaway
Prototyping, and making the right choice about whether to develop an
evolutionary prototype or a throwaway prototype is one key to success.
Other keys to success include using experienced developers, managing
schedule and budget expectations, and managing the prototyping
activity itself. (McConnell: Rapid Development: Taming Wild Software Schedules)
Throwaway prototyping is where the objective of the evolutionary
development process is to understand the customer's requirements and
hence develop a better requirements definition for the system. The
prototype concentrates on experimenting with the customer requirements
that are poorly understood. (Sommerville: Software Engineering, 8th
With Throwaway Prototyping, code is developed to explore factors
critical to the system's success, and then that code is thrown away.
The prototyping implementation uses programming languages or
development practices or both that are much faster than the target
language and practices. The user interface is prototyped far more
commonly than any other part of the system, but other parts of some
systems can also benefit from being prototyped. When used as a
requirementsspecification aid, the Throwaway Prototyping practice can
accelerate projects based on traditional lifecycle models, such as DoD
projects. It can be initiated at either a management or technical
level. (McConnell: Rapid Development: Taming Wild Software Schedules)