提取和封装是两种很好的口味，一起吃起来味道很好。

封装是最小化你暴露给你代码用户的东西。那个“用户”可能是你代码的其余部分，或者是任何使用你发布的代码的人。

封装有一些明确的好处：

• 代码的使用者并不依赖于程序中可能会改变的部分，当你改变程序时，他们并不需要改变他们的代码
• 您可以更准确地控制代码和状态在程序生存期内的更改方式。您必须处理的方案更少，需要修复的意外问题也更少

我不懂Java，但这里有一个用C#封装的小例子：

public class Giraffe
{
    public Giraffe(int heightInFeet)
    {
        this.heightInFeet = heightInFeet;
        this.numberOfSpots = heightInFeet * 72;
    }

    public override string ToString()
    {
        return "Height: " + heightInFeet + " feet"
            + " Number of Spots: " + numberOfSpots;
    }

    private int heightInFeet;
    private int numberOfSpots;
}

它不是公开numberOfSpots，而是封装在类中，并通过ToString方法公开。

Abstraction使用扩展点来让选择被延迟到运行确切代码的不同部分。该选择可以在程序的其他地方、其他程序中或在运行时动态地进行。

抽象还有很多好处：

• 当你改变实现抽象的代码时，抽象的用户不必改变他们的代码，只要抽象不改变，用户就不必改变他们的代码。
• 编写使用抽象的代码时，只需编写一次代码，就可以针对实现该抽象的任何新代码重用该代码。可以编写更少的代码来完成更多的工作。

在C#中，IEnumerable是一个常用的抽象。列表、数组、字典和任何其他类型的集合类都实现IEnumerable。foreach循环结构和整个LINQ库都基于该抽象：

public IEnumerable<int> GetSomeCollection()
{
    // This could return any type of int collection.  Here it returns an array
    return new int[] { 5, 12, 7, 14, 2, 3, 7, 99 };
}

IEnumerable<int> someCollectionOfInts = GetSomeCollection();

IEnumerable<string> itemsLessThanFive = from i in someCollectionOfInts
                                        where i < 5
                                        select i.ToString();

foreach(string item in itemsLessThanFive)
{
    Console.WriteLine(item);
}

您也可以轻松地编写自己的抽象：

public interface IAnimal
{
    bool IsHealthy { get; }
    void Eat(IAnimal otherAnimal);
}

public class Lion : IAnimal
{
    public Lion()
    {
        this.isHealthy = true;
    }

    public bool IsHealthy
    {
        get { return isHealthy; }
    }

    void Eat(IAnimal otherAnimal)
    {
        if(otherAnimal.IsHealthy && !(otherAnimal is SlimeMold))
        {
            isHealthy = true;
        }
        else
        {
            isHealthy = false;
        }
    }

    private bool isHealthy;
}

IAnimal someAnimal = PullAnAnimalOutOfAWoodenCrate();

Console.WriteLine("The animal is healthy?: " + someAnimal.IsHealthy);

您可以将两者一起使用，就像我对IAnimal和IsHealthy所做的那样。IAnimal是一个抽象，只有一个get访问器，而IsHealthy上没有set访问器是封装。

这两个概念是完全不同的。
抽象是使基类"抽象"然后扩展其功能的实践。抽象类是不存在于具体事物中的东西;它唯一的目的是被扩展。想象一下如果你在写类来表示不同的物种。你所有的不同物种都可能扩展一个抽象的Animal类，因为它们都会共享动物的公共属性。然而，你永远不会示例化一个Animal对象，因为你在世界上看到的每一种动物都是松鼠，或者狗，或者鱼...或者那个基础的某种具体实现，抽象的动物种类。
封装是使类变量成为私有变量，然后允许通过get和set方法访问它们的实践。这样做的目的是将访问数据的方式与实现数据的方式分开。例如，如果某个变量有一个要求，即每次更改它时，它也会将第二个变量加1，那么您将封装该功能;这样，您代码会更可靠，因为您不必记住每次访问原始变量时都要遵守规则。
如果你想要具体的代码示例，我建议你在谷歌上搜索一下，因为类似的示例有很多，这里有两个：
http://www.tutorialspoint.com/java/java_abstraction.htmhttp://www.tutorialspoint.com/java/java_encapsulation.htm

封装是为了保护您的成员变量或方法不受外界影响。
抽象是获得具体实现的方法，也就是说，用户不知道使用哪个实现。

封装是抽象的一部分。抽象的概念是创建一个对象来表示另一个对象。通常情况下，原始对象比抽象更复杂。因此，抽象是一种表示，通常作为记忆、术语/通信等的辅助手段。可以这样想：抽象艺术是对其他事物的表现。2方向盘、变速杆和2/3踏板是对汽车工作原理的抽象。
基本上，抽象可以让你把复杂的东西，很多细节，表现为简单得多的东西。在我看来，这与认知科学中的“组块”有关。我们不能把复杂的东西留在头脑中，所以我们通过抽象来简化，然后使用抽象。设计模式是另一个很好的例子。我们可以谈论命令，而不是细节。状态或策略模式等
封装是形成/创建抽象的一部分。对象的接口越小，抽象就越容易。你不需要知道发动机和变速箱如何工作来驱动汽车，你只需要理解它们的抽象（变速杆和油门）。发动机和变速箱的细节被封装（到接口中）以创建抽象。
抽象需要封装，因为抽象不能处理所有真实的的细节和复杂性（否则就不是抽象）。因此，变速器是变速箱的不完整表示（或模型），但对于日常使用来说已经足够完整了。封装可以被认为是“隐藏细节”，这对于创建更简单的表示是必要的。
讨论“接口”的概念也很重要。在大多数情况下，术语“接口”和“抽象”在这种情况下是不太容易互换的。接口是用户处理或交互的系统的一部分。汽车的接口是方向盘、变速杆和踏板等。抽象产生接口。你不直接处理引擎/变速箱。处理它们各自的接口。
封装的另一个原因是因为我们处理的是一个不完整的模型/抽象，我们不了解原始模型的全部复杂性，并且不能被信任来处理所有的变量（因为我们不了解完整的模型）。这对于解耦很重要，因为如果没有抽象，交互的组件会对彼此了解太多。想想看，因为每辆车都有方向盘，踏板和变速器，你可以驾驶任何汽车，无论发动机类型等。而且，变速器是抽象的发动机。否则每个定制的发动机将需要一个定制的变速器。
类似地，类是一个抽象，类代表一些复杂的模型，通过它的接口-类的公共成员。这个接口是通过封装创建的。类向它的合作者提供了它更复杂实现的简化接口。你也可以把它看作是一个“需要知道”的情况。类的合作者不需要确切地知道它是如何工作的。就像你不需要知道发动机是如何工作来驾驶汽车一样。
封装、接口和抽象在代码的内聚性和耦合性以及代码的维护中起着至关重要的作用。如果你没有创建好的抽象，并且违反了“需要知道”的原则，那么你的代码就会变得混乱、脆弱，并且是一场改变的噩梦，因为没有“缓冲”。“告诉不要问”的OO概念也与此相关。