第十课时

前言
继承的三个特点:

目录

多态
抽象类
1、多态
1.1、多态的概述
什么是多态:
同一个对象，在不同时刻表现出来的不同形态。
多态的前提:
要有继承或实现关系要有方法的重写要有父类引用指向子类对象。
1.2、多态中的成员方法的特点
成员访问特点
成员变量
编译看父类，运行看父类
成员方法
编译看父类，运行看子类
1.3、多态的好处和弊端
好处: 提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作。
弊端: 不能使用子类的特有成员。
1.4、多态的转型
向上转型……父类引用指向子类对象就是向上转型
向下转型……格式：子类型对象名=(子类型)父类引用;
1.5、例一:
程序代码如下:
①
package com.hg.day10.demo01;

public class Fu {
int num = 10;

public Fu() {
//TODO 自动生成的构造函数
}
public Fu(int num) {
//TODO 自动生成的构造函数
}
②
package com.hg.day10.demo01;
/*

this
1
1.访问本类的成员变量

2.在本类成员变量中，访问另一个成员方法

3.在构造函数中调用this方法

*/
public class Zi extends Fu {
int num = 20;

public Zi() {
//this(100); ！！ this和super只能调用一个 ！!

super();
System.out.println(“我是子类的无参构造方法”);
}
public Zi(int n) {
this.num = n;
System.out.println(“我是子类的有参构造方法”+n);
}
public Zi(int n,String name) {
this(1000);
//只初始化name相关工作
System.out.println(“我是子类的有参构造方法”+n);
}
public void showNum() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
public void methodA() {
System.out.println(“AAA”);
}
public void methodB() {
this.methodA();
System.out.println(“BBB”);
}

}
③
package com.hg.day10.demo01;

public class demo01Extends {
public static void main (String[] agrs) {
Zi zi = new Zi();
}
2、抽象类
2.1、概述
当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

2.2、抽象类的特点
①抽象类和抽象方法必须使用abstract关键字修饰
②抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
//抽象类的定义publicabstractclass类名{}
//抽象方法的定义publicabstractvoideat();
③抽象类不能实例化
抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态。
④抽象类的子类要么重写抽象类中的所有抽象方法要么是抽象类。
2.3、抽象类的成员特点
①成员的特点
成员变量 既可以是变量，也可以是常量
②构造方法
空参构造 有参构造
③成员方法
抽象方法 普通方法
2.4、例二
①
package com.hg.day10.demo02;
/*

抽象方法 + Abstract关键字，去掉大括号，直接分号结束。

1.抽象类不能直接使用，不能直接实例化

2.必须用一个子类来继承抽象的父类

3.子类必须 覆盖重写 抽象父类中的所有抽象方法
*/
public abstract class Animal {
public Animal() {
System.out.println(“抽象父类中的构造方法”);
}
public abstract void eat();

public abstract void foot();

public void normalMethod() {
}

}
②
package com.hg.day10.demo02;

public class Cat extends Animal {
public Cat () {
System.out.println(“子类中的构造方法”);
}
@Override // 重写
public void eat() {
System.out.println(“猫吃鱼”);
}
public void foot() {

}
③
package com.hg.day10.demo02;
/*

一个抽象类 不一定含有 抽象方法
1
但是，一个有抽象方法的类一定含有抽象方法
*/
public abstract class MyAbstract {
public void sleep() {
}

}
④调用
package com.hg.day10.demo02;

public class Demo02Main {
public static void main (String[] agrs) {
Cat cat = new Cat();
cat.eat();
}
运行结果:

例二:
①
package com.hg.day10.demo03;

/*

抽象方法 + Abstract关键字，去掉大括号，直接分号结束。

1.抽象类不能直接使用，不能直接实例化

2.必须用一个子类来继承抽象的父类

3.子类必须 覆盖重写 抽象父类中的所有抽象方法

*/
public abstract class Animal {
public Animal() {
System.out.println(“抽象父类中的构造方法”);
}
public abstract void eat();

public abstract void sleep();
}
②
package com.hg.day10.demo03;

public abstract class Dog extends Animal {
@Override // 重写
public void eat() {
System.out.println(“狗吃骨头”);
}
③
package com.hg.day10.demo03;

public class Dog2ha extends Dog {
@Override // 重写
public void sleep() {
System.out.println(“二哈睡觉”);
}④
package com.hg.day10.demo03;

public class DogGolden extends Dog {
@Override // 重写
public void sleep() {
System.out.println(“躺着沙发睡觉”);
}
⑤
package com.hg.day10.demo03;

public class Demo03Main {
public static void main (String[] args) {
//不能实例化：
//Animal animal = new Animal();
//Dog dog = new Dog();
//可以实例化：
Dog2ha ha2 = new Dog2ha();
ha2.eat();
ha2.sleep();
System.out.println("==========");

DogGolden doggolden = new DogGolden();
doggolden.eat();
doggolden.sleep();
}