1 多态
1.1 多态的概述
1:什么是多态
一个对象的多种状态
(老师)(员工)(儿子)
教师 a =老钟;
员工 b= 老钟;
2:多态体现
1:Father类
1:非静态成员变量x
2:静态成员变量y
3:非静态方法eat,方法体输出父类信息
4:静态方法speak();方法体输出父类信息
2:Son类
1:非静态成员变量x
2:静态成员变量y
3:非静态方法eat,方法体输出子类信息
4:静态方法speak();方法体输出子类信息
class Father { intx = 1; staticinty = 2;
void eat() { System.out.println("开吃"); }
staticvoid speak() { System.out.println("小头爸爸"); } }
class Son extends Father { intx = 3; staticinty = 4;
void eat() { System.out.println("大头儿子很能吃"); }
staticvoid speak() { System.out.println("大头儿子。"); } }
class Demo10 {
publicstaticvoid main(String[] args) {
Father f = new Son(); // 父类引用指向了子类对象。 System.out.println(f.x); // 1 System.out.println(f.y); // 2
f.eat(); // 输出的是子类的。
f.speak(); // 输出的是父类
} } |
3:Son类继承父类
1:创建Father f=new Son();
1:这就是父类引用指向了子类对象。
2:问f.x=?(非静态)
3:问f.y=?(静态)
4:问f.eat()输出的是子类还是父类信息?(非静态)
5:问f.speak()输出的是子类还是父类信息?(静态)
4:总结
1:当父类和子类具有相同的非静态成员变量,那么在多态下访问的是父类的成员变量
2:当父类和子类具有相同的静态成员变量,那么在多态下访问的是父类的静态成员变量
所以:父类和子类有相同的成员变量,多态下访问的是父类的成员变量。
3:当父类和子类具有相同的非静态方法(就是子类重写父类方法),多态下访问的是子类的成员方法。
4:当父类和子类具有相同的静态方法(就是子类重写父类静态方法),多态下访问的是父类的静态方法。
2:多态体现
1:父类引用变量指向了子类的对象
2:父类引用也可以接受自己的子类对象
3:多态前提
1:类与类之间有关系,继承或者实现
4:多态弊端
1:提高扩展性,但是只能使用父类引用指向父类成员。
5:多态特点
非静态
1:编译时期,参考引用型变量所属的类是否有调用的方法,如果有编译通过。没有编译失败
2:运行时期,参考对象所属类中是否有调用的方法。
3:总之成员函数在多态调用时,编译看左边,运行看右边。
在多态中,成员变量的特点,无论编译和运行参考左边(引用型变量所属的类)。
在多态中,静态成员函数特点,无论编译和运行都参考左边
6:多态练习
1:多态可以作为形参,接受范围更广的对象,避免函数重载过度使用。
1:定义功能,根据输出任何图形的面积和周长。
1:定义抽象类abstract MyShape
1:定义抽象方法public abstract double getArea();
2:定义抽象方法public abstract double getLen();
2:定义Rect类继承MyShape
1:定义长和宽成员变量,double width height;
2:无参构造,有参构造。
3:实现父类方法。
3:定义Cricle类继承MyShape
1:定义半径成员变量,和PI常量
2:无参构造,有参构造
3:实现父类方法。
4:定义静态方法计算任意图形的面积和周长
1:未知内容参与运算,不能确定用户传入何种图形,使用多态。
1:形参定义为 MyShape my
2:调用计算面积方法,和计算周长方法。并打印
2:使用多态特性,子类重写了父类非静态方法,会执行子类的方法。
/* 多态练习 1:多态可以作为形参,接受范围更广的对象,避免函数重载过度使用。 1:定义功能,根据输出任何图形的面积和周长。 子类重写了父类的抽象方法,多态下,会执行子类的非静态方法。 2:多态可以作为返回值类型。 获取任意一辆车对象 3:抽象类和接口都可以作为多态中的父类引用类型。 */ abstractclass MyShape{ publicabstractdouble getArea(); publicabstractdouble getLen(); } class Rect extends MyShape{ doublewidth ; doubleheight; Rect(){
} Rect(double width ,double height){ this.width=width; this.height=height; } publicdouble getArea(){ returnwidth*height; } public double getLen(){ return 2*(width+height); }
} class Circle extends MyShape{ doubler; publicstaticfinaldoublePI=3.14;
Circle(){
}
Circle(double r){ this.r=r; } publicdouble getLen(){ return 2*PI*r; }
publicdouble getArea(){ returnPI*r*r; } }
class Demo11{
publicstaticvoid main(String[] args){
System.out.println();
print(new Rect(3,4)); //MyShape m =new Rect(3,4);
print(new Circle(3));
}
//根据用户传入的图形对象,计算出该图形的面积和周长 //1:多态可以作为形参,接受范围更广的对象,避免函数重载过度使用。 publicstaticvoid print(MyShape m){ System.out.println(m.getLen()); System.out.println(m.getArea()); } } |
2:多态可以作为返回值类型。
获取任意一辆车对象
1:定义汽车类,有名字和颜色,提供有参和无参构造,有运行的行为。
2:定义Bmw类,继承Car类,提供无参构造和有参构造(super父类构造),重写父类运行行为。
3:定义Benz类,继承Car类,提供无参构造和有参构造(super父类构造),重写父类运行行为。
4:定义Bsj类,继承Car类,提供无参构造和有参构造(super父类构造),重写父类运行行为。
5:定义静态方法,汽车工厂,随机生产汽车。使用多态定义方法返回值类型。
1:使用(int)Math.round(Math.random()*2); 生成0-2之间随机数。
2:使用if else 判断,指定,0,1,2 new 不同汽车并返回。
6:调用该方法,发现多态的好处。
* 2:多态可以作为返回值类型。 获取任意一辆车对象 1:定义汽车类,有名字和颜色,提供有参和无参构造,有运行的行为。 2:定义Bmw类,继承Car类,提供无参构造和有参构造(super父类构造),重写父类运行行为。 3:定义Benz类,继承Car类,提供无参构造和有参构造(super父类构造),重写父类运行行为。 4:定义Bsj类,继承Car类,提供无参构造和有参构造(super父类构造),重写父类运行行为。 5:定义静态方法,汽车工厂,随机生产汽车。使用多态定义方法返回值类型。 1:使用(int)Math.round(Math.random()*2); 生成0-2之间随机数。 Math 类 2:使用if else 判断,指定,0,1,2 new 不同汽车并返回。 6:调用该方法,发现多态的好处。 */ class Car { String name; String color;
Car() {
}
Car(String name, String color) { this.name = name; this.color = color; }
void run() { System.out.println("跑跑。。。。"); } }
class Bmw extends Car { Bmw() {
}
Bmw(String name, String color) { super(name, color); }
void run() { System.out.println("宝马很拉风。。。。"); } }
class Benz extends Car { Benz() {
}
Benz(String name, String color) { super(name, color); }
void run() { System.out.println("奔驰商务首选。。。。"); } }
class Bsj extends Car {
Bsj() {
}
Bsj(String name, String color) { super(name, color); }
void run() { System.out.println("泡妞首选。。。。"); } }
class Demo12 {
publicstaticvoid main(String[] args) {
int x = 0; while (x < 100) { Car c = CarFactory(); c.run(); x++; }
}
// 定义静态方法,汽车工厂,随机生产汽车。使用多态定义方法返回值类型。 // 使用随机数,0.1.2 if 0 bsj 1 bmw 2 bc publicstatic Car CarFactory() { int x = (int) Math.round(Math.random() * 2);
if (0 == x) { returnnew Bmw("宝马x6", "红色"); } elseif (1 == x) { returnnew Benz("奔驰", "黑色"); } elseif (2 == x) { returnnew Bsj("保时捷", "棕色"); } else { returnnew Benz("Smart", "红色"); }
} } |
3:抽象类和接口都可以作为多态中的父类引用类型。
1:sun Arrays
6:多态之类型转型
1:案例定义Father类
1:定义method1和method2方法
2:定义Son类继承Father类
1:定义method1(重写父类method1)和method2方法
3:创建Father f=new Son();
1: f.method1() 调用的子类或者父类?
2: f.method2() 编译和运行是否通过?
3: f.method3() 编译和运行是否通过?(编译报错)
4:如何在多态下,使用父类引用调用子类特有方法。
1:基本类型转换:
1:自动:小->大
2:强制:大->小
2:类类型转换
前提:继承,必须有关系
1:自动:子类转父类
2:强转:父类转子类
3:类型转换
1:Son s=(Son)f
2:s.method3();
/* 如何在多态下,使用父类引用调用子类特有方法。 1:基本类型转换: 1:自动:小->大 int x=1 double d=x; 2:强制:大->小 int y=(int)d; 2:类类型转换 前提:继承,必须有关系 1:自动:子类转父类 Father f=new Son(); 2:强转:父类转子类 Son s=(Son)f; 1:类型转换 1:Son s=(Son)f 2:s.method3(); */ class Father {
void method1() { System.out.println("这是父类1"); }
void method2() { System.out.println("这是父类2"); } }
class Son extends Father { void method1() { System.out.println("这是子类1"); }
void method3() { System.out.println("这是子类3"); } }
class Demo14 {
publicstaticvoid main(String[] args) { Father f = new Son(); f.method1(); // 这是子类1 f.method2(); // 这是父类2
// f.method3(); //编译报错。 // 多态弊端,只能使用父类引用指向父类成员。
// 类类型转换 Son s = (Son) f; s.method3();
System.out.println(); } } |
5:案例:
1:定义Animal类颜色成员变量,无参构造,有参构造,run方法
2:定义Dog类,继承Animal,定义无参构造,有参构造(使用super调用父类有参构造),Dog的特有方法ProtectHome
3:定义Fish类,继承Animal,定义无参构造,有参构造(使用super调用父类有参构造),Fish特有方法swim
4:定义Bird类,继承Animal,定义无参构造,有参构造(使用super调用父类有参构造),Bird特有方法fly
5:使用多态,Animal a=new Dog();
6:调用Dog的特有方法,ProtectHome
1:类类型转换,Dog d=(Dog)a;
2:d.protectHome
7:非多态
1:Animal a=new Animal();
2:类类型转换
Dog d=(Dog)a;
d.protectHome();
3:编译通过,运行出现异常
1:ClassCastException
8:多态例外
1:Animal a=new Dog();
2:类类型转换
1:Fish f=(Fish)a;
2:f.fish();
3:编译通过,运行异常
1:ClassCastException
4:虽然是多态,但是鸟不能转为狗,狗不能转为鱼,他们之间没有关系。
class Animal { String color;
Animal() {
}
Animal(String color) { this.color = color; }
void run() { System.out.println("跑跑"); } }
class Dog extends Animal { Dog() {
}
Dog(String color) { super(color); }
void run() { System.out.println("狗儿跑跑"); }
void protectHome() { System.out.println("旺旺,看家"); } }
class Fish extends Animal { Fish() {
}
Fish(String color) { super(color); }
void run() { System.out.println("鱼儿水中游"); }
void swim() { System.out.println("鱼儿游泳"); }
}
class Demo15 {
publicstaticvoid main(String[] args) {
Animal ani = new Dog(); // ani.protectHome(); // 正常转换 Dog d = (Dog) ani; d.protectHome();
// 多态例外 Animal an = new Animal(); // ClassCastException // Dog d=(Dog)an
// 多态例外 Animal dog = new Dog(); // ClassCastException // Fish f = (Fish) dog;
} } |
6:案例2
1:定义一功能,接收用户传入动物,根据用于传入的具体动物,执行该动物特有的方法
2:使用多态,方法形参,不能确定用户传入的是那种动物
3:使用instanceof 关键字,判断具体是何种动物,
4:类转换,执行该动物的特有方法。
package oop04;
/* 案例2 1:定义一功能,接收用户传入动物,根据用于传入的具体动物,执行该动物特有的方法 2:使用多态,方法形参,不能确定用户传入的是那种动物 3:使用instanceof关键字,判断具体是何种动物, 4:类转换,执行该动物的特有方法。 */ class Animal { String color;
Animal() {
}
Animal(String color) { this.color = color; }
void run() { System.out.println("跑跑"); } }
class Dog extends Animal { Dog() {
}
Dog(String color) { super(color); }
void run() { System.out.println("狗儿跑跑"); }
void protectHome() { System.out.println("旺旺,看家"); } }
class Fish extends Animal { Fish() {
}
Fish(String color) { super(color); }
void run() { System.out.println("鱼儿水中游"); }
void swim() { System.out.println("鱼儿游泳"); }
}
class Bird extends Animal { Bird() {
}
Bird(String color) { super(color); }
void run() { System.out.println("鸟儿空中飞"); }
void fly() { System.out.println("我是一只小小鸟。。。。"); } }
class Demo16 {
publicstaticvoid main(String[] args) {
System.out.println(); doSomething(new Dog()); doSomething(new Bird()); doSomething(new Fish()); }
// 定义一功能,接收用户传入动物,根据用于传入的具体动物,执行该动物特有的方法 publicstaticvoid doSomething(Animal a) { if (a instanceof Dog) { Dog d = (Dog) a; d.protectHome(); } elseif (a instanceof Fish) { Fish f = (Fish) a; f.swim(); } elseif (a instanceof Bird) { Bird b = (Bird) a; b.fly(); } else { System.out.println("over"); } } } |