Java基础知识（十七）（面向对象--8）引用类型数据作为形参和返回值

一、引用数据类型作为形式参数的时候
   1、 当类作为参数的类型的时候，实际上需要的是该类的对象的地址值

class Student{
    public void study(){
        System.out.println("好好学习天天向上");
    }
}

class StudentDemo{
    //但凡今后看到一个方法的参数是一个类的类型进行传参的时候
    //实际上穿传的是该类的对象的地址值
    public void fun(Student student){
        student.study();
    }
}

public class StudentTest {
    public static void main(String[] args) {
        StudentDemo studentDemo = new StudentDemo();
        Student student = new Student();
        studentDemo.fun(student);
    }
}

    2、当抽象类作为参数的类型的时候，实际上需要的是该抽象类的子类的对象的地址值

class PersonDemo {
    //将来你看到当一个抽象类作为参数的类型的时候
    //实际上需要的时候该类子类实现对象的地址值，利用多态的形式创建
    public void fun(Person person) { //Person person = new Student2()
        person.study();
    }
}

public class PersonTest {
    public static void main(String[] args) {
        PersonDemo personDemo = new PersonDemo();
        //抽象类不能被实例化
//        Person person = new Person();
//        Person p = new Student2();
//        personDemo.fun(p);
        personDemo.fun(new Student2());
    }

    3、当接口作为形式参数的类型的时候，实际上需要的是实现该接口的类的对象

interface Person2 {
    public abstract void study();
}

class Teacher implements Person2{

    @Override
    public void study() {
        System.out.println("好好学习天天赚钱");
    }
}

class TeacherDemo{
    //今后你看到一个方法的参数类型是一个接口的时候，
    //实际上需要的是该接口的实现类对象的地址值，利用接口多态的方式创建
    public void fun(Person2 person2){
        person2.study();
    }
}


public class TeacherTest {
    public static void main(String[] args) {
        TeacherDemo teacherDemo = new TeacherDemo();
//        Person2 person2 = new Person2();
        Person2 p = new Teacher();
        teacherDemo.fun(p);
    }
}

二、引用数据类型作为方法的返回值的时候
    1、当类作为方法的返回值类型的时候，实际上需要的是该类的对象

class Student3{
    public void study(){
        System.out.println("好好学习天天向上");
    }
}

class StudentDemo3{
    //今后你看到一个方法的返回值是一个类的类型的时候，
    //实际上返回的是该类对象的地址值。
    public Student3 fun(){
        Student3 s = new Student3();
        return s;
    }
}

public class StudentTest2 {
    public static void main(String[] args) {
        StudentDemo3 studentDemo3 = new StudentDemo3();
        Student3 s = studentDemo3.fun();
        s.study();
    }
}

    2、当抽象类作为方法的返回值的时候，实际上需要的是该抽象类子类的对象

abstract class Person3{
    public abstract void study();
}

class Doctor extends Person3{
    @Override
    public void study() {
        System.out.println("好好学习医术");
    }
}

class PersonDemo3{
    //今后当你看到一个方法的返回值是一个抽象类类型的时候
    //需要返回的是该抽象类的子类对象
    public Person3 fun(){
//        Person3 person3 = new Person3();
//        Person3 p = new Doctor();
//        return p;
        return new Doctor();
    }
}

public class PersonTest2 {
    public static void main(String[] args) {
        PersonDemo3 personDemo3 = new PersonDemo3();
        Person3 p = personDemo3.fun(); //Person3 p = new Doctor();
        p.study();
    }
}

    3、当接口作为方法的返回值的时候，实际上需要的是实现该接口具体的类的对象

interface PlayGame3{
    public abstract void playLol();
}

class Teacher3 implements PlayGame3{

    @Override
    public void playLol() {
        System.out.println("打英雄联盟");
    }
}

class TeacherDemo3{
    //当接口作为返回值类型的时候，需要的是实现该接口的类的对象
    public PlayGame3 fun(){
        return new Teacher3();
    }
}


public class TeacherTest2 {
    public static void main(String[] args) {
//        TeacherDemo3 teacherDemo3 = new TeacherDemo3();
//        PlayGame3 pg3 = teacherDemo3.fun();
//        pg3.playLol();
        new TeacherDemo3().fun().playLol();
    }
}