形式参数和返回值问题

形式参数问题

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.当抽象类作为形式参数传参的时候，实际上需要的是该类子类实现对象的地址值，利用多态的形式创建

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

class Student2 extends Person {
    @Override
    public void study() {
        System.out.println("好好学习，天天向上");
    }
}

class PersonDemo {
    public void fun(Person person) {
        person.study();
    }
}

public class PersonTest {
    public static void main(String[] args) {
        PersonDemo personDemo = new PersonDemo();
        //抽象类无法被实例化
//        Person p = 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(new Teacher());
    }
}

返回值问题

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() {
//        PlayGame3 pg = new Teacher3();
//        return pg;
        //换一种写法
        return new Teacher3();
    }
}

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

        //链式编程
        //上面三行代码用链式编程改进（spark,flink都是这样的写代码方式）
        new TeacherDemo3().fun().playLol();
    }
}