java多态

目录

多态简介

多态调用成员的特点

多态的优势

多态的弊端是什么?

---

多态简介

Java多态是指同一个方法可以根据不同的对象调用而表现出不同的行为。这是Java面向对象编程的一个重要特性。

在Java中，多态可以通过继承和接口实现。当一个子类继承自父类或实现一个接口时，它可以使用父类或接口的方法，并且可以根据需要重写这些方法。当调用这些方法时，可以根据对象的实际类型来确定调用的是哪个类的方法。

1.什么是多态?
对象的多种形态，
2.多态的前提?

• 有继承/实现关系
• 有父类引用指向子类对象
• 有方法的重写

3.多态的好处?
使用父类型作为参数，可以接收所有子类对象体现多态的扩展性与便利。 

---

下面我们来写个例子看看

Person类

public class Person {
    private String name;
    private  int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Person{name = " + name + ", age = " + age + "}";
    }

    public void show(){
        System.out.println(name+","+age);
    }
}

Student类

public class Student extends Person{
    @Override
    public void show(){
        System.out.println("学生的信息为："+getName()+","+getAge());
    }
}

 Teacher类

public class Teacher extends Person{
    @Override
    public void show(){
        System.out.println("老师的信息为："+getName()+","+getAge());
    }
}

administrator类

public class administrator extends Person{
    @Override
    public void show(){
        System.out.println("管理员的信息为："+getName()+","+getAge());
    }
}

最后再写个测试类就好了

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.setAge(18);
        Teacher teacher = new Teacher();
        teacher.setName("李四");
        teacher.setAge(30);
        administrator admin = new administrator();
        admin.setName("王五");
        admin.setAge(25);
        register(student);
        register(teacher);
        register(admin);
    }
    public static void register(Person p){
        p.show();
    }
}

 register既要接收学生，又要接受老师，还要接受管理员，只能把参数写成这三个类型的父类

 运行结果在这里

---

多态调用成员的特点

• 变量调用:编译看左边，运行也看左边。
• 方法调用:编译看左边，运行看右边。 

Animal类

public class Animal {
    String name="动物";
    public  void show(){
        System.out.println("Animal的show方法");
    }
}

Dog类

public class Dog extends Animal{
    String name="狗";
    public void show(){
        System.out.println("Dog的show方法");
    }
}

测试一下

public class Test2 {
    public static void main(String[] args) {
        Animal a = new Dog();
        System.out.println(a.name);
    }
}

这个的结果会是什么呢？

调用成员变量:编译看左边，运行也看左边

编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败

可以看一下，我给父类的注释掉了，直接就报错

运行也看左边：java运行代码的时候，实际获取的就是左边父类中成员变量的值 

在测试类中我调用成员方法

public class Test2 {
    public static void main(String[] args) {
        Animal a = new Dog();
        System.out.println(a.name);
        a.show();
    }
}

这样的结果又会是什么呢？

调用成员方法:编译看左边，运行看右边

编译看左边:iavac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败

可以看到，我给父类的注释掉了，也直接就报错了

运行看右边:java运行代码的时候，实际上运行的是子类中的方法。

成员方法:如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖的。

多态的优势

1. 灵活性：多态可以在运行时决定调用哪个方法，使得程序可以根据不同的对象类型选择不同的方法实现。这样可以使得程序更加灵活，在后期可以轻松地添加新的对象类型而不需要修改已有的代码。

2. 可扩展性：多态使得程序的扩展性更好。当需要添加新的对象类型时，只需要继承已有的抽象类或接口，并实现其中的方法即可。这样无需修改原有的代码，使得程序的扩展变得更加容易。

3. 可维护性：多态使得程序的维护变得更加简单。通过将不同的对象类型视为同一类型，可以使用统一的接口进行操作和调用方法。这样在代码的维护过程中，只需要关注抽象类或接口的变化，而不需要关心具体的实现细节。

4. 代码复用：多态可以通过继承和实现接口来实现代码的复用。可以将相同的代码逻辑抽象出来，形成一个抽象类或接口，其他子类可以继承该抽象类或实现该接口，并实现自己的具体逻辑。这样可以减少重复的代码，提高代码的复用性。

5. 可替换性：多态使得程序的逻辑更加清晰。通过将不同的对象类型看作同一类型，可以将具体的实现细节和调用逻辑分离。这样在后期如果需要替换某个具体的对象类型时，只需要将其更换为另一个实现该抽象类或接口的对象即可，无需修改其他代码。

多态的弊端是什么?

 不能使用子类的特有功能，如果要使用的话可以将数据类型转换一下，也可以进行强制类型转换

Person p=new student();
Student s=(student)p;

 这样就可以转换成真正的子类类型，从而调用子类独有功能，转换类型与真实对象类型不一致会报错，转换的时候用instanceof关键字进行判断

动物类

public class Animal {
    String name="动物";
    public  void eat(){
        System.out.println("吃东西");
    }
}

猫类

public class Cat extends Animal{
    String name="猫";
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

 狗类

public class Dog extends Animal{
    String name="狗";
    public void eat(){
        System.out.println("狗啃骨头");
    }
    public void dogLookHome(){
        System.out.println("狗看家");
    }
}

 测试一下

 可以看到并不能使用子类的特有功能

我们可以直接将类型改了

也可以直接进行强制转换

---

 

这样运行的话就会出错，转换类型与真实对象类型不一致，我们可以用instanceof关键字进行判断 

public class Test2 {
    public static void main(String[] args) {
        Animal a = new Dog();
        if(a instanceof Dog){
            Dog d=(Dog)a;
            d.dogLookHome();
        }
        else if(a instanceof Cat){
            Cat c=(Cat)a;
            c.catchMouse();
        }
        else{
            System.out.println("没有这个类型，无法转换");
        }
    }
}

这样写的话对jdk版本是有要求的，低了不行

jdk版本低的话可以这样写

public class Test2 {
    public static void main(String[] args) {
        Animal a = new Dog();
        if(a instanceof Dog d){
            d.dogLookHome();
        }
        else if(a instanceof Cat c){
            c.catchMouse();
        }
        else{
            System.out.println("没有这个类型，无法转换");
        }
    }
}

 这一期就到这里啦，继续加油哦！！！