方法的返回值类型和参数类型

方法的返回值
        基本数据类型&＃xff1a;byte,short,int ,long,float,double,char,boolean
        
        引用数据类型&＃xff1a;
            
            类&＃xff1a;当类作为方法的返回值得的时候&＃xff0c;实际上需要的是该类的对象
             

class Student3{public void study(){System.out.println("好好学习天天向上");}
}
class StudentDemo3{//今后你看到一个方法的返回值是一个类的类型的时候&＃xff0c;//实际上返回的是该类对象的地址值。public Student3 fun(){Student3 s &＃61; new Student3();return s;}
}
public class StudentTest2 {public static void main(String[] args) {StudentDemo3 studentDemo3 &＃61; new StudentDemo3();Student3 s &＃61; studentDemo3.fun();s.study();}
}

            抽象类&＃xff1a;当抽象类作为方法的返回值得时候&＃xff0c;实际上需要的是该抽象类的子类对象的

                           地址值&＃xff0c;
                    

abstract class Person3{public abstract void study();
}
class Doctor extends Person3{&＃64;Overridepublic void study() {System.out.println("好好学习医术");}
}
class PersonDemo3{//今后当你看到一个方法的返回值是一个抽象类类型的时候//需要返回的是该抽象类的子类对象public Person3 fun(){
// Person3 person3 &＃61; new Person3();
// Person3 p &＃61; new Doctor();
// return p;return new Doctor();}
}
public class PersonTest2 {public static void main(String[] args) {PersonDemo3 personDemo3 &＃61; new PersonDemo3();Person3 p &＃61; personDemo3.fun(); //Person3 p &＃61; new Doctor();p.study();}
}

            接口&＃xff1a;当接口作为方法的返回值的时候&＃xff0c;实际上需要的是实现该接口的类对象的地址值&＃xff1b;
             

interface PlayGame3{public abstract void playLol();
}
class Teacher3 implements PlayGame3{&＃64;Overridepublic void playLol() {System.out.println("打英雄联盟");}
}
class TeacherDemo3{//当接口作为返回值类型的时候&＃xff0c;需要的是实现该接口的类的对象public PlayGame3 fun(){return new Teacher3();}
}
public class TeacherTest2 {public static void main(String[] args) {
// TeacherDemo3 teacherDemo3 &＃61; new TeacherDemo3();
// PlayGame3 pg3 &＃61; teacherDemo3.fun();
// pg3.playLol();//链式编程&＃xff08;今后你们所学的spark,flink都是这样的写代码方式&＃xff09;//scalanew TeacherDemo3().fun().playLol();}
}


            数组&＃xff1a;当数组作为方法的返回值得时候&＃xff0c;实际上需要的是数组的地址值&＃xff1b;形式参数
       

方法的形式参数&＃xff1a;

         基本数据类型&＃xff1a;byte,short,int ,long,float,double,char,boolean
        
        引用数据类型&＃xff1a;
            
            类&＃xff1a;当类作为方法的形式参数的时候&＃xff0c;实际上需要的是该类的对象
             

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 &＃61; new StudentDemo();Student student &＃61; new Student();studentDemo.fun(student);}
}

            抽象类&＃xff1a;当抽象类作为方法的形式参数的时候&＃xff0c;实际上需要的是该抽象类的子类实现

                       对象的地 址值&＃xff0c;

abstract class Person {public abstract void study();
}
class Student2 extends Person{&＃64;Overridepublic void study() {System.out.println("好好学习天天向上");}
}
class PersonDemo {//将来你看到当一个抽象类作为参数的类型的时候//实际上需要的时候该类子类实现对象的地址值&＃xff0c;利用多态的形式创建public void fun(Person person) { //Person person &＃61; new Student2()person.study();}
}
public class PersonTest {public static void main(String[] args) {PersonDemo personDemo &＃61; new PersonDemo();//抽象类不能被实例化
// Person person &＃61; new Person();
// Person p &＃61; new Student2();
// personDemo.fun(p);personDemo.fun(new Student2());}
}

            
            接口&＃xff1a;当接口作为方法的形式参数的时候&＃xff0c;实际上需要的是该接口的实现类对象的

                      地址值&＃xff0c;利用接口多态的方式创建&＃xff1b;

interface Person2 {public abstract void study();
}
class Teacher implements Person2{&＃64;Overridepublic void study() {System.out.println("好好学习天天赚钱");}
}
class TeacherDemo{//今后你看到一个方法的参数类型是一个接口的时候&＃xff0c;//实际上需要的是该接口的实现类对象的地址值&＃xff0c;利用接口多态的方式创建public void fun(Person2 person2){person2.study();}
}
public class TeacherTest {public static void main(String[] args) {TeacherDemo teacherDemo &＃61; new TeacherDemo();
// Person2 person2 &＃61; new Person2();Person2 p &＃61; new Teacher();teacherDemo.fun(p);}
}


             
            数组&＃xff1a;当数组作为方法的形式参数的时候&＃xff0c;实际上需要的是数组的地址值&＃xff1b;