面向对象编程最重要的特征就是封装性(也可称作抽象性)、继承性和多态性，那么，作为面向对象编程语言，Java在这方面更是有其出色之处：
1、“继承性是软件复用的一种形式，对降低软件复杂性行之有效。继承性同时是面向对象程序设计语言的特点，采用对象但没有继承性的语言是基于对象的语言，但不是面向对象的语言，这是两者的区别”
类之间的继承关系是现实世界中遗传关系的直接模拟，它表示类之间的内在联系以及对属性和操作的共享，即子类可以沿用父类（被继承类）的某些特征。当然，子类也可以具有自己独立的属性和操作
继承性是软件复用的一种形式。新类由已存在的类生成，通过保留它们的属性和行为，并且根据新类的要求对性能加以修改，添加新的属性和行为。如果子类只从一个父类继承，则称为单继承；如果子类从一个以上父类继承，则称为多继承。注意Java不支持多重继承，但它支持“接口”概念。接口使Java获得了多重继承的许多优点，摒弃了相应的缺点。注意：C++支持多继承
1、继承关系的定义：
[修饰符]class子类名 extends父类名,父类名2
父类名跟在extends
关键字后面，用来说明当前类是哪个已经存在类的子类，存在继承关系。
定义 雇员类 Employee的两个子类：
一般雇员类:CommonEmployee
主 管 类:ManagerEmployee
子类从父类继承有两个主要的方面：
（1）属性的继承。例如，公司是一个父类，一个公司有名称、地址、经理、雇员等，这些都属于结构方面。
（2）方法的继承。一个父类定义了若干操作，如一个公司要有项目、利润、任命经理、录用职工等操作，子公司也将继承这些行为s;mpclassCommonEmployeeextends Employee／／子类1：
{
intm_ManagerNo ;／／定义类属性m _ManagerNo，代表雇员上司的编号
}
classManagerEmployeeextends Employee ／／子类2：
{
intm_SecretaryNo； ／／定义类属性m_SecretaryNo，代表秘书的编号
}
（1）子类不能访问父类的private成员，但子类可以访问其父类的public，
（2）protected访问是public和private访问之间一个保护性的中间层次。
（3）由于被继承的父类成员没有在子类声明中列出，但是这些成员确实存在于子类中。在这里，要区分一下继承、覆盖与重载这几个易混淆的概念：
1、只有方法这一概念层面，这三个概念才易混淆：
2、方法继承
对于子类对象，可以使用父类中的方法。即使这些方法没有明显地在子类中定义，它们也自动地从父类中继承过来了
方法覆盖
方法的覆盖是指：子类定义同名方法来覆盖父类的方法，是多态技术的一个实现。当父类方法在子类中被覆盖时，通常是子类版本调用父类版本，并做一些附加的工作。
有很多注意事项，这里，我主要提一下this与super，C++中有this（且与Java中中概念差不多）,但是没有super。
this表示的是当前对象本身，this代表当前对象的一个引用。可以理解为对象的另一个名字。利用this可以调用当前对象的方法和属性。
如：this.getName（）和getName（）在类中是一样的。
super表示的是当前对象的直接父类对象，是当前对象的父类对象的引用
方法重载
2、”多态性允许以统一的风格处理已存在的变量及相关的类，使增加系统中新功能变得容易“
这里，贴一下网上找的资料，能更清楚地将继承中需特别注意的多态、继承中的问题弄清:
Java的多态性 面向对象编程有三个特征，即封装、继承和多态。 封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。 继承是为了重用父类代码，同时为实现多态性作准备。那么什么是多态呢？ 方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。 要理解多态性，首先要知道什么是“向上转型”。 我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过 Cat c = new Cat(); 实例化一个Cat的对象，这个不难理解。但当我这样定义时： Animal a = new Cat(); 这代表什么意思呢？ 很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特， 定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。 所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的； 同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用； 对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。 看下面这段程序： class Father{ public void func1(){ func2(); } //这是父类中的func2()方法，因为下面的子类中重写了该方法 //所以在父类类型的引用中调用时，这个方法将不再有效 //取而代之的是将调用子类中重写的func2()方法 public void func2(){ System.out.println("AAA"); } } class Child extends Father{ //func1(int i)是对func1()方法的一个重载 //由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用 //所以在下面的main方法中child.func1(68)是不对的 public void func1(int i){ System.out.println("BBB"); } //func2()重写了父类Father中的func2()方法 //如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法 public void func2(){ System.out.println("CCC"); } } public class PolymorphismTest { public static void main(String[] args) { Father child = new Child(); child.func1();//打印结果将会是什么？ } } 上面的程序是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。重载后的func1(int i)和func1()不再是同一个方法，由于父类中没有func1(int i)，那么，父类类型的引用child就不能调用func1(int i)方法。而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。 那么该程序将会打印出什么样的结果呢？ 很显然，应该是“CCC”。 对于多态，可以总结它为： 一、使用父类类型的引用指向子类的对象（实际对象）； 二、该引用只能调用父类中定义的方法和变量； 三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用） 四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。 **************************************************************************************************************************** 多态详解(整理)2008-09-03 19:29多态是通过: 1 接口 和 实现接口并覆盖接口中同一方法的几个不同的类体现的 2 父类 和 继承父类并覆盖父类中同一方法的几个不同子类实现的. 一、基本概念 多态性：发送消息给某个对象，让该对象自行决定响应何种行为。 通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。 ava 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。 1. 如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。 2. 如果a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。 二、Java多态性实现机制 SUN目前的JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针： 一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另外一个指向类对象，表明该对象所属的类型）； 另一个指针指向一块从java堆中为分配出来内存空间。 三、总结 1、通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。 DerivedC c2=new DerivedC(); BaseClass a1= c2; //BaseClass 基类，DerivedC是继承自BaseClass的子类 a1.play(); //play()在BaseClass，DerivedC中均有定义，即子类覆写了该方法 分析： * 为什么子类的类型的对象实例可以覆给超类引用？ 自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass； * a.play()将执行子类还是父类定义的方法？ 子类的。在运行时期，将根据a这个对象引用实际的类型来获取对应的方法。所以才有多态性。一个基类的对象引用，被赋予不同的子类对象引用，执行该方法时，将表现出不同的行为。 在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。 2、不能把父类对象引用赋给子类对象引用变量 BaseClass a2=new BaseClass(); DerivedC c1=a2;//出错 在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。 c1=(DerivedC)a2; 进行强制转化,也就是向下转型. 3、记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。 你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。 其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。 例如，DerivedC类在继承BaseClass中定义的函数外，还增加了几个函数（例如 myFun()） 分析： 当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。 这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。 4、Java与C++多态性的比较 jvm关于多态性支持解决方法是和c++中几乎一样的， 只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中，但是利用某种技术来区别。 Java把类型信息和函数信息分开放。Java中在继承以后，子类会重新设置自己的虚拟函数表，这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类自己的虚拟函数。 虚拟函数调用是经过虚拟函数表间接调用的，所以才得以实现多态的。 Java的所有函数，除了被声明为final的，都是用后期绑定。 四. 1个行为,不同的对象,他们具体体现出来的方式不一样, 比如: 方法重载 overloading 以及 方法重写(覆盖)override class Human{ void run(){输出 人在跑} } class Man extends Human{ void run(){输出 男人在跑} } 这个时候,同是跑,不同的对象,不一样(这个是方法覆盖的例子) class Test{ void out(String str){输出 str} void out(int i){输出 i} } 这个例子是方法重载,方法名相同,参数表不同 ok,明白了这些还不够,还用人在跑举例 Human ahuman=new Man(); 这样我等于实例化了一个Man的对象,并声明了一个Human的引用,让它去指向Man这个对象 意思是说,把 Man这个对象当 Human看了. 比如去动物园,你看见了一个动物,不知道它是什么, "这是什么动物? " "这是大熊猫! " 这2句话,就是最好的证明,因为不知道它是大熊猫,但知道它的父类是动物,所以, 这个大熊猫对象,你把它当成其父类 动物看,这样子合情合理. 这种方式下要注意 new Man();的确实例化了Man对象,所以 ahuman.run()这个方法 输出的 是 "男人在跑 " 如果在子类 Man下你 写了一些它独有的方法 比如 eat(),而Human没有这个方法, 在调用eat方法时,一定要注意 强制类型转换 ((Man)ahuman).eat(),这样才可以... 对接口来说,情况是类似的... 实例: package domatic; //定义超类superA class superA { int i = 100; void fun(int j) { j = i; System.out.println("This is superA"); } } // 定义superA的子类subB class subB extends superA { int m = 1; void fun(int aa) { System.out.println("This is subB"); } } // 定义superA的子类subC class subC extends superA { int n = 1; void fun(int cc) { System.out.println("This is subC"); } } class Test { public static void main(String[] args) { superA a = new superA(); subB b = new subB(); subC c = new subC(); a = b; a.fun(100); a = c; a.fun(200); } } /* * 上述代码中subB和subC是超类superA的子类,我们在类Test中声明了3个引用变量a, b, * c,通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问： * "为什么(1)和(2)不输出：This is superA"。 * java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时, * 被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法, * 但是这个被调用的方法必须是在超类中定义过的, * 也就是说被子类覆盖的方法。 * 所以,不要被上例中(1)和(2)所迷惑,虽然写成a.fun(),但是由于(1)中的a被b赋值, * 指向了子类subB的一个实例,因而(1)所调用的fun()实际上是子类subB的成员方法fun(), * 它覆盖了超类superA的成员方法fun()；同样(2)调用的是子类subC的成员方法fun()。 * 另外,如果子类继承的超类是一个抽象类,虽然抽象类不能通过new操作符实例化, * 但是可以创建抽象类的对象引用指向子类对象,以实现运行时多态性。具体的实现方法同上例。 * 不过,抽象类的子类必须覆盖实现超类中的所有的抽象方法, * 否则子类必须被abstract修饰符修饰,当然也就不能被实例化了 */ 以上大多数是以子类覆盖父类的方法实现多态.下面是另一种实现多态的方法-----------重写父类方法 1.JAVA里没有多继承，一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。举例说明： //父类 public class Father{ //父类有一个打孩子方法 public void hitChild(){ } } //子类1 public class Son1 extends Father{ //重写父类打孩子方法 public void hitChild(){ System.out.println("为什么打我？我做错什么了！"); } } //子类2 public class Son2 extends Father{ //重写父类打孩子方法 public void hitChild(){ System.out.println("我知道错了，别打了！"); } } //子类3 public class Son3 extends Father{ //重写父类打孩子方法 public void hitChild(){ System.out.println("我跑，你打不着！"); } } //测试类 public class Test{ public static void main(String args[]){ Father father; father = new Son1(); father.hitChild(); father = new Son2(); father.hitChild(); father = new Son3(); father.hitChild(); } } 都调用了相同的方法，出现了不同的结果！这就是多态的表现！ ****************************************************************************************************************************import java.io.*;
class Super{
Super(){
System.out.println("This is super class!");
}
void method(){
System.out.println("Super's method");
}
}
class Sub extends Super{
Sub(){
super();
System.out.println("\n\t:and here is the child");
}
void method(){
System.out.println("child's method");
}
}
public class Super_Sub{
public static void main(String[] args){
Super sup=new Sub();
sup.method();
Sub child=(Sub)new Super();//这里，实际分配的内存是Super的，但是却用Child来指代它，这就是“向下转型”(父类冒充子类，因为子类在UML中画时是在下的嘛),必经强制类型转换
child.method();
}
}
对于数据来说，继承是否为正确的设计可以用一个简单的规则来判断。“is-a”规则表明子类的每一个对象都是一个超类的对象。例如，每一个经理是一个员工。然而，只有经理类是员工类的子类才是有意义的。很明显，反过来就不行了——并不是每个员工都是经理。
还有一个明确叙述“is-a”规则的方法是替代原则。该原则规定无论何时，如果程序需要一个超类对象，都可以用一个子类对象来代替
理解调用一个对象方法的机制是非常重要的。下面具体介绍：X.f；
（1）编译器检查对象的声明类型和方法名。
（2）接着，编译器检查方法调用中的参数类型。如果在所有的叫做f的方法中有一个其参数类型同调用提供的参数类型最匹配，那么该方法就会被选择调用。这个过程称作超载选择。（静态）
（3）当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用同x所指向的对象的实际类型相匹配的方法版本。
……
如果类中没有写构造函数，那么系统会自动为该类提供一个默认构造函数，该构造函数将所有的实例字段初始化为默认值：
……
包用途:
Java允许把多个类收集在一起成为一组，称作包（package）。包便于组织任务，以及使自己的任务和其他人提供的代码库相分离。
标准Java库被分类成许多的包，其中包括java.1ang、java.util和java.net等等。标准Java包是分层次的。就像在硬盘上嵌套有各级子目录一样，可以通过层次嵌套组织包。所有的Java包都在Java和Javax包层次内
已经看到，已有的库，比如JavaAPI中的类和接口，可以导入到Java程序中。
Java API中的每一个类和接口属于一个特定的包。它包含一组相关联的类和接口，实际是对类和接口进行组织的目录结构。
例如，假定文件名是MyClass.java。它意味着在那个文件有一个、而且只能有一个public类。而且那个类的名字必须是MyClass（包括大小写形式）：
packagemypackage;
publicclass MyClass
{
……
}
创建可复用的类的步骤简要说明如下：
（1）定义一个public类。如果类不是public，它只能被同一包中的其他类使用。
（2）选择一个包名，并把package语句加到可复用的类的源代码文件中。
（3）编译这个类。这样，它就被放到适当的包目录结构中，以供编译器和解译器使用。
（4）把这个可复用的类导入到需要用它的程序中。现在就可以使用它了。
注意 在 Java 语言中可以出现在类定义的括号外面的仅有两个语句，它们是 package 和 import。
例如，给出一个指向此包中的类的快捷方式。一旦使用import（导入）了以后，就不再需要给出完整的包名。
可以引入一个特定的类，也可以引入整个包。import语句要放在源文件的头部（但在所有package语句的下面）。例如，可以通过下面的语句引入在java.util包中的所有的类：
importjava.util.*;
然后，就可以使用
Datetoday=new Date();
而不需要在前面加上包名。也可以引入包中某个特定的类：
importjava.util.Date;
要把类放人一个包中，必须把此包的名字放在源文件头部，并且放在对包中的类进行定义的代码之前。例如，在文件Employee.java的开始部分如下：
packagecom.horstmann.corejava;
publicclass Employee
{
……
}
把包中的文件放入与此完整的包名相匹配的子目录中。例如，在包com.horstmann.corejava中的所有的类文件都必须放在子目录com/horstmann/core.java（Windows下的com\horstmann\corejava）下。这是最简单的一种方法
类被存储在文件系统的子目录中。类的路径必须与所在包名相匹配。
在前面的例子中，包目录com/horstmann/corejava是程序目录的一个子目录。然而这样安排很不灵活。一般，有多个程序需要访问包文件。为了使包可以在多个程序间共享，需要做以下事情：
1）把类放在一个或多个特定的目录中，比如/home/user/classdir。此目录是包树的基本目录。如果加入了类com.horstmann.corejava.Employee，那么此类文件必须位于子目录/home/user/classdir/com/horstmann/corejava下。
2）设置类路径。类路径是其子目录包含类文件的所有基本目录的集合。classpath
已经接触过public和private访问指示符。
被标记为Public的部件可以被任何类使用，而私有部件只能被定义它们的类使用。如果没有指定public或private，那么部件（即类、方法或变量）可以被同一个包中的所有方法访问。
为了简化面向对象的编程过程，Java系统事先设计并实现了一些体现了常用功能的标准类，如用于输入／输出的类，用于数学运算的类，用于图形用户界面设计的类，用于网络处理的类等。这些系统标准类根据实现的功能不同，可以划分成不同的集合，每个集合是一个包，合称为类库。可以引用这些包，也可以创建自己的包。
Java的类库是系统提供的已实现的标准类的集合，是Java编程的API，它可以帮助开发者方便、快捷地开发Java程序
接口主要作用是可以帮助实现类似于类的多重继承的功能。在Java中，出于简化程序结构的考虑，不再支持类间的多重继承而只支持单重继承，即一个类至多只能有一个直接父类。然而在解决实际问题的过程中，仅仅依靠单重继承在很多情况下都不能将问题的复杂性表述完整，需要其他的机制作为辅助。
Java中声明接口的语法如下：
[public] interface 接口名 [extends 父接口名列表]
{ //接口体;
//常量域声明
[public] [static] [final] 域类型 域名=常量值;
//抽象方法声明
[public] [abstract] 返回值 方法名(参数列表) [throw异常列表];
}
从上面的语法规定可以看出，定义接口与定义类非常相似，实际上完全可以把接口理解成为一种特殊的类，接口是由常量和抽象方法组成的特殊类
（1）接口中的属性都是用final修饰的常量，
（2）接口中的方法都是用abstract修饰的抽象方法，在接口中只能给出这些抽象方法的方法名、返回值和参数列表，而不能定义方法体，即仅仅规定了一组信息交换、传输和处理的“接口”
一个类要实现某个或某几个接口时，有如下的步骤和注意事项：
（1）在类的声明部分，用implements关键字声明该类将要实现哪些接口；
如下：
class类名implements接口{
}
（2）如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须实现指定接口的所有抽象方法，即为所有抽象方法定义方法体，而且方法头部分应该与接口中的定义完全一致，即有完全相同的返回值和参数列表；
（3）如果实现某接口的类是abstract的抽象类，则它可以不实现该接口所有的方法。
（4）一个类在实现某接口的抽象方法时，必须使用完全相同的方法头。
（5）接口的抽象方法，其访问限制符都已指定是public，所以类在实现方法时，必须显式地使用public修饰符。
小结：
多重继承是指一个子类继承多个父类。Java不支持多重继承，但Java提供了接口。
子类不能访问父类的private成员，但子类可以访问其父类的public，protected和包访问成员；要访问父类的包访问成员，子类一定要在父类的包内。
子类构造函数总是先调用（显式的或隐式地）其父类的构造函数，以创建和初始化子类的父类成员。
子类的对象可以当作其父类的对象对待，反之则不行（即向上转型）
protected访问是public和private访问之间一个保护性的中间层次。父类方法、子类方法和在同一个包内类的方法都能访问父类的protected成员，但其他方法均不能访问
一个子类对象引用可以隐式地转换成一个父类对象引用。使用显式的类型转换，可以把父类引用转换成子类引用。如果目标不是子类对象，将产生ClassCastException例外处理。
146
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
