方法参数类型以及返回值

蔚落 2021-12-24 08:17 346阅读 0赞

# 方法参数类型以及返回值 #

# （一）方法参数类型 #

## 一、类名作为形式参数 ##

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

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