多态的应用 与 内部类

多态的应用

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

多态的实现方法：

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

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

继承多态：参数的父类是普通类或者抽象类时

接口多态：参数的父类是一个接口时，构成接口多态

 

多态作为形参

基本数据类型

基本数据类型作为形参，和值传递没什么区别，不涉及到多态

引用类型

普通类

一个形参希望我们传递的是一个普通类时，我们实际传递的是该类的对象或者匿名对象

public class OOP01 {
    public static void main(String[] args) {
        Student s = new Student();
        Person p = new Person();
        p.run(s);
        System.out.println("------------");
        p.run(new Student());//匿名对象当做实参传递
    }
}
class Student{
    public void study(){
        System.out.println("学习中");
    }
}
class Person{
    public void run(Student stu){
        stu.study();
        System.out.println("run方法");
    }
}

 

抽象类

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

public class OOP01 {
    public static void main(String[] args) {
        //多态的体现
        Student s = new ABS();
        Person p = new Person();
        p.run(s);
        System.out.println("------------");
        p.run(new ABS());//匿名对象当做实参传递
    }
}

/**
 * 定义的抽象类
 */
abstract class Student{
    public abstract void study();
}

class ABS extends Student{
    @Override
    public void study() {
        System.out.println("学习中....");
    }
}

class Person{
    /**
     * 形参要求传递进来一个抽象类型
     * @param stu
     */
    public void run(Student stu){
        stu.study();
        System.out.println("run方法");
    }
}

 

接口

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

public class OOP01 {
    public static void main(String[] args) {
        IStudent s = new Student();
        Person p = new Person();
        p.run(s);
        System.out.println("------------");
        p.run(new Student());//匿名对象当做实参传递

        IStudent iStudent = new IStudent(){
            @Override
            public void study() {
                System.out.println("接口...");
            }
        };
        p.run(iStudent);

        p.run(new IStudent(){
            @Override
            public void study() {
                System.out.println("接口...1");
            }
        });

    }
}
class Student implements IStudent{
    public void study(){
        System.out.println("学习中");
    }
}

interface IStudent{
    void study();
}

class Person{
    public void run(IStudent stu){
        stu.study();
        System.out.println("run方法");
    }
}

 

多态作为返回值

基本数据类型

基本数据类型作为返回值，和值传递没什么区别，不涉及到多态

引用数据类型

普通类

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

public class OOP01 {
    public static void main(String[] args) {
        Student s = new Student();
        Person p1 = s.study();
        Person eat = s.eat();
        System.out.println(p1);
        System.out.println(eat);
    }
}


class Person{

}

class Student{
    public Person study(){
        return new Person();
    }
    public Person eat(){
        Person p = new Person();
        return p;
    }
}

 

抽象类

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

如果使用该类的子类来接收，需要使用强制类型装换（使用强制类型转换需要注意强制转换的异常）

public class OOP01 {
    public static void main(String[] args) {
        Student s = new Student();
        APerson p1 = s.study();
        APerson eat = s.eat();
        //自类接收父类发返回需要强制类型转换
        Person p3 = (Person) s.study();//强制转换有可能出现异常
        if (eat instanceof Person){
            Person p4 = (Person)eat;
        }

        System.out.println(p1);
        System.out.println(eat);
    }
}


abstract class APerson{

}

class Person extends APerson{

}

class Student{
    public APerson study(){
        return new Person();
    }

    public APerson eat(){
        return new APerson(){};
    }
}

接口

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

如果使用实现类来接收，需要使用强制类型装换（使用强制类型转换需要注意强制转换的异常）

public class OOP01 {
    public static void main(String[] args) {
        Student s = new Student();
        IPerson p1 = s.study();
        IPerson eat = s.eat();
        //自类接收父类发返回需要强制类型转换
        Person p3 = (Person) s.study();//强制转换有可能出现异常
        if (eat instanceof Person){
            Person p4 = (Person)eat;
        }

        System.out.println(p1);
        System.out.println(eat);
    }
}


interface IPerson{

}

class Person implements IPerson{

}

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

    public IPerson eat(){
        return new IPerson(){};
    }
}

 

当方法的返回值类型是引用类型的时候，可以使用链式调用

//链式调用
IPerson p5 = p1.eat().run().sleep();

interface IPerson{
    IPerson sleep();
    IPerson run();
    IPerson eat();
}

class Person implements IPerson{

    @Override
    public IPerson sleep() {
        return this;
    }

    @Override
    public IPerson run() {
        return this;
    }

    @Override
    public IPerson eat() {
        return this;
    }
}

内部类

概念：

　　 将类定义在类的内部，就是内部类

 

 内部类不能被外界直接实例化，还有（抽象类，接口，所有构造方法，被private修饰的类型 ）

 

 

为什么要使用内部类

提高类的安全性

内部类的特点

>内部类可以直接访问外部类的所有的成员（变量和方法）

>外部类如果要访问内部类成员，必须创建内部类对象来实现

>内部类编译后的class文件命名有别于普通类：外部类$，内部类.classOu$Inner.class

>访问内部类的成员是非常麻烦的，而且造成程序耦合性增强，可读性降低，所以内部类慎用

 

 

 

 

搜索

复制