Java方法参数类型及返回值为类、抽象类、接口

方法参数类型以及返回值

一、类名作为形式参数

一个方法的形参要一个类 类型，就传一个该类的对象

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        int num=2;
        set(student,num); //student.num=2
        student.show(new Student(),100);
        System.out.println(student.num);//2
    }

    public static void set(Student student,int num){
        student.num=num;
    }
}

class Student{
    int num=10;
    public void show(Student student,int num){
        student.num=num;
    }
}
//输出结果：2

二、抽象类名作为形式参数

一个方法的形参要一个抽象类 类型，传一个该抽象类的子类对象

public class MyTest {
    public static void main(String[] args) {
        int num=1;
        Zi zi = new Zi();
        set(new Zi(),num);//新创建了一个对象，与zi对象无关
        zi.show(188);
        System.out.println(zi.num); //188
    }

    public static void set(Fu fu,int num){
        fu.num=num;
    }
}

abstract class Fu{
    int num=100;
    public abstract void show(int num);
}

class Zi extends Fu{
    int num=10;
    @Override
    public void show(int num) {
        this.num=num;
    }
}
//输出结果：188

三、接口名作为形式参数

一个方法的形参要一个接口类型，传一个该接口的实现类对象

public class MyTest {
    public static void main(String[] args) {
        int num=1;
        B b = new B();
        set(b,num);
       // b.show(109);
        System.out.println(b.a);//10
        System.out.println(b.NUM); //100
        System.out.println(A.NUM); //100
        System.out.println(B.NUM); //100

    }
    public static void set(A a,int num){
       new B().a=num;
       a.show(num);
    }
}

interface A{
    public static final int NUM=100;
    void show(int num);
}

class B implements A{
        int a=10;
    @Override
    public void show(int num) {
        this.a=num;
    }
}
//输出：
10
100
100
100

四、类名作为返回值类型

一个方法的返回值类型 是一个 类 类型，就返回该类的一个对象

public class MyTest {
    public static void main(String[] args) {
        int num = 100;
        A a = new A();
        A a1 = a.getA(num);//谁调用就返回谁，a调用方法返回的是a
        System.out.println(a.num);// 1
        System.out.println(a1.num); // 1
        System.out.println(a == a1);
    }

    public static A getAA(A a, int num) {
        a.num = num;
        return a;
    }
}

class A {
    int num = 1;
    public A getA(int num) {
        A a = new A();
        a.num = num;
        return a; //return this;
    }
}
//输出：
1
1
true

五、抽象类名作为返回值类型

一个方法的返回值类型是一个抽象类 类型，你就返回一个该抽象类的子类对象

public class MyTest {
    public static void main(String[] args) {
        Zi zi = new Zi();
        Fu fu = zi.getFu(zi, 109);
        System.out.println(zi.num); //109
        System.out.println(fu.num); //109
    }
}

abstract class Fu {
    int num = 10;
}

    public Fu getFu(Fu fu, int num) {
        fu.num = num;
        return this;
    }
}

六、接口名作为返回值类型

一个方法的返回值类型是一个接口类型，就返回该接口的一个子类对象

public class MyTest {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        int num=2;
        MyInterface myInterface = get(myClass, num);
        myClass.show(109);
        System.out.println(myClass.num); //109
        System.out.println(myInterface.NUM);//100
    }

    public static MyInterface get(MyClass myClass,int num){
        myClass.num=num;
        return myClass;
    }
}

interface MyInterface{
    int NUM=100;
    void show(int num);
}

class MyClass implements MyInterface{
    int num=1;
    @Override
    public void show(int num) {
        this.num=num;
    }
}

七、链式编程

链式编程：当调用完一个方法之后，方法的返回值又是一个对象，那么就可以紧接着打点再去调用对象的方法

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        new Student().getStudent(student, 100).show(109);  //一个新的对象，与输出语句无关
        System.out.println(student.num); //100
    }
}

class Student {
    int num = 10; 
    public Student getStudent(Student stu, int num) {
        stu.num = num;
        return this;
    }

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