面向对象(15)：形式参数和返回值问题案例

一、形式参数

形式参数：
    （1）基本数据类型：byte、short、int、long、float、double、char、boolean
    （2）引用数据类型：类、接口、数组、抽象类

1、当类作为形参：实际上传的是该类的对象的地址值

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

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

public class StudentTest {
    public static void main(String[] args) {
        StudentDemo sd = new StudentDemo();
        //使用匿名对象传参
        sd.fun(new Student());
    }
}
        执行结果如下：
                好好学习天天向上

                Process finished with exit code 0

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 p){ 
        p.study();
    }
}

//测试类
public class PersonTest {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo();
        //使用匿名对象传参
        pd.fun(new Student2());//将抽象类的子类对象的地址值传进去
    }
}
            执行结果如下：
                        好好学习天天向上

                        Process finished with exit code 0

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 person2 = new Teacher();
        person2.study();
    }
}

public class TeacherTest {
    public static void main(String[] args) {
        TeacherDemo td = new TeacherDemo();
        td.fun(new Teacher());
    }
}
			执行结果如下：
                        好好学习天天向上

                        Process finished with exit code 0

二、返回值类型

返回值：
    （1）基本数据类型：byte、short、int、long、float、double、char、boolean
    （2）引用数据类型：类、接口、抽象类

1、当类作为返回值，返回的结果是什么？

当类作为方法的返回值类型的时候，返回是实际上是该类对象的地址值

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

class StudentDemo3{
   public Student3 fun(){
		//return new Student3();
        //当类作为方法的返回值类型的时候，返回是实际上是该类对象的地址值
       Student3 s = new Student3();
       return s;
   }
}

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

2、当抽象类作为返回值，返回的结果是什么？

需要的是该抽象类子类的对象

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

class PersonDemo3{
    public Person3 getPerson(){
        //抽象类不能实例化
		//Person3 person3 = new Person3();
		//return person3;

		//Doctor doctor = new Doctor();//该方法可行
		//return doctor;
        Person3 person3 = new Doctor();//建议使用该方法
        return person3;
    }
}

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

public class PersonTest2 {
    public static void main(String[] args) {
        PersonDemo3 pd3 = new PersonDemo3();
        Person3 person3 = pd3.getPerson(); //Person3 person3 = new Doctor();
        person3.study();
    }
}
            执行结果如下：
                        医生学习医术

                        Process finished with exit code 0

3、当接口作为返回值，返回的结果是什么？

需要的是实现该接口的类的对象

interface PlayGame{
    public abstract void playLoL();
}

class Teacher2 implements PlayGame{

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

class TeacherDemo2{
    public PlayGame getPlayGame(){
        PlayGame pg = new Teacher2();
        return pg;
    }
}

public class TeacherTest2 {
    public static void main(String[] args) {
       /*
        TeacherDemo2 td2 = new TeacherDemo2();
        //使用接口多态
         PlayGame pg = td2.getPlayGame();
         pg.playLoL();
       */
      
        	/*
             td2用new TeacherDemo2()替代，得：
             PlayGame pg = new TeacherDemo2().getPlayGame();
             pg.playLoL();

             pg用new TeacherDemo2().getPlayGame();替代，得：
             new TeacherDemo2().getPlayGame().playLoL();
         	*/

        //链式编程(后面大家会学习scala,spark,flink)
        new TeacherDemo2().getPlayGame().playLoL();
    }
}
        执行结果如下：
                老师打英雄联盟

                Process finished with exit code 0