java 继承多态整理

继承

声明子类

 使用关键字extends来定义一个类的子类,格式如下：
class 子类名 extends 父类名 {
…
}
 子类创建对象时，子类的构造方法总是先调用父类的某个构造方法，完成父类部分的创建；然后再调用子类自己的构造方法，完成子类部分的创建。如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类的不带参数的构造方法 。
 子类在创建一个子类对象时，不仅子类中声明的成员变量被分配了内存，而且父类的所有的成员变量也都分配了内存空间，但子类只能操作继承的那部分成员变量 。
 子类可以通过继承的方法来操作子类未继承的变量和方法 .
 创建子类对象时，子类总是按层次结构从上到下的顺序调用所有超类的构造函数。如果继承和组合联用，要先构造基类的构造函数，然后调用组合对象的构造函数（组合按照声明的顺序调用）。

成员变量的隐藏和方法重写

成员变量的隐藏

 对于子类可以从父类继承的成员变量，只要子类中声明的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量。
 在子类中要操作这个与父类同名的成员变量时，子类操作的是子类重新声明的这个成员变量。而不是被隐藏掉的。

方法重写

1．重写的语法规则
– 如果子类继承了父类的实例方法，那么子类就有权利重写这个方法。
– 方法重写是指：子类中定义一个方法，这个方法的类型和父类的方法的类型一致或是父类方法的类型的子类型，且这个方法的名字、参数个数、参数的类型和父类的方法完全相同.
2．重写的目的
– 子类通过方法的重写可以隐藏继承的方法，子类通过方法的重写可以把父类的状态和行为改变为自身的状态和行为。
3. 重写后方法的调用
– 子类创建的一个对象，如果子类重写了父类的方法，则运行时系统调用的是子类重写的方法;
– 子类创建的一个对象，如果子类未重写父类的方法，则运行时系统调用的是子类继承的方法;

super关键字

用super操作被隐藏的成员变量和成员方法

 子类可以隐藏从父类继承的成员变量和方法，如果在子类中想使用被子类隐藏的成员变量或方法就可以使用关键字super。比如super.x、super.play()就是访问和调用被子类隐藏的成员变量x和方法play().

使用super调用父类的构造方法

 子类不继承父类的构造方法，因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示，而且super必须是子类构造方法中的头一条语句。

final关键字

 final关键字可以修饰类、成员变量和方法中的局部变量。
– 可以使用final将类声明为final类。final类不能被继承，即不能有子类。
如： final class A {
… …
}
– 如果用final修饰父类中的一个方法，那么这个方法不允许子类重写。
– 如果成员变量或局部变量被修饰为final的，就是常量。

对象的上转型对象

 A类是B类的父类，当用子类创建一个对象，并把这个对象的引用放到父类的对象中时，称对象a是对象b的上转型对象。比如：
A a;
a=new B();
或
A a;
B b=new B();
a=b;

上转型对象的使用

1.上转型对象不能操作子类新增的属性和方法，但是可以访问子类继承和隐藏的成员变量
2.上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重写的实例方法。上转型对象操作子类继承的方法或子类重写的实例方法，其作用等价于子类对象去调用这些方法。因此，如果子类重写了父类的某个实例方法后，当对象的上转型对象调用这个实例方法时一定是调用了子类重写的实例方法。
3.如果子类重写了父类的静态变量或者方法，那么子类对象的上转型对象调用重写了的静态方法或者静态变量时，调用的是父类的静态方法和静态变量（需要特别注意)

总结

 继承是一种由已有的类创建新类的机制。
 子类继承父类的成员变量。
 子类继承父类的方法。
 子类继承过程中可以实现变量隐藏与方法重写。
 上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重写的实例方法
 多态是面向对象编程的又一重要特性。子类可以体现多态，即子类可以根据各自的需要重写的父类的某个方法，子类通过方法的重写可以把父类的状态和行为改变为自身的状态和行为。
 熟练使用上转型对象以及面向抽象编程的思想，以便体现程序设计所提倡的“开-闭”原则。

多态：

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同

要点：

1.多态是方法的多态，不是属性的多态（多态与属性无关）。
2.多态的存在要有三个必要条件：继承，方法重写，父类引用指向子类对象
3.父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了

public class People {
public void cry() {
System.out.println(“wuwuwu”);
}
}

public class Child extends People{
@Override
public void cry() {
System.out.println(“嘤嘤嘤”);
}
}

public class Teenager extends People{
@Override
public void cry() {
System.out.println(“aaaa”);
}
}

public class Main {
public static void main(String[] args) {
Child child=new Child();
Teenager teenager=new Teenager();
PeopleCry(child);
PeopleCry(teenager);
}
static void PeopleCry(People obj) {
obj.cry();
}
}

//运行结果
嘤嘤嘤

PeopleCry方法就是多态的体现，如果没有多态，想要实现相同的功能就要根据子类的个数来定义多个相同方法名的方法（即方法重载），当新增一个子类时，就要重新定义一个相同方法名的方法，这导致有多个子类时，实现同方法不同行为的代码量会大大增加，而多态就避免了这种问题

