1.何时使用继承

1.1符合 *** is a ***的规则，即双方可以相互依存，亦可保持独立；

1.2可实现代码复用

即当大家的代码块具有相似或类似时，我们可以抽象出一些公共的属性及方法作为父类，子类可以 继承父类而使用这些代码片段。同时也能保持自己的独立性。

2.抽象

2.1定义：

在一段段的继承关系中，可以清晰地形成一座金字塔格式，底部的子类将会越来越强大，因为其继承了上部的多种属性及方法，而越在上部的类就越简单也即越抽象。甚至可追溯到这个父类中的方法无法满足子类，形成了一种抽象方法，含有这种抽象方法的类即为抽象类。

语法如下：

public abstract class 类名 {

}

2.2抽象的特性

抽象类由于过于抽象，将无法实现方法，也即实现也无意义，固抽象类不能实例化。

public abstract class Animal{

private String name;

public void setName(String name){

this.name = name;

}

public String getName(){

return this.name;

}

public Animal(){

}

public Animal(String name){

this.name = name;

}

public void sleep(){

}

}

如果一个方法过于抽象，不能实现，其一定要写在抽象类中，不加方法体，固：

抽象方法一定位于抽象类中；

抽象方法没有方法体；

不过，抽象类中的方法不一定都是抽象方法。

注意：

如果子类继承了抽象类，需对抽象方法做出修改，否则，此子类也必须是抽象子类。

3.final关键字

——final是java语言中的一个关键字，被译为最终的不可改变的

——final修饰的类无法被继承

——final修饰的方法无法被重写

——final修饰的变量一旦被赋值，将不可再次赋值

——final修饰的引用一旦指向某个对象之后，就不能再指向其他对象，所以被final修饰后的引用指向的对象将不会被垃圾回收机制回收。但该对象中的内存可以被修改，因为其修饰的引用是一个地址，地址不能被改变，但其对象中的内容可以改变。

——final修饰的实例变量常常与static一起使用，被称为常量，与static一起使用将有效提高运行效率。

public final class Animal{

}

public class Person extends Animal{

public void sleep(){

System.out.println("闭眼躺着睡觉...");

}

}

3.1思考

静态方法能被继承吗？

静态方法能被重写吗？

静态方法可以被继承，应该说是被默认继承了静态方法，但不能重写，应该说该静态方法被隐藏了。

分析：

1. 静态方法和属性是属于类的，调用的时候直接通过类名.方法名完成，不需要继承机制及可以调用。如果子类里面定义了静态方法和属性，那么这时候父类的静态方法或属性称之为"隐藏"。如果你想要调用父类的静态方法和属性，直接通过父类名.方法或变量名完成，至于是否继承一说，子类是有继承静态方法和属性，但是跟实例方法和属性不太一样，存在"隐藏"的这种情况。

2. 多态之所以能够实现依赖于继承、接口和重写、重载(继承和重写最为关键)。有了继承和重写就可以实现父类的引用指向不同子类的对象。重写的功能是："重写"后子类的优先级要高于父类的优先级，但是“隐藏”是没有这个优先级之分的。

3. 静态属性、静态方法和非静态的属性都可以被继承和隐藏而不能被重写，因此不能实现多态，不能实现父类的引用可以指向不同子类的对象。非静态方法可以被继承和重写，因此可以实现多态。

4.多态

4.1定义：

多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作。对拓展开放，对修改关闭。

4.2使用多态的好处：

1.消除类型之间的耦合关系

2. 可替换性

3. 可扩充性

4. 接口性

5. 灵活性

6. 简化性

4.3实现步骤：

[1] 编写父类

[2] 编写子类，子类一定要重写/实现父类的方法

[3] 运行时，父类类型 引用 子类对象 (Pet pet = new Dog())

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

4.4多态的实现形式

1.父类类型 引用 子类对象(基于此而延伸)

实例：

// 多态// 同一引用类型Pet pet = null;

// 父类引用 引用 子类对象pet = new Dog("二狗",100,0,"土狗");

// 呈现多态pet.eat();

这里的.eat()的方法，是属于Dog子类中独有的方法，父类将子类的方法引用了过来，完成多态，实现拓展性。

2.父类作为方法的形参实现多态

实例：

public void feed(Pet pet) {

System.out.println(this.getName() + "正在喂" + pet.getName());

pet.eat();

}

Pet作为宠物类的父类，在主人类中被当作了方法的形参，实现了多态。

3.父类作为方法的返回值实现多态

实例：

public Pet adoptPet(int type) {

Pet pet = null;

if(1 == type) {

pet = new Dog();

}else if(2 == type) {

pet = new Penguin();

}else if(3 == type){

pet = new Cat();

}

return pet;

}

4.5存在于多态中的类型转换

在多态实现的过程中一样存在这两种类型转换，即自动类型转换(亦称为向上类型转换)与强制类型转换(向下类型转换)。

自动类型转换：子类可以自动转换为父类。

Pet pet = null;

pet = new Dog();

同样，若想要进行强制类型转换，需要加强制类型转换符。

子类类型 引用 = (子类)父类对象

需要注意的是，如果单纯这样转换，编译不会报错，但在运行过程中将很容易发生运行错误，许多程序员在编码的过程中，很容易将子类类型转换为错误的父类类型，导致父类在调用子类特有的方法时发生找不到方法的可能。所以java为了应对这些问题，创建了 instantceof关键字。

通过instantceof关键字可以判断其转换的类型是否是我们需要的类型，可参考以下格式：

public class TestInstanceOf {

public static void main(String[] args) {

Dog dog = new Dog();

System.out.println(dog instanceof Dog); //trueSystem.out.println(dog instanceof Pet); //trueSystem.out.println(dog instanceof Object); //true}

}

public void play(Pet pet) {

if(pet instanceof Dog) {

Dog dog = (Dog) pet;

dog.catchFlyDisc();

}else if(pet instanceof Penguin) {

Penguin penguin = (Penguin) pet;

penguin.swimming();

}

}