学习目标:面向对象进阶
学习内容:多态
学习时间:
下午 3 点-下午 6 点
学习产出:
面向对象三大特征:封装、继承、多态
多态
什么是多态
同类型的对象,表现出的不同形态。
多态的表现形式
父类类型 对象名称 = 子类对象;
多态的前提
有继承关系。
有父类引用指向子类对象。
有方法重写。
多态的好处
使用父类型作为参数,可以接收所有子类对象。
体现多态的扩展性与便利。
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void show(){
System.out.println(name+", "+age);
}
}
public class Student extends Person{
@Override
public void show() {
System.out.println("学生的信息为:"+getName()+", "+getAge());
}
}
public class Student extends Person{
@Override
public void show() {
System.out.println("学生的信息为:"+getName()+", "+getAge());
}
}
public class Administrator extends Person{
@Override
public void show() {
System.out.println("管理员的信息为:"+getName()+", "+getAge());
}
}
public class Test {
public static void main(String[] args) {
Student s=new Student();
s.setName("旭哥");
s.setAge(23);
register(s);
Teacher t=new Teacher();
t.setName("蛋姐");
t.setAge(21);
register(t);
Administrator a=new Administrator();
a.setName("王五");
a.setAge(99);
register(a);
}
public static void register(Person p){
p.show();
}
}
运行结果:
学生的信息为:旭哥, 23
老师的信息为:蛋姐, 21
管理员的信息为:王五, 99
多态调用成员的特点
变量调用:编译看左边,运行也看左边。
方法调用:编译看左边,运行看右边。
package a09demo2;
public class Test {
public static void main(String[] args) {
//创建对象(多态方式)
//Fu f = new Zi();
Animal a = new Dog();
//调用成员变量:编译看左边,运行也看左边
//编译看左边:javac编译代码的时候,会看左边的父类中有没有这个变量,如果有,编译成功,如果没有编译失败。
System.out.println(a.name);//动物
//调用成员方法:编译看左边,运行看右边
//编译看左边:javac编译代码的时候,会看左边的父类中有没有这个方法,如果有,编译成功,如果没有编译失败。
//运行看右边:java运行代码的时候,实际上运行的是子类中的方法。
a.show();///Dog --- show方法
//理解:
//Animal a = new Dog();
//现在用a去调用变量和方法的呀?是的
//而a是Animal类型的,所以默认都会从Anima1这个类中去找
//成员变量:在子类的对象中,会把父类的成员变量也继承下的。父:name 子:name
//成员方法:如果子类对方法进行了重写,那么在虚方法表中是会把父类的方法进行覆盖的。
}
}
class Animal{
String name="动物";
public void show(){
System.out.println("Animal ------ show方法");
}
}
class Dog extends Animal{
String name="狗";
@Override
public void show() {
System.out.println("Dog ------ show方法");
}
}
class Cat extends Animal{
String name="猫";
@Override
public void show() {
System.out.println("Cat ------ show方法");
}
}
运行结果:
动物
Dog ------ show方法
多态的优势
在多态形式下,右边对象可以实现解耦合,便于扩展和维护。
Person p=new Student();
p.work(); //业务逻辑发生改变时,后续代码无需修改
定义方法的时候,使用父类型作为参数,可以接收所有子类对象,体现多态的扩展性与便利。
多态的弊端是什么?
不能使用子类的特有功能。
引用数据类型的类型转换,有几种方式?
自动类型转换、强制类型转换
Person p = new Student (); //自动类型转换
Student s = (Student)p; //强制类型转换
强制类型转换能解决什么问题?
可以转换成真正的子类类型,从而调用子类独有功能。
转换类型与真实对象类型不一致会报错。
转换的时候用instanceof关键字进行判断。
package a09demo2;
public class Test {
public static void main(String[] args) {
//创建对象
Animal a=new Dog();
//编译看左边,运行看右边
a.eat();
//多态的弊端
//不能调用子类的特有功能
//报错的原因?
//当调用成员方法的时候,编译看左边,运行看右边
//那么在编译的时候会先检查左边的父类中有没有这个方法,如果没有直接报错。
//a.lookHome();
/*if(a instanceof Dog){
Dog d = (Dog) a;
d. lookHome();
}else if(a instanceof Cat) {
Cat c = (Cat) a;
c.catchMouse();
}else{
System.out.println("没有这个类型,无法转换”);
}*/
//新特性
//先判断a是否为Dog类型,如果是,则强转成Dog类型,转换之后变量名为d
//如果不是,则不强转,结果直接是false
if(a instanceof Dog d){
d. lookHome();
}else if(a instanceof Cat c){
c.catchMouse();
}else{
System.out.println("没有这个类型,无法转换");
}
}
}
class Animal{
public void eat(){
System.out.println("动物在吃东西");
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗在啃骨头");
}
public void lookHome(){
System.out.println("狗看家");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫在吃小鱼干");
}
public void catchMouse(){
System.out.println("猫抓老鼠");
}
}
狗在啃骨头
狗看家