方法参数类型以及返回值

方法参数类型以及返回值

（一）方法参数类型

一、类名作为形式参数

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

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

(二)返回值

1、类名作为返回值类型

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

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

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

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

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;
}

}

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

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

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;
    }
}