I'm not sure how much this will make sense.  Encapsulation is "hiding"
data within an appropriate wrapper.  This is what the Java Beans
specification was based on.
You have hidden members (class variables) and public accessors (methods
which
modify them).  Once you have data you wish to protect access to, you
"encapsulate"
it in a proper bean or class.  This is in place of simply dropping it
in a class and accessing
it however you like.  It makes data more thread safe, I'm sure, among
other things.

Abstraction is grouping like things together.  Often this is moving
frequently re-used
methods to a common "base class".  For instance, you have functions you
keep using
over and over in a group of database classes.  You might move them into
a top level,
"base class", you inherit.  This keeps you from writing them over and
over again.  Also
there's one place you change things in them.

I guess an example might be adding furniture to houses on a city block.
Do you place the
furniture within new houses and control access within them?  Or do you
add one house that  will showcase frequently-used items?

Encapsulation is combining the data, and the operations that work on
that data in a single unit.

Data Abstraction is being able to group smaller units of data into a
larger, logical unit that can be operated without the knowledge of
underlying components. For example, abstracting a Person data structure
out of 3 strings representing first, last, middle names, and an integer
representing age.

-cheers,
Manish

Wikipedia has some useful definitions of these and related concepts.

http://en.wikipedia.org/wiki/Information_hiding

Thank you all.