接口

 为了克服Java单继承的缺点，Java使用了接口，一个类可以实现多个接口。
 使用关键字interface来定义一个接口。接口的定义和类的定义很相似，分为接口的声明和接口体。
 接口中的变量自动都是public、static，final，
 接口中的方法默认为public abstract；接口也产生class文件。
 接口中的方法不能被static和final修饰，因为要重写所有接口中的方法。
接口中没有构造函数，方法可以抛出异常

接口回调

接口回调是指：可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法，且只能调用被类重写的接口方法。

Com com;//声明接口对象
ImpleCom obj= new ImpleCom();//实现接口子类对象
com = obj; //接口回调

理解接口

理解的关键点是：
（1）接口可以抽象出重要的行为标准，该行为标准用抽象方法来表示。
（2）可以把实现接口的类的对象的引用赋值给接口变量，该接口变量可以调用被该类实现的接口方法，即体现该类根据接口里的行为标准给出的具体行为
接口的思想在于它可以要求某些类有相同名称的方法，但方法的具体内容（方法体的内容）可以不同，即要求这些类实现接口，以保证这些类一定有接口中所声明的方法（即所谓的方法绑定）。接口在要求一些类有相同名称的方法的同时，并不强迫这些类具有相同的父类。
接口与多态

面向接口编程

 面向接口去设计程序，可以通过在接口中声明若干个abstract方法，表明这些方法的重要性，方法体的内容细节由实现接口的类去完成。
 使用接口进行程序设计的核心思想是使用接口回调，即接口变量存放实现该接口的类的对象的引用，从而接口变量就可以回调类实现的接口方法。

abstract类和abstract()方法

abstract类有如下特点

– 和普通的类相比，abstract类里可以有abstract方法。也可以没有。对于abstract方法，只允许声明，不允许实现，而且不允许使用final修饰abstract方法。
– 对于abstract类，不能使用new运算符创建该类的对象，只能产生其子类，由子类创建对象。
– 如果一个类是abstract类的子类，它必须具体实现父类的所有的abstract方法。

理解抽象类

（1）抽象类可以抽象出重要的行为标准，该行为标准用抽象方法来表示。即抽象类封装了子类必需要有的行为标准。
（2）抽象类声明的对象可以成为其子类的对象的上转型对象，调用子类重写的方法，即体现子类根据抽象类里的行为标准给出的具体行为。
面向抽象编程

 在设计一个程序时，可以先声明一个abstract类，通过在类中声明若干个abstract方法，表明这些方法在整个系统设计中的重要性，方法体的内容细节由它的非abstract子类去完成。
 然后利用多态实现编程。使用多态进行程序设计的核心技术是使用方法重写和上转型对象，即将abstract类声明对象作为其子类的上转型对象，那么这个上转型对象就可以调用子类重写的方法。
所谓面向抽象编程，是指当设计某种重要的类时，不让该类面向具体的类，而是面向抽象类，即所设计类中的重要数据是抽象类声明的对象，而不是具体类声明的对象

abstract类与接口的比较

1．abstract类和接口都可以有abstract方法。
2．接口中只可以有常量,不能有变量；而abstract类中即可以有常量也可以有变量。
3．abstract类中也可以有非abstract方法,接口不可以。

总结

 接口的接口体中只可以有常量和abstract方法。
 和类一样，接口也是Java中一种重要的引用型数据类型。
 当接口变量中存放了实现接口的类的对象的引用后，接口变量就可以调用类实现的接口方法，这一过程被称为接口回调。
 和子类体现多态类似，由接口产生的多态就是指不同的类在实现同一个接口时可能具有不同的实现方式。
 在使用多态设计程序时，要熟练使用接口回调技术以及面向接口编程的思想，以便体现程序设计所提倡的“开-闭”原则。

着重记忆

子类操作成员变量成员，方法

在子类中要操作这个与父类同名的成员变量或者重写的方法，子类操作的是子类重新声明的这个成员变量，成员方法，而不是被隐藏掉的。
super关键字存在的意义 ：想要在子类中（子类的结构中）想使用被子类隐藏的成员变量或方法就需要使用关键字super。

子类创建的对象访问成员变量，方法

若子类重写了父类的A方法，子类隐藏了a变量，子类创建了一个对象，该对象调用A方法时，系统调用的是子类重写的A方法，该对象使用a变量时，系统调用的是子类的a变量，不是隐藏的a变量。

 子类在创建一个子类对象时，不仅子类中声明的成员变量被分配了内存，而且父类的所有的成员变量也都分配了内存空间，但子类只能操作继承的那部分成员变量 。
 子类可以通过继承的方法来操作子类未继承的变量和方法 .

上转型对象

某个对象向上转型
1.上转型对象不能操作子类新增的属性和方法。
2.上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重写的实例方法。上转型对象操作子类继承的方法或子类重写的实例方法，其作用等价于子类对象去调用这些方法。因此，如果子类重写了父类的某个实例方法后，当对象的上转型对象调用这个实例方法时一定是调用了子类重写的实例方法。
3.如果子类重写了父类的静态变量或者方法，那么子类对象的上转型对象调用重写了的静态方法或者静态变量时，调用的是父类的静态方法和静态变量（需要特别注意)

接口回调

把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法，且只能调用被类重写的接口方法。