difference between abstraction and encapsulation?

 

封装和抽象之间的精确区别是什么？

Most answers here focus on OOP but encapsulation begins much earlier:

  • Every function is an encapsulation ; in pseudocode: 

    point x = { 1, 4 }
point y = { 23, 42 }

numeric d = distance(x, y)

    Here, distance encapsulates the calculation of the (Euclidean) distance between two points in a plane: it hides implementation details. This is encapsulation, pure and simple.

  • Abstraction is the process of generalisation : taking a concrete implementation and making it applicable to different, albeit somewhat related, types of data. The classical example of abstraction is C's qsort function to sort data:

    The thing about qsort is that it doesn't care about the data it sorts — in fact, it doesn't know what data it sorts. Rather, its input type is a typeless pointer ( void* ) which is just C's way of saying “I don't care about the type of data” (this is also called type erasure). The important point is that the implementation of qsort always stays the same, regardless of data type. The only thing that has to change is the compare function, which differs from data type to data type. qsort therefore expects the user to provide said compare function as a function argument.

    • Encapsulation and abstraction go hand in hand so much so that you could make the point that they are truly inseparable. For practical purposes, this is probably true; that said, here's an encapsulation that's not much of an abstraction: 

    class point {
    numeric x
    numeric y
}

    We encapsulate the point's coordinate, but we don't materially abstract them away, beyond grouping them logically.

    And here's an example of abstraction that's not encapsulation: 

    T pi<T> = 3.1415926535

    This is a generic variable pi with a given value (π), and the declaration doesn't care about the exact type of the variable. Admittedly, I'd be hard-pressed to find something like this in real code: abstraction virtually always uses encapsulation. However, the above does actually exist in C++(14), via variable templates (= generic templates for variables); with a slightly more complex syntax, eg: 

    template <typename T> constexpr T pi = T{3.1415926535};

    Encapsulation is hiding the implementation details which may or may not be for generic or specialized behavior(s).

    Abstraction is providing a generalization (say, over a set of behaviors).

    Here's a good read: Abstraction, Encapsulation, and Information Hiding by Edward V. Berard of the Object Agency.

    encapsulation puts some things in a box and gives you a peephole; this keeps you from mucking with the gears.

    abstraction flat-out ignores the details that don't matter, like whether the things have gears, ratchets, flywheels, or nuclear cores; they just "go"

    examples of encapsulation:

  • underpants
  • toolbox
  • wallet
  • handbag
  • capsule
  • frozen carbonite
  • a box, with or without a button on it
  • a burrito (technically, the tortilla around the burrito)

    • examples of abstraction:

  • "groups of things" is an abstraction (which we call aggregation)
  • "things that contains other things" is an abstraction (which we call composition)
  • "container" is another kind of "things that contain other things" abstraction; note that all of the encapsulation examples are kinds of containers, but not all containers exhibit/provide encapsulation. A basket, for example, is a container that does not encapsulate its contents.
    • 链接地址: http://www.djcxy.com/p/24036.html

    上一篇: 封装与抽象？

    下一篇: 抽象和封装之间的区别？