Java-继承与多态
什么是继承，继承的特点？
子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。或子类从父类继承方法，使得子类具有父类相同的行为。
特点：在继承关系中，父类更通用、子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。
表示父类和子类的术语：父类和子类、超类和子类、基类和派生类，他们表示的是同一个意思。
为什么需要继承？什么时候应该继承？
使用继承可以有效实现代码复用，避免重复代码的出现。
当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。
继承实现了面向对象的原则：write once,only
once（编写一次、且只编写一次）
如何实现继承？
在java语言中，用extends（扩展）关键字来表示一个类继承了另一个类。
在父类中只定义一些通用的属性和方法。
子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法。或子类重新定义父类的属性、重写父类的方法可以获得与父类不同的功能。
什么是方法重写？
如果在子类中定义的一个方法，其名称、返回类型及参数列表正好与父类中某个方法的名称、返回类型及参数列表相匹配，那么可以说，子类的方法重写了父类的方法。
方法重写在不同类，是实现多态的必要条件。
注意：重写方法不能比被重写方法拥有更严格的权限访问。
super关键字的用法和位置，super关键字调用父类的构造方法，super关键字调用父类的方法？
在子类的构造方法中，通过super关键字调用父类的构造方法。
如果子类中重写了父类的方法，可以通过super关键字调用父类的方法。
private String
public xinxin1(String
name,String sex)
& &this.name=
& &this.sex=
public void
& &System.out.println(“嗨！我是” name
”我是” sex ”孩”);
public xinxin2(String
name,String sex)
& &//调用父类的构造方法
& &super(name,sex);
&//（这属于显示调用，即使子类的构造方法不写明调用父类的构造方法，也会默认调用父类无参构造方法，这叫隐式调用。）
public void
&System.out.println(“我是新来的！”);
& &//调用父类的方法
& &super.hello();
位置注意：调用父类的构造方法的语句（super语句）必须是构造方法中的第一条语句。
因为创建对象的时候，需要先创建父类对象，再创建子类对象。
注意：创建对象时，先创建父类对象，在创建子类对象。如果没有显示调用父类的构造方法，将自动调用父类的无参构造方法
一切类的老大（祖先）Object
所有类都直接或者间接地继承了java.lang.Object类，Object类中定义了所有的java对象都具有的相同行为，是所有类的祖先。
一个类如果没有使用extends关键字，那么这个类直接继承自Object类。
什么是多态？
多态的特征是表现出多种形态，具有多种实现方式。或者多态是具有表现多种形态的能力的特征。或者同一个实现接口，使用不同的实例而执行不同的操作。
为什么需要使用多态？多态的好处？
可以增强程序的可扩展性及可维护性，使代码更加简洁。
不但能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。
&如何实现多态？
一般做法是：写一个方法，它只接收父类作为参数，编写的代码只与父类打交道。调用这个方法时，实例化不同的子类对象（new一个对象）。
更具体的说：
（1）、子类重写父类的方法。使子类具有不同的方法实现。
（2）、把父类类型作为参数类型，该父类及其子类对象作为参数转入。
（3）、运行时，根据实际创建的对象类型动态决定使用那个方法。
在运行时，java虚拟机会根据实际创建的对象类型决定使用那个方法。一般将这称为动态绑定。
我们向来举个例子：比如：Student是Object的子类。
& Object o = new Student();
& 那么Student b =是否正确呢？答案是：错误的
& 这个o对象声明为Object,但实际上是一个Student的实例。
& 你要问为什么，解释一下，儿子肯定是爸爸的，但是爸爸却不一定是儿子的。
& 如果觉得这个解释很无厘头，那么再来一个比方，苹果是水果的子类
& 还有橘子呀，菠萝呀，突然好想吃水果...额，跑偏了。
这些都是水果，但苹果并不能代表所有的水果，你要必须进行显式转换 Fruit f = new Apple(); Apple a =
还有，你要是不确定可不可以进行对象间的转换，你可以使用instanceof()这个方法来判断两个对象是否可以相互转换。
多态小结：
多态与继承、方法重写密切相关，我们在方法中接收父类类型作为参数，在方法实现中调用父类类型的各种方法。当把子类作为参数传递给这个方法时，java虚拟机会根据实际创建的对象类型，调用子类中相应的方法（存在方法重写时）。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。Java中的继承、封装、多态、抽象
java 和某些面向对象语言(如 c++)在实现继承的不同之处在于java只支持单继承，不支持多重继承。即java 中一个类只能继承于另一个类。我们将被继承的类称之为父类（基类），继承类称之为子类(派生类)。在java 中用关键字extends 来实现单继承。实现继承关系的类之间有着必然的联系，不能将不相关的类实现继承，就象人类不能继承于鸟类！
那怎么去判断类和类之间是否有着必然联系呢？实际上，前面我们已知当某类A和类 B之间有着共同的属性和行为时，那么类A 和类 B之间就可能是继承关系或者有着共同的父类。继承带来了三个好处：减少代码冗余；维护变得简单；扩展变得容易。构造方法不能被继承！一个类得到构造构造方 法只有两种途径：自定义构造方法；使用JVM分配的缺省构造方法。但是，可以在子类中可以通过super关键字访问父类的构造方法。
继承:好比如你继承你老爸的事业，等于你有了你老爸一样的东西。
在程序里,以class A是爸，class B extends A代表B继承A，B也就有了A的一切，即属性与方法。
但不能拥有你爸爸的秘密的东西，比如他的日记，也就是不能继承私有属性与方法。
运行时多态性是面向对象程序设计代码重用的一个最强大机制，Java多态性的概念也可以被说成“一个接口，多个方法”。Java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制。
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种 表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方 法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。方法的重写Overriding和重载Overloading是Java多态性的不同表现。
多态性：发送消息给某个对象，让该对象自行决定响应何种行为。
通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用
所有编程语言的最终目的都是提供一种“抽象”方法。
汇编语言是对基础机器的少量抽象。后来的许多“命令式”语言（如FORTRAN，BASIC 和C）是对汇编语言的一种抽象。与汇编语言相比，这些语言已有了长足的进步，但它们的抽象原理依然要求我们着重考虑计算机的结构，而非考虑问题本身的结构。在机器模型（位于“方案空间”）与实际解决的问题模型（位于“问题空间”）之间，程序员必须建立起一种联系。这个过程要求人们付出较大的精力，而且由于它脱离了编程语言本身的范围，造成程序代码很难编写，而且要花较大的代价进行维护。为机器建模的另一个方法是为要解决的问题制作模型。对一些早期语言来说，如LISP 和APL，它们的做法是“从不同的角度观察世界”——“所有问题都归纳为列表”或“所有问题都归纳为算法”。PROLOG 则将所有问题都归纳为决策链。对于这些语言，我们认为它们一部分是面向基于“强制”的编程，另一部分则是专为处理图形符号设计的。每种方法都有自己特殊的用途，适合解决某一类的问题。但只要超出了它们力所能及的范围，就会显得非常笨拙。
面向对象的程序设计在此基础上则跨出了一大步，程序员可利用一些工具表达问题空间内的元素。由于这种表达非常普遍，所以不必受限于特定类型的问题。我们将问题空间中的元素以及它们在方案空间的表示物称作“对象”（Object）。当然，还有一些在问题空间没有对应体的其他对象。通过添加新的对象类型，程序可进行灵活的调整，以便与特定的问题配合。所以在阅读方案的描述代码时，会读到对问题进行表达的话语。与我们以前见过的相比，这无疑是一种更加灵活、更加强大的语言抽象方法。总之，OOP 允许我们根据问题来描述问题，而不是根据方案。然而，仍有一个联系途径回到计算机。每个对象都类似一台小计算机；它们有自己的状态，而且可要求它们进行特定的操作。与现实世界的“对象”或者“物体”相比，编程“对象”与它们也存在共通的地方：它们都有自己的特征和行为。
封装是JAVA面向对象的特点的表现，封装是一种信息隐蔽技术它有两个含义，即把对象的全部属性和
全部服务结合在一起，形成一个不可分割的独立单位，以及尽可能隐藏对象的内部结构，也就是说，如果
我们使用了封装技术的话，别人就只能用我们做出来的东西而看不见我们做的这个东西的内部结构了。
封装:就是遥控车一样，你有个遥控，就能控制车子，但你是看不到遥控的电路设计的，因为你不必
要知道，为什么要封闭，就怕你乱接电路，让遥控用不了。
程序里，在属性和方法前面加上private关键字，就表示封闭属性和方法了，只能类的内部访问。
在java中是通过各种访问限定符来实现数据封装的，共分为四种访问级别(由高到低)：
private(私有)、friendly(缺省)、protected(受保护)、public(公共)。注意：以上四种访问修饰符可以
作用于任何变量和方法，类只可以定义为默认或公共级别(嵌套类除外)。
public(公共)
当变量或方法被public修饰时，该变量和方法可以在任何地方(指的是任何包中)的任何类中被访问；
protected(受保护的)
当类的变量或方法被 protected 修饰时，该变量和方法只可以在同包中的任何类、不同包中的任何当前
类的子类中所访问。即不同包中的任何不是该类的子类不可访问级别为protected的变量和方法。
friendly(缺省的)
当类的变量和方法没有显式地被任何访问区分符修饰时，该变量和方法的访问级别是缺省的。缺省的变量
和方法只能在同包的类中访问。
private(私有的)
被 private 所修饰的所有变量和方法只能在所属类中被访问。即类的私有成员和变量只能在当前类中被
浏览: 23388 次
&从接下来我们出发&下的第一个程序，总结的 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
标签：至少1个，最多5个
版权声明：本文由吴仙杰创作整理，转载请注明出处：
1. 面向对象编程的三大特性
Java 面向对象编程有三大特性：封装、继承、多态。
1.1 封装（Encapsulation）
隐藏对象的属性和实现细节，仅对外公开访问方法，控制在程序中属性的读和写的访问级别。
1.1.1 封装的目的
增强安全性和简化编程，使用者不必了解具体的实现细节，而只要通过对外公开的访问方法，来使用类的成员。
1.1.2 封装的基本要求
把所有的属性私有化。
对每个属性提供 getter 和 setter 方法。
如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数。
建议重写 toString 方法，但这不是必须的。
1.2 继承（Inheritance）
可以理解为，在一个现有类的基础之上，增加新的方法或重写已有方法，从而产生一个新类。
我们在编写 Java 代码时，每一个类都是在继承。因为在 Java 中存在一个所有类的父类（基类、超类）：java.lang.Object。
1.2.1 继承和权限
子类不能继承父类中访问权限为 private 的成员变量和方法，也不能继承父类的构造方法。子类可以重写父类的方法，及命名与父类同名的成员变量。
有时候我们会有这样的需求：我们需要将某些事物尽可能地对这个世界隐藏，但是仍然允许子类的成员来访问它们。这个时候就需要使用到 protected。
类成员访问修饰符与访问能力之间的关系：
同一包中的子类
同一包中的非子类
不同包中的子类
不同包中的非子类
1.2.2 Java 中类的划分
Java 中类可分为以下三种：
普通类：使用 class 定义且不含有抽象方法的类。
抽象类：使用 abstract class 定义的类，它可以含有或不含有抽象方法。
接口：使用 interface 定义的类。
上述三种类存在以下的继承规律：
普通类可以继承（extends）普通类，可以继承（extends）抽象类，可以继承（implements）接口。
抽象类可以继承（extends）普通类，可以继承（extends）抽象类，可以继承（implements）接口。
接口只能继承（extends）接口。
上述的继承规律中，每种继承都有各自使用的关键字 extends 和 implements，不可混淆使用。
上述描述中，我们没有对 implements 关键字使用实现这种说法，是因为从概念上来讲，它也是一种继承关系，而且对于抽象类 implements 接口而言，它并不要求一定要实现这个接口中定义的方法。
各继承规律中的约束：
一个普通类或一个抽象类，要么继承一个普通类，要么继承一个抽象类，即所谓的单继承。
一个普通类或一个抽象类或一个接口，可以继承任意多个接口。
一个普通类继承一个抽象类后，必须实现这个抽象类中定义的所有抽象（abstract）方法，否则就只能被定义为抽象类。
一个普通类继承一个接口后，必须实现这个接口中定义的所有方法，否则就只能被定义为抽象类。
抽象类继承抽象类，或者实现接口时，可以部分、全部或者完全不实现父类抽象类的抽象（abstract）方法或父类接口中定义的方法。
1.2.3 继承的优点
继承给我们的编程带来的好处就是对原有类的复用（重用）。除了继承之外，我们还可以使用组合的方式来复用类。
所谓组合就是把原有类定义为新类的一个属性，通过在新类中调用原有类的方法来实现复用。从抽象概念上来讲，新定义类所代表的事物是原有类所代表的事物的一种，那么这时组合就是实现复用更好的选择。下面这个例子就是组合方式的一个简单示例：
public class BMW {
private Car car = new Car();
public void driveBMW() {
// 复用汽车类的通用驾驶方法
car.drive();
// 再写宝马车的特定驾驶方法
class Car {
public void drive() {
使用继承和组合复用原有的类，都是一种增量式的开发模式，这种方式带来的好处是不需要修改原有的代码，因此不会给原有代码带来新的 BUG，也不用因为对原有代码的修改而重新进行测试，这对我们的开发显然是有益的。因此，如果我们是在维护或者改造一个原有的系统或模块，尤其是对它们的了解不是很透彻的时候，就可以选择增量开发的模式，这不仅可以大大提高我们的开发效率，也可以规避由于对原有代码的修改而带来的风险。
1.3 多态（Polymorphism）
相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。
以下的例子，可帮助理解：
* 汽车接口
interface Car {
// 汽车名称
String getName();
// 获得汽车售价
int getPrice();
class BMW implements Car {
public String getName() {
return "BMW";
public int getPrice() {
return 300000;
class BENZ implements Car {
public String getName() {
return "BENZ";
public int getPrice() {
return 400000;
// 汽车出售店
public class CarShop {
// 售车收入
private int money = 0;
// 卖出一部车
public void sellCar(Car car) {
System.out.println("车型：" + car.getName() + "
单价：" + car.getPrice());
// 增加卖出车售价的收入
money += car.getPrice();
// 售车总收入
public int getMoney() {
public static void main(String[] args) {
CarShop carShop = new CarShop();
// 卖出一辆宝马
carShop.sellCar(new BMW());
// 卖出一辆奔驰
carShop.sellCar(new BENZ());
System.out.println("总收入：" + carShop.getMoney());
运行结果：
单价：300000
车型：BENZ
单价：400000
总收入：700000
继承是多态得以实现的基础。针对上面的示例，多态就是一种类型（都是 Car 类型）表现出多种状态（宝马汽车的名称是 BMW，售价是 300000；奔驰汽车的名称是 BENZ，售价是 400000）。
将一个方法调用同这个方法所属的主体（也就是对象或类）关联起来，分前期绑定和后期绑定两种。
前期绑定：在程序运行之前进行绑定，由编译器和连接程序实现，又叫做静态绑定。比如 static 方法和 final 方法，注意，这里也包括 private 方法，因为它是隐式 final 的。
后期绑定：在运行时根据对象的类型进行绑定，由方法调用机制实现，因此又叫做动态绑定，或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。
多态就是在后期绑定这种机制上实现的。
多态给我们带来的好处是消除了类之间的耦合关系，使程序更容易扩展。比如在上例中，新增加一种类型汽车的销售，只需要让新定义的类继承 Car 类并实现它的所有方法，而无需对原有代码做任何修改，CarShop 类的 sellCar(Car car) 方法就可以处理新的车型了。
1.3.1 实现多态的三个必要条件
继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。
只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。
1.3.2 多态的实现方式
基于继承实现的多态:
主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。
基于接口实现的多态:
在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例，在运行时，根据对象引用的实际类型来执行对应的方法。
继承都是单继承，只能为一组相关的类提供一致的服务接口。
接口是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。
2. 重载（overloading）重写（overriding）
重载和重写都是针对方法的概念，在弄清楚这两个概念之前，我们先来了解一下什么叫方法的型构（signature）。
指方法的组成结构，具体包括方法的名称和参数，涵盖参数的数量、类型以及出现的顺序，但是不包括方法的返回值类型，访问权限修饰符，以及 abstract、static、final 等修饰符。
示例一、下面两个是具有相同型构的方法：
public void method(int i, String s) {
// do something
public String method(int i, String s) {
// do something
注意：在同一个类中，是不允许定义多于一个的具有相同型构的方法。
示例二、下面两个是具有不同型构的方法：
public void method(int i, String s) {
// do something
public void method(String s, int i) {
// do something
了解完型构的概念后我们再来看看重载和重写：
重写（overriding）:
指在继承情况下，子类中定义了与其父类中方法具有相同型构的新方法，就称为子类把父类的方法重写了。这是实现多态必须的步骤。
重载（overloading）:
指在同一个类中定义了一个以上具有相同名称，但是型构不同的方法。
为了加深理解，我们来考虑一个有趣的问题：构造器可以被重载吗？
答案当然是可以的，我们在实际的编程中也经常这么做。实际上构造器也是一个方法，构造器名就是方法名，构造器参数就是方法参数，而它的返回值就是新创建的类的实例。但是构造器却不可以被子类重写，因为子类无法定义与父类具有相同型构的构造器。
1 收藏&&|&&5
你可能感兴趣的文章
7 收藏，457
分享到微博？
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。　　我们知道面向对象的三大特性是封装、继承和多态。然而我们有时候总是搞不清楚这些概念。下面对这些概念进行整理，
为以后面向抽象的编程打下坚实的基础。
　　封装的概念还是很容易理解的。如果你会定义类，那么相信你对封装的概念已经完全掌握了。下面定义的几个类，就是对数据的封装。
　　继承的好处是代码复用。继承的子类自动拥有父类中的所有属性和方法。所以继承已存在的类就是复用这些类的方法和域。
在此基础上，子类还可以添加一些新的方法和域，以满足新的需求。这是Java程序设计中的一项核心技术。
　　那么如何判断是否需要继承呢？"is-a"关系是继承的一个明显特征。这句话的意思可以解释为：Student之所以继承Person，
是因为Student 是Person。如果没有这个关系也就不需要这个继承了。这也是里氏替换原则的定义，子类型必须能够替换掉它们的父类型。
　　在通过扩展超类定义子类的时候，仅需指出子类与超类的不同之处。因此在设计类时，应该将通用的方法放到超类中，
而将具有特殊用途的方法放到子类中，这种将通用的功能放到超类的做法，在面向对象程序设计中十分普遍。
　　动态绑定有一个非常重要的特性：无需对现存的代码进行修改，就可以对程序进行扩展。所以多态是开放封闭原则的基础。
　　下面是一个继承和多态实现的具体例子：
&abstract 是抽象的关键字。(最好从抽象类继承而不是从具体类继承)。
public abstract class Person {
// 私有变量
public String getName() {
// Getter方法
public void setName(String name) {
//Setter方法
this.name =
public Person(String name) {
// 构造函数，用于初始化name
this.name =
public abstract String getDesc();
// 抽象类中的抽象方法。
只有声明，没有具体实现。　　
& & & public String toString(){ & & &// toString方法覆盖了Object类的toString方法& & & & &return name + getDesc();& & & }
&extends 是继承的关键字。Student继承Person，所以Student拥有name属性。
public class Student extends Person {
private S // 新增加的数据
public String getMajor() {
public void setMajor(String major) {
this.major =
public Student(String name,String major) { // 构造函数用于初始化
super(name);
// 调用超类构造函数
this.major =
public String getDesc() {
// 必须实现超类中的抽象方法
// TODO Auto-generated method stub
return " : a student, major is " +
&凡是继承超类的子类，必须实现（无论是哪种实现方式）超类中定义的抽象方法。
public class Employee extends Person{
private double
public double getSalary() {
public void setSalary(double salary) {
this.salary =
public Employee(String name, double salary) {
super(name);
this.salary =
public String getDesc() {
// TODO Auto-generated method stub
return " :a employee, salary is " +
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Person[] p=new Person[2];
p[0]=new Student("Mark", "IT");
p[1]=new Employee("Jerry", 2000);
for (Person person : p) {
System.out.println(person.getName()+person.getDesc());
从这个例子也可以看出，没有封装就谈不上继承，而没有继承，就不可能有所谓的多态。
而理解封装、继承和多态（特别是多态）是理解设计模式的基础。
阅读(...) 评论()java基础三大特性——封装、继承与多态
面向对象的三大特性：
封装：主要实现了隐藏细节，对用户提供访问接口，无需关心方法的具体实现。
继承：很好的实现了代码的复用，提高了效率。
多态：程序的可扩展性及可维护性增强。
继承就是一种由已有的类创建新类的机制，是指在已有类的基础上扩展功能。继承中分为子类和父类
类可以有两种重要的成员：成员变量和方法。子类的成员中有一部分是子类自己声明定义的，另一部分是从它的父类继承的。
1.所谓子类继承父类的成员变量作为自己的一个成员变量，就好象它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法操作.
2. 所谓子类继承父类的方法作为子类中的一个方法，就象它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法调用。
(1) 只支持单一继承，也就是只有一个父类，利用extends 关键字继承；
class A{ & & & & & & }
class B{ & & & & & & }
class C extends A,B{ & & // 错误的，因为同时继承了两个父类 & & & & &}
(2)Java中允许多层继承
class A{ & & & & &}
class B extends A{ & & & & & }
class C extends B{ & & & & & }
(3)当子类拥有和父类相同的方法定义(即返回类型、方法名、参数列表完全相同时，仅方法体不一样)，称之为方法重写(OverRide)；
1对于子类创建的一个对象，如果子类重写了父类的方法，则运行时调用子类重写的方法，如果子类继承了父类的方法（未重写），那么子类创建的对象也可以调用这个方法，只不过方法产生的行为和父类的相同而已。
2重写父类方法时不可以降低方法的访问权限
3如果重写了父类的方法后使用父类的被重写方法，可以在子类的方法中使用super.被重写方法（）;
4子类不继承父类的构造方法
5子类的构造方法必须调用父类的构造方法
6如果子类的构造方法中没有显式地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则系统默认调用父类无参数的构造方法，相当于省略了super();语句
7如果子类构造方法中既未显式调用父类构造方法，而父类中只有有参数的构造方法，没有无参的构造方法，则编译出错
8在子类的构造方法中可使用语句super(argument_list) 调用父类的构造方法，但必须作为构造方法的第一条句。
9子类在实例化时实际上先调用父类的构造方法，后调用的子类的构造方法。
&抽象类(Abstract Class)
抽象类提供一个类型的部分实现，可以有实例变量，构造方法，抽象方法(Abstract Method 即不能有方法的实现哪怕是{})和具体方法。一个抽象类不会有实例；它是用来继承的。它反映了一种一般/特殊化的关系。
用关键字abstract修饰的类称为abstract类（抽象类）。
abstract class A
{ & & & & &}
&abstract类有特点:和普通的类相比，abstract类可以有abstract方法。对于abstract方法，只允许声明，不允许实现，而且不允许使用final修饰abstract方法。
abstract class A
{ & & &abstract &int min(int x,int y);
& & & & int max(int x,int y)
& & & & & & & & & & & & { &return x&y?x:y; }
abstract类不能用new运算创建对象
& &对于abstract类，我们不能使用new运算符创建该类的对象，需产生其子类，由子类创建对象，如果一个类是abstract类的子类，它必须具体实现父类的abstract方法，这就是为什么不允许使用final修饰abstract方法的原因。
一个abstract类只关心它的子类是否具有某种功能，并不关心功能的具体行为，功能的具体行为由子类负责实现，抽象类中的抽象方法可以强制子类必须给出这些方法的具体实现。
多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为。简单来说，多态是具有表现多种形态的能力的特征。
当一个类有很多子类时，并且这些子类都重写了父类中的某个方法。那么当我们把子类创建的对象的引用放到一个父类的对象中时，就得到了该对象的一个上转型对象，那么这个上转的对象在调用这个方法时就可能具有多种形态.
1. & 对于一个引用类型的变量，Java编译器按照它的声明的类型来处理
2. & &对于一个引用类型的变量，运行时Java按照它的实际引用的对象来处理
& & & & & & & &1、子类重写父类的方法
& & & & & & & & 2、编写方法时，调用父类定义的方法
& & & & & & & & 3、运行时，根据实际创建的对象类型动态决定使用哪个方法
例如：让父类引用指向子类对象；如 Person p1 = new Student();//引用的类型是Person，指向子类对象Student
接口与类属于同一层次，实际上，接口是一种特殊的抽象类。在Java中接口定义同类的定义很相似，分为接口声明和接口体两部分。接口通过interface关键字声明，接口体中只能包含全局常量和抽象方法，接口的变量自动是public static final属性，接口中的方法自动是public abstract属性，并没有方法体，以分号结尾。
格式: [public] interface 接口名 [extends 父接口名表]{ 接口体；}
接口体包含常量定义和方法定义，
interface IA{
& &public static final int MAX=100; //全局常量
& &public void print(); &//抽象方法
& &public abstract int sum(); & &//抽象方法
1) & & & &public interface：公开接口，与类相似，一个文件只能有一个public接口，且与文件名相同。
2) & & & &在一个文件中不可同时定义一个public接口和一个public类。
3) & & & &接口和接口之间可以定义继承关系，并且接口之间允许实现多重继承。
& & & & & & & & & & & & & & & & & & & & & & & & &例：interface IC extends IA,IB{ & };
1.一个类通过关键字implements实现接口：
格式：[修饰符] class &类名 [extends 父类] [implements 接口]{}
& & &非抽象类，必须实现接口的所有方法;
& & 抽象类的非抽象子类中对其父类所实现的接口中的所有抽象方法都必须实现。
&2.一个类除继承另外一个类，还可以实现接口：
class IAImpl extends java.util.Arrylist implement IA，IB{}
1) & & & &一个类实现了某个接口，则必须实现接口中的所有方法，如果没有实现接口中的所有方法，则此类一定是抽象类。因为一个类实现接口，相当于它继承一个抽象类。
2) & & & &接口中方法可不写public，但在子类中实现接口的过程中public不可省。（如果省去public则在编译的时候提示出错：对象无法从接口中实现方法，相当于降低了重写方法的权限。）
3) & & & &如果父类实现了某个接口，子类不需要使用implements关键字声明就可以使用此接口。
4) & & & 接口也可以用于定义对象
& & & & & & & & & & & & IA iA=new IAImpl(); &//类似于上转型对象
上转型对象特点：
& & & & & &n &上转对象不能操作子类新增的成员变量（失掉了这部分属性）；不能使用子类新增的方法（失掉了一些功能）。
& & & & & &n &上转型对象可以操作子类继承或隐藏成员变量，也可以使用子类继承的或重写的方法。
& & & & & &n &上转型对象操作子类继承或重写的方法时，就是通知对应的子类对象去调用这些方法。因此，如果子类重写了父类的某个方法后，对象的上转型对象调用这个方法时，一定是调用了这个重写的方法。
& & & & & &n & 可以将对象的上转型对象再强制转换到一个子类对象，这时，该子类对象又具备了子类所有属性和功能。
&接口使用案例：&
interface IDetail{
public String detail();
class Teacher implements IDetail {
public Teacher(String name, int age, String type) {
this.name =
this.age =
this.type =
// 返回教师详细信息
public String detail() {
return &姓名：& + name + &,年龄：& + age + &，教师类型：& +
class Printer {
public void print(String s) {
System.out.println(s);
class MedicalInspection implements IDetail{
Printer printer = new Printer();
// 返回体检中心信息
public String detail() {
return &这里是滨州市体检中心，欢迎您的到来！&;
// 打印detail信息
public void printDetail(IDetail d) {
printer.print(d.detail());
public class ExDemon03 {
public static void main(String[] args) {
MedicalInspection mi=new MedicalInspection();
IDetail t = new Teacher(&李四&, 33, &Java&);
mi.printDetail();// 打印教师信息
mi.printDetail(mi);// 打印中心信息}