君，已阅读到文档的结尾了呢~~
豆丁精品文档： xtal1封装 tlp281 1封装 接口与抽象类的区别 抽象与接口的区别 抽象思维与具象思维 接口与抽象类 具体劳动与抽象劳动 抽象类与抽象方法 抽象与移情 电子与封装
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
抽象与封装-1
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='/DocinViewer-4.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口2630人阅读
转载请备注出自于：http://blog.csdn.net/qq_/article/details/
1.定义：隐藏对象的属性和实现细节，仅对外公开接口,控制在程序中属性的读和修改的访问级别。
2.封装的目的是：增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。
3.封装的基本要求是:把所有的属性私有化，对每个属性提供getter和setter方法，如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数。在开发的时候经常要对已经编写的类进行测试，所以在有的时候还有重写toString方法，但这不是必须的。
1.目的：实现代码的复用。
2.介绍：当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。继承后子类自动拥有了父类的属性和方法，但特别注意的是，父类的私有属性和构造方法并不能被继承。另外子类可以写自己特有的属性和方法，目的是实现功能的扩展，子类也可以复写父类的方法即方法的重写。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。有时候我们需要这样的需求：我们需要将某些事物尽可能地对这个世界隐藏，但是仍然允许子类的成员来访问它们。这个时候就需要使用到protected。
1.概念：相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。
2. Java实现多态有三个必要条件：继承、重写、向上转型。
&&&&&&&&&继承：在多态中必须存在有继承关系的子类和父类。
&&&&&&&&&重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
&&&&&&&&&向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。
&&&&&&只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。
3.多态的实现方式：
（1）基于继承实现的多态
&&&&&&基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。
（2）基于接口实现的多态
&&&&&&继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。
&&&&&&在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。
&&&&&&继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。
4.多态性主要表现在如下两个方面:
(1)方法重载.通常指在同一个类中,相同的方法名对应着不同的方法实现,但是方法的参数不同.
(2)成员覆盖.通常指在不同类(父类和子类)中,允许有相同的变量名,但是数据类型不同;也允许有相同的方法名，但是对应的方法实现不同.
5.多态的好处：程序的可扩展性及可维护性增强。
1.介绍：在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、 设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象，我们不能把它们实例化（拿不出一个具体的东西）所以称之为抽象。
　　比如：我们要描述“水果”，它就是一个抽象，它有质量、体积等一些共性（水果有质量），但又缺乏特性（苹果、橘子都是水果，它们有自己的特性），我们拿不出唯一一种能代表水果的东西（因为苹果、橘子都不能代表水果），可用抽象类来描述它，所以抽象类是不能够实例化的。当我们用某个类来具体描述“苹果”时，这个类就可以继承描述“水果”的抽象类，我们都知道“苹果”是一种“水果”。
2.抽象方法：被abstract修饰的方法是抽象方法，抽象方法没有方法体。修饰符 abstract 返回值类型 函数名();抽象方法的修饰符只能用public或者protected或者没有修饰，不能被final，static，private修饰。
（1）、类即使不包含抽象方法，也可以定义成抽象类。
（2）、类中含有抽象方法的类一定要定义成抽象类。
（3）、抽象类中字段的定义和子类的访问与一般类没有变化。
（4）、扩展抽象类有两种方法，第一种是在子类中定义部分抽象方法或者抽象方法不定义，这样子类也必须定义成抽象类，第二种是定义全部的抽象方法，这样子类就可以不定义成抽象的了。
（5）、抽象类不能被实例化，但是可以定义一个抽象类的对象变量，这个变量可以引用非抽象子类的对象。
（6）、抽象类中包含有构造方法，也可以显式书写构造方法，构造方法在实例化子类的对象中调用。
接口与抽象类的区别:
1、接口可以多实现，而抽象类只能单继承
2、抽象类可以有非抽象的方法和构造方法、变量，但是接口只能有抽象方法，静态常量。
3、抽象类和子类具有父子关系，子类能拥有父类中一些属性。接口虽然某个类实现一个接口，但是由于接口中的变量都为静态常量，不存在继承关系。
1、无论接口还是抽象类，都无法直接实例化，其自身实例化需要靠实现类或子类来实现。
2、接口和抽象类都必须实现其中的所有方法。
抽象类（abstract class）的定义方式如下：&
public abstract class AbstractClass&&&&&&&&&&&& //里面至少有一个抽象方法
&　　& //普通数据成员
　　&public abstract void method1();&& //抽象方法，抽象类的子类在类中必须实现抽象类中的抽象方法
&　　public abstract void method2();&
&　　public void method3();&& //非抽象方法
&　　public int method4();
&　　publi int method4 (){
&&&&& 　　……&//抽象类中可以赋予非抽象方法方法的默认行为，即方法的具体实现
&&&&&& public void method3(){
&&&&& 　　……&//抽象类中可以赋予非抽象方法方法的默认行为，即方法的具体实现
接口（interface）的定义方式如下：&
public interface Interface
&　　& //接口中不能有普通数据成员，只能够有静态的不能被修改的数据成员,static表示全局，final表示不可修改，可以不用static final&修饰，会隐式的声明为static和final
　　 public void method1();& //接口中的方法一定是抽象方法，所以不用abstract修饰
&　　public void method2();&&//接口中不能赋予方法的默认行为，即不能有方法的具体实现
1、一个接口可以被多个类实现，一个类也可以实现多个接口。
2、接口中所有的定义的字段默认都是public static final 的属性，写和不写没有区别。
3、接口中的方法都是抽象的方法，并且抽象的方法默认都是public abstract修饰的，不能用其他的修饰符修饰，可以不写。
4、接口中没有构造方法
5、接口不是类，尤其不能使用new运算符实例化一个接口。但是可以声明接口的变量，这个变量可以指向实现了此接口的子类。
简言之抽象类是一种功能不全的类，接口只是一个抽象方法声明和静态不能被修改的数据的集合，两者都不能被实例化。
　　从某种意义上说，接口是一种特殊形式的抽象类，在ｊａｖａ语言中抽象类表示的是一种继承关系，一个类只能继承继承一个抽象类，而一个类却可以实现多个接口。在许多情况下，接口确实可以代替抽象类，如果你不需要刻意表达属性上的继承的话。
&super的用法：
1.&&&&&子类的构造函数如果要引用super的话，必须把super放在函数的首位.
class&Base {
&&&&Base() {
&&&&&&&System.out.println(&Base&);
public&class&Checket&extends&Base {
&&&&Checket() {
&&&&&&&super();//调用父类的构造方法，一定要放在方法的首个语句
&&&&&&&System.out.println(&Checket&);
&&&&public&static&void&main(String argv[]) {
&&&&&&&Checket&c&=&new&Checket();
&&&&&&&&&&如果想用super继承父类构造的方法，但是没有放在第一行的话，那么在super之前的语句，肯定是为了满足自己想要完成某些行为的语句，但是又用了super继承父类的构造方法。那么以前所做的修改就都回到以前了，就是说又成了父类的构造方法了。
2．&&&&&&&在java中，有时还会遇到子类中的成员变量或方法与超类（有时也称父类）中的成员变量或方法同名。因为子类中的成员变量或方法名优先级高，所以子类中的同名成员变量或方法就隐藏了超类的成员变量或方法，但是我们如果想要使用超类中的这个成员变量或方法，就需要用到super.
&class&Country {
&&&&String&
&&&&void&value() {
&&&&&&&name&=&&China&;
class&City&extends&Country {
&&&&String&
&&&&void&value() {
&&&&name&=&&Hefei&;
&&&&super.value();//不调用此方法时，super.name返回的是父类的成员变量的值null
&&&&&&&System.out.println(name);
&&&&&&&System.out.println(super.name);
&&&&public&static&void&main(String[] args) {
&&&&&&&City c=new&City();
&&&&&&&c.value();
&&&&&&&&&为了在子类中引用父类中的成员变量name和方法value()，在代码中使用了super、super.name和super.value(),若不调用super.value()时，super.name返回父类成员变量默认值null,调用此方法时，super.value()方法把成员变量name赋值为China,再利用super.name调用父类的成员变量的值。
&&&&&另外，要注意的是super.name调用的是成员变量的值，
class&Country {
&&&&String&name=&xianfan&;
&&&&String value(String name) {
&&&&&&&name =&&China&;
&&&&&&&return&
class&City&extends&Country {
&&&&String&
&&&&String value(String name) {
&&&&name =&&Hefei&;
super.value(&失败&);//不调用此方法时，super.name返回的是父类的成员变量的值null
&&&&&&&System.out.println(name);
&&&&&&&System.out.println(super.name);
&&&&&&&return&
&&&&public&static&void&main(String[] args) {
&&&&&&&City c=new&City();
&&&&&&&c.value(&成功&);
&&&&结果为：Hefei
&&&&&此时，super.name返回的值是父类成员变量的值xianfan,而此时的super.value()方法是不起作用的。
3．用super直接传递参数：
&&class&Person {
&&&&public&static&void&prt(String s) {
&&&&&&&System.out.println(s);
&&&&Person() {
&&&&&&&prt(&A Person.&);
&&&&Person(String name) {
&&&&&&&prt(&A person name is:&&+ name);
public&class&Chinese&extends&Person {
&&&&Chinese() {
&&&&&&&super();&//&调用父类构造函数（1）
&&&&&&&prt(&A chinese.&);// (4)
&&&&Chinese(String name) {
&&&&&&&super(name);//&调用父类具有相同形参的构造函数（2）
&&&&&&&prt(&his name is:&&+ name);
&&&&Chinese(String name,&int&age) {
&&&&&&&this(name);//&调用当前具有相同形参的构造函数（3）
&&&&&&&prt(&his age is:&&+ age);
&&&&public&static&void&main(String[] args) {
&&&&&&&Chinese&cn&=&new&Chinese();
&&&&&&&cn =&new&Chinese(&kevin&);
&&&&&&&cn =&new&Chinese(&kevin&, 22);
&&&&&&结果为：A Person.
A chinese.
A person name is:kevin
his name is:kevin
A person name is:kevin
his name is:kevin
his age is:22
&&&&&&&&&&在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道了。
&this的用法：“this是指向对象本身的一个指针”
说明在什么情况下需要用到this：
&&&&&&&&第一、通过this调用另一个构造方法，用发是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。
&&&&&&&&第二、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this。
&&&&&&&&第三、在函数中，需要引用该函所属类的当前对象时候，直接用this。
super和this的异同：
&&&&&&&1)super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）&
& & & &2)this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
& & & &3)super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名&&&&super.成员函数据名（实参）
& & & 4)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）
& & & 5）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
& & & 6）super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。
　 &7）super()和this()均需放在构造方法内第一行。
　 &8）尽管可以用this调用一个构造器，但却不能调用两个。
　 &9）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
　10）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
　11）从本质上讲，this是一个指向本对象的指针,&然而super是一个Java关键字。
以下是关于子类父类的构造方法的注意事项：
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：28088次
排名：千里之外
原创：24篇
转载：18篇
(1)(32)(10)haolloyin 的BLOG
用户名：haolloyin
文章数：107
评论数：414
访问量：1396003
注册日期：
阅读量：5863
阅读量：12276
阅读量：357371
阅读量：1054010
51CTO推荐博文
这学期上《计算机系统结构》这门课，用的是张晨曦老师编写的教材，任课老师一直赞本书多么权威（的确权威，该本书有一个内容丰富的配套网站）。这么一说就激起同学们不得不认真学习书中知识的热情了。&
自从大学接触计算机以来，我对于计算机体系结构的理解从来都是上层（如应用程序）封装下层（如操作系统）的具体实现细节，由下层向上层提供相应的服务，前提是上层必须服务下层所公开的API（或者说协议、规约等）。&
上面的这种看待计算机的观点就如书中这种下层为上层提供基础的多层次结构体系（注意书中是说从计算机语言的角度，把计算机系统按功能划分的），如下：
注意到图片中在&软件&层次上的4个分层中都有&虚拟机&一词，想到了Java虚拟机（JVM）。从计算机语言的角度上看，我认为计算机系统的确是这样上层封装下层并不断抽象出一个适合当前用户理解能力的视图。譬如，不是每个人都能够掌握CPU层级的微程序指令，那么就往上封装一下称为机器语言；但机器语言又是天书般难懂，那就只得再一层层往上封装直至恰当的抽象层次了。&
这种不断封装、抽象的机制不仅帮助计算机用户只关注于当前自己需要理解的层面，减少对于底层具体实现细节理解负担，还从另一方面使得计算机的底层知识对用户透明。而这种透明正是底层实现细节能够脱离于具体用户而灵活改变实现的基础，同时也保证了计算机系统的安全性。&
基于这种层层封装、抽象的角度来看待计算机系统，我们就将其理解为上层调用下层服务的工作流程。然而，一旦转换个角度来看，结构恰好不是这样子的。看了高焕堂老师的《Android应用框架原理与程序设计36技》对于框架的讲解，很惊讶于其看待操作系统与应用程序的关系，当然这两者之间还隔着应用框架这一至关重要的层次。&
按照原来的看待角度得到的视图如下：
转换一种层次来看的话，计算机的不同模拟层次结构如下：
&&&&&& 书中高焕堂老师称第一种为&常见的迷思&，而第二种为&较合理的观点&。之所以会有第二种看法，接下来读着高老师对应用框架的魅力&&控制反转（IoC）的讲解就能大概地有些许了解了。
&&&&&& 我的理解，在这里应用框架是作为应用程序与操作系统之间进行沟通的桥梁，也可以理解为操作系统提供给外部应用程序的API，即统一的接口。这样子我们就可以比较理解平时在Windows下安装软件（应用程序）这一过程和目的了。安装软件的目的是向操作系统注册该软件的身份（大概注册表的存在与用途就是这原因吧），而在使用时则由应用框架来动态地（即书中写道&主控者是应用框架，而不是应用程序&）选择适合用户要求的服务。应用程序在这里只被当作是一种事前已向操作系统注册，使用时通过应用框架来动态调用的一种服务。
&&&&&& 但是话说回来，平时我们明明是针对操作系统上已安装的某个应用程序来使用我们的计算机的，这第二种看法似乎也有点让人迷糊。我的看法是，怎么看待都是合理的，造成所看待视图的差异的原因只是因为我们不同的人对同一事物有不同的关注点，甚至同一个人在面对同一事物时，也会因为在不同情境下对该事物的期望不同而造成差异。一句话就是：角度不同，抽象层面不同！
&&&&&& 对于控制反转（IoC）还不甚了解，模模糊糊说不出来，好像很大程度上就是涉及到多态机制的运用。只待在接下来的学习中能多点注意这方面的知识了。
本文出自 “” 博客，请务必保留此出处
了这篇文章
类别：┆阅读(0)┆评论(0)<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
您的访问请求被拒绝 403 Forbidden - ITeye技术社区
您的访问请求被拒绝
亲爱的会员，您的IP地址所在网段被ITeye拒绝服务，这可能是以下两种情况导致：
一、您所在的网段内有网络爬虫大量抓取ITeye网页，为保证其他人流畅的访问ITeye，该网段被ITeye拒绝
二、您通过某个代理服务器访问ITeye网站，该代理服务器被网络爬虫利用，大量抓取ITeye网页
请您点击按钮解除封锁&抽象和封装之间的区别？-oop,封装encapsulation,抽象abstraction-CodeGo.net
抽象和封装之间的区别？
什么是封装和抽象之间的精确区别？
本文地址 ：CodeGo.net/44128/
-------------------------------------------------------------------------------------------------------------------------
1. 先验，他们已经得到了什么
这里面向对象的封装，但最开始的答案早得多，是一种封装：
point x = { 1, 4 };
point y = { 23, 42 };
int d = distance(x, y);
在这里，distance封装在一个平面上两点之间的（欧几里德）距离的计算：它隐藏的细节。这是封装，纯粹而简单。
抽象是概括的过程：以一个具体并使其适用于不同的，尽管相关的 CodeGo.net，各种类型的数据。抽象的经典的例子是C的qsort函数，数据排序。
有关的东西qsort是，它不关心它排序的数据-实际上，它不知道它是什么排序的数据。相反，它的输入类型是无类型指针（void*），它只是说“我不关心数据的类型”（这也被称为类型擦除）：C的方式。重要的一点是，为qsort总是停留在不考虑数据类型。有改变的唯一一件事就是函数，它不同于数据类型的数据类型。qsort因此，希望提供的函数函数
封装是躲在这可能会或可能不会成为通用或专用的行为（S）的细节。
抽象是提供一个泛化（比如，在一组行为）。
这里有一个很好看的：抽象，封装，和信息的对象局爱德华五贝拉尔隐藏。
封装使事情在一个盒子里，并给你一个窥视孔，这让你从与gears碴。
抽象平了忽略无关紧要的细节，喜欢的东西是否有gears，棘轮，飞轮，或核核心，他们只是“走出去”
抽象可以让你在什么样的对象呢，而不是如何做
隐藏的对象如何做内部细节
就像当你开车，你知道油门踏板做，但你可能不知道它背后被封装的过程。
给在C＃中的例子。假设你有一个整数：
int Number = 5;
string aStrNumber = Number.ToString();
你喜欢则Number.toString（），它返回你数5个字符表示，并存储在一个字符串对象。告诉你它做什么，而不是如何做。
封装：是从隐藏的对象不需要的/非预期/礼仪细节。
List&string& list = new List&string&();
list.Sort(); /* Here, which sorting algorithm is used and hows its
implemented is not useful to the user who wants to perform sort, that's
why its hidden from the user of list. */
抽象：是提供一般化，因此方法具有丰富多样性的对象一起工作的方式。例如
class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane's Design says:
// Aeroplane is a flying object
// Aeroplane can be fueled
// Aeroplane is a Machine
// But the code related to Pilot, or Driver of Aeroplane is not bothered
// about Machine or Fuel. Hence,
// pilot code:
IFlyable flyingObj = new Aeroplane();
flyingObj.Fly();
// fighter Pilot related code
IFlyable flyingObj2 = new FighterAeroplane();
flyingObj2.Fly();
// UFO related code
IFlyable ufoObj = new UFO();
ufoObj.Fly();
// **All the 3 Above codes are genaralized using IFlyable,
// Interface Abstraction**
// Fly related code knows how to fly, irrespective of the type of
// flying object they are.
// Similarly, Fuel related code:
// Fueling an Aeroplane
IFuelable fuelableObj = new Aeroplane();
fuelableObj.FillFuel();
// Fueling a Car
IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { }
fuelableObj2.FillFuel();
// ** Fueling code does not need know what kind of vehicle it is, so far
// as it can Fill Fuel**
抽象：只显示。让我们在开关上的例子并不需要知道所发生的，而系统仍然加载（从隐藏
让我们再举一个例子，该ATM机。在不需要知道机器如何读取引脚和处理交易，所有他需要做的就是输入PIN码，拿现金走人。
封装：处理躲在它的CLAS因此部分私有化的敏感数据。它是通过使不从外部访问它保持私有给客户端的方法。
另一个例子：
假设我创建了这样一个不变的Rectangle类：
class Rectangle {
Rectangle(int width, int height) : width_(width), height_(height) {}
int width() const { return width_; }
int height() const { return height_; }
int width_;
int height_;
现在，我已经封装宽度和高度（访问限制），但我没有抽象的东西（好吧，也许我忽略了其中的矩形位于坐标空间，但这是示例的缺陷） 。
好意味着良好的封装。
好抽象的例子是一个通用的数据库连接类。它的公共接口是数据库无关的，而且很简单，但做我想要的连接。而你看到了什么？还有封装目前，这个类必须拥有所有低级别的句柄，并调用里面。
防止免受蓄意或意外的外部函数的特定对象的数据称为“数据封装”
较重要的函数，而不包括背景细节或解释的行为被称为抽象
抽象：呈现在一个简化的/不同的方式，这是不是更容易理解或更中肯的情况的想法。
想想看，发送电子邮件一类...抽象本身展现给你的那种男孩，所以你可以调用emailSender.send（邮件，收件人）。它实际上是什么-选择POP3 / SMTP，调用服务器，MIME翻译等，是抽象化了。你只看到男孩。
封装：保护和隐藏是私有的对象数据的想法。它涉及更多的制作与独立，万无一失。
举例来说。我概括了我的心脏速率从世界其他地方。我不想让任何人改变这个变量，我不需要任何人来设置它才能正常工作。它非常重要，但你并不需要知道它是什么，你可能不反正不在乎。
看看你的周围会发现你触摸，几乎一切都是既抽象和封装的例子。您的手机，例如呈现给您的是能够把你说的话，说出来的抽象东西-覆盖了GSM，处理器架构，无线电频率，以及你不明白或关心到一百万其他的东西。它也可以对某些数据来自你，就像序列号，ID号，频率等
这一切都使得世界成为一个更好的地方住在：D
封装被包裹在一个胶囊是类＆因此封装...
而抽象是一个对象，它区别于其它对象的特性...
抽象可以通过制作具有一个或抽象类的抽象来实现。这是什么，但应该是通过扩展它的类的特性。
例如当你发明/设计一个车，你定义一个特征样车应该有4个门，rest，方向盘等......所以这样的设计应该包括这个特性。是不是每一个抽象的头。它只是将其定义应包括的特性。
封装是实现保持数据和行为在一个胶囊是类与由像访问修饰符的公共，private，以及继承，聚集保护所以你只只显示需要的东西，那也只限于你想要显示。即公共，保护，友好和privateKA丰达......
例如通用自动决定上述的抽象设计。但是他们有具有特色和几乎做函数的产品。于是，他们写它扩展了上面抽象类的类。它说，gears箱应该如何工作，rest应如何运作，方向盘应该如何工作。然后，所有的产品函数。他们需要不知道怎么gears箱的作品或断开的作品，或转向风团的作品。 Indivisual产品一定能有一个像/ c或自动锁定等更多的函数.....
两者都是强大的，抽象需要比封装更多的技能和更大的应用/产品无法与抽象出来生存。
让我们来堆叠的例子。它可以使用数组或链表。但是它支持的操作是push和pop。现在，抽象只露出接口push和pop。底层表示被隐藏（它是一个数组还是一个链表？），并提供一个定义良好的接口。现在，你如何确保没有意外的访问是对抽象的数据？这就是封装。对于在C ++类，例如使用access-specifier这确保意外的访问和修改是可以避免的。并且还通过使接口为公共的，它保证了操纵堆栈中的唯一方法是通过良好定义的接口。在这个过程中，它已耦合的数据，并可以对其进行操作的代码。 （让我们不要到这里所涉及的友元函数）。这是代码和数据被粘合在一起或绑定或包封
封装手段，隐藏数据的getter和setter等。
使用抽象类和接口等的抽象表示，藏身
欲了解更多详情：
Abstraction和Encapsulation一个广义的例子
我们的计算器的计算问题！
class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane's Design says:
// Aeroplane is a flying object
// Aeroplane can be fueled
// Aeroplane is a Machine
// But the code related to Pilot, or Driver of Aeroplane is not bothered
// about Machine or Fuel. Hence,
// pilot code:
IFlyable flyingObj = new Aeroplane();
flyingObj.Fly();
// fighter Pilot related code
IFlyable flyingObj2 = new FighterAeroplane();
flyingObj2.Fly();
// UFO related code
IFlyable ufoObj = new UFO();
ufoObj.Fly();
// **All the 3 Above codes are genaralized using IFlyable,
// Interface Abstraction**
// Fly related code knows how to fly, irrespective of the type of
// flying object they are.
// Similarly, Fuel related code:
// Fueling an Aeroplane
IFuelable fuelableObj = new Aeroplane();
fuelableObj.FillFuel();
// Fueling a Car
IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { }
fuelableObj2.FillFuel();
// ** Fueling code does not need know what kind of vehicle it is, so far
// as it can Fill Fuel**
抽象隐藏数据
和封装的数据绑定到一起胶囊（一类）。
我认为封装是办法，我们实现的抽象。
本文标题 ：抽象和封装之间的区别？
本文地址 ：CodeGo.net/44128/
Copyright (C) 2014 CodeGo.net