面向对象4（传参与返回值）

类名作为形式参数

public class MyTest {
    public static void main(String[] args) {
//        当你以后看到一个方法的形参要一个类类型，你就传递一个该类的对象。
        Student student = new Student();
        show(student,20);
        System.out.println(student.num);//20
        student.setNum(40);
        System.out.println(student.num);//40
        show(new Student(),20);
        student.setNum(40);
        System.out.println(student.num);//40
    }
    public  static void  show(Student student,int num){
        student.num= num;
    }
}
class Student{
    int num=100;

    public void setNum(int num) {
        this.num = num;
    }
}

当你以后看到一个方法的形参要一个类类型，你就传递一个该类的对象。

抽象类名作为形式参数

public class MyTest2 {
    public static void main(String[] args) {
//        当你以后看到一个方法的形参要一个抽象类类型，你就传递一个该抽象类的子类对象。
        BB bb = new BB();
        show(bb,50);//多态，这个num设给父类中的num，没有设给子类，编译看左边，运行也看左边
        System.out.println(bb.num);
        bb.aa();//找最近的num
    }
    public static void show(AA aa,int num ){
        aa.num=num;
    }
}
abstract class AA{
    int num = 100;
    public abstract void aa();
}
class BB extends AA{
int num = 20;
    @Override
    public void aa() {
        System.out.println(num);
    }
}

当你以后看到一个方法的形参要一个抽象类类型，你就传递一个该抽象类的子类对象。

接口名作为形式参数

public class MyTest3 {
    public static void main(String[] args) {
//        当你以后看到一个方法的形参要一个接口类型，你就传递一个该接口的子类对象。
        MyClass myClass = new MyClass();
        show(myClass);
        System.out.println(myClass.num);//20
        System.out.println(MyInterface.num);//100
    }
    public static void show(MyInterface myInterface){
        System.out.println(myInterface.num);//100
    }
}
interface MyInterface{
    int num = 100;
    void aa();
}
class MyClass implements MyInterface{
int num = 20;

    public void setNum(int num) {
        this.num = num;
    }

    @Override
    public void aa() {
        System.out.println(num);
    }
}

当你以后看到一个方法的形参要一个接口类型，你就传递一个该接口的子类对象。

类名作为返回值类型

public class MyTest {
    //    当你以后看到一个方法的返回值类型，是一个类类型，你就返回一个该类的对象。
    public static void main(String[] args) {
        Student student = getStudent();
        student.setNum(80);
        int num = student.getNum();
        System.out.println(num);//80

    }

    public static Student getStudent(){
        Student student = new Student();
        student.num=50;
        return student;
    }
}
class Student{
    int num=20;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}

当你以后看到一个方法的返回值类型，是一个类类型，你就返回一个该类的对象。

抽象类名作为返回值类型

public class MyTest2 {
    public static void main(String[] args) {
        CC cc=test();
        cc.cc();
    }
//    当你以后看到一个方法的返回值类型是一个抽象类类型，你就返回一个该抽象类的子类对象。
    public static CC test(){
        MyClass myClass = new MyClass();
        myClass.num= 120;

        return myClass;
    }
}
abstract class CC {
    int num =20;
    public abstract void cc();
}
class MyClass extends CC{
int num = 10;
    @Override
    public void cc() {
        System.out.println(num);//120
    }
}

当你以后看到一个方法的返回值类型是一个抽象类类型，你就返回一个该抽象类的子类对象。

接口名作为返回值类型

public class MyTest3 {
    //当你以后看到一个方法的返回值类型是一个接口类型，你就返回一个该接口的子类对象。
    public static void main(String[] args) {
        MyInterface myInterface = test(8);
        System.out.println(myInterface.num);//100多态形式访问成员变量
        System.out.println(MyInterface.num);//100
    }
    public static MyInterface test(int num){
        BB bb=new BB();
        bb.num=num;
        return bb;
    }
}
interface MyInterface{
    int num = 100;
    public abstract void show(int num);
}
class BB implements MyInterface {
    int num = 20;
    public void setNum(int num) {
        this.num = num;
    }
    @Override
    public void show(int num) {
        System.out.println(num);
    }
}

当你以后看到一个方法的返回值类型是一个接口类型，你就返回一个该接口的子类对象。