首页 > 其他分享> > 多态的应用和内部类讲解

多态的应用和内部类讲解

2022-06-19 15:36:01 作者：互联网

多态的应用

什么是多态:父类的引用指向了子类的实例

多态的实现方法:

1.使用父类作为方法的形参实现多态

2.使用父类作为方法的返回值实现多态

继承多态:当这个作为参数的父类是普通类或者抽象类时

接口多态:当这个作为参数的父类是一个接口时，构成接口多态

多态作为行参

　1、普通类

　当一个行参希望我们传递的是一个普通类时，我们实际传递的是该类的对象/匿名对象

public class OOPDemo01 {
    public static void main(String[] args) {
        Student student = new Student();
        Person person = new Person();
        person.run(student);
        System.out.println("=====");
        person.run(new Student());
    }
}
class Student{
    public void study(){
        System.out.println("学习");
    }
}
class Person{
    public void run(Student s){
        s.study();
        System.out.println("run");
    }
}

　2、抽象类

　　当一个参数希望我们传入的是一个抽象类时，我们实际上传入的是该类的子类对象或者子类的匿名对象

package com.example.ObjectOriented.Interface1.pp9;

public class OOPDemo01 {
    public static void main(String[] args) {
        //多态的体现
        AbsStudent student = new Student();
        Person person = new Person();
        person.run(student);
        System.out.println("======");
        person.run(new Student());
        System.out.println("=======");
        AbsStudent absStudent = new AbsStudent(){
            @Override
            public void study() {
                System.out.println("xxxxxxxx");
            }
        };
        person.run(absStudent);
        System.out.println("=======");
        //匿名内部类
        person.run(new AbsStudent(){
            @Override
            public void study() {
                System.out.println("xxxxxxxx");
            }
        });
    }
}
abstract class AbsStudent{
    public abstract void study();
}
class Student extends AbsStudent{

    @Override
    public void study() {
        System.out.println("学习");
    }
}
class Person{
    public void run(AbsStudent s){
        s.study();
        System.out.println("run");
    }
}

　3、接口

　当一个参数希望我们传入的是一个接口时，我们实际上传入的是该接口的实现类对象或者实现类匿名对象

public class OOPDemo01 {
    public static void main(String[] args) {
        //多态的体现
        IStudent student = new Student();
        Person person = new Person();
        person.run(student);
        System.out.println("======");
        person.run(new Student());
        System.out.println("=======");
        IStudent absStudent = new IStudent(){
            @Override
            public void study() {
                System.out.println("xxxxxxxx");
            }
        };
        person.run(absStudent);
        System.out.println("=======");
        //匿名内部类
        person.run(new IStudent(){
            @Override
            public void study() {
                System.out.println("xxxxxxxx");
            }
        });
    }
}
class Student implements IStudent{
    public void study(){
        System.out.println("学习");
    };
}
interface IStudent{
    void study();
}
class Person{
    public void run(IStudent s){
        s.study();
        System.out.println("run");
    }
}

多态作为返回值

1、普通类

当一个方法的返回值是一个普通类，实际返回的就是该类的对象，我们可以使用该类的对象类接收

public class OOPDemo02 {
    public static void main(String[] args) {
        Studnet studnet = new Studnet();
        Person study = studnet.study();
        System.out.println(study);
        Person eat = studnet.eat();
        System.out.println(eat);
    }
}
class Person{

}
class Studnet{
    public Person study(){
        return new Person();
    }
    public Person eat(){
        Person person = new Person();
        return person;
    }
}

2、抽象类

当一个方法的返回值是一个抽象类时，实际返回的是该抽象类的子类对象，我们可以使用该抽象类接收。

package com.example.ObjectOriented.Interface1.ppp9;

public class OOPDemo02 {
    public static void main(String[] args) {
        Studnet studnet = new Studnet();
        AbsPerson study = studnet.study();
        //子类的接收，父类的返回，那么就需要强制类型转换
        Person study1 = (Person) studnet.study();

        System.out.println(study);
        AbsPerson eat = studnet.eat();
        if (eat instanceof Person){
            Person p4 = (Person) eat;
        }
        System.out.println(eat);
    }
}
abstract class AbsPerson{

}
class Person extends AbsPerson{

}
class Studnet{
    public AbsPerson study(){
        return new Person();
    }
    public AbsPerson eat(){
//        Person person = new Person();
        return new AbsPerson(){};
    }
}

3、接口

当一个方法的返回值是一个接口时，实际返回是该接口的实现类对象，我们可以使用接口来接收，

同样的如果我们使用实现类来接收的，那么同样有可能出现异常的问题，也就是强制类型转换的异常

package com.example.ObjectOriented.Interface1.ppp9;

public class OOPDemo02 {
    public static void main(String[] args) {
        Studnet studnet = new Studnet();
        IPerson study = studnet.study();
        IPerson eat = studnet.eat();
        //子类的接收，父类的返回，那么就需要强制类型转换
        IPerson study1 = (Person) studnet.study();
        if (eat instanceof Person){
            Person p4 = (Person) eat;
        }
        System.out.println(study);
        System.out.println(eat);
    }
}
interface IPerson{

}
class Person implements IPerson{

}
class Studnet{
    public IPerson study(){
        return new Person();
    }
    public IPerson eat(){
        return new IPerson(){};
    }
}

内部类讲解