目    录

 1.值传递​

2.址传递​

方法的形参是数组类型

 方法的形参是 类 类型

 方法的形参是 抽象类 类型

 1.值传递

基本类型作为参数传递,属于值传递!传递的是变量的值,形参的改变不会影响实参的值!

public class Test {

    public static void main(String[] args) {
        //创建对象
        Test test=new Test();
        int num=100;
        System.out.println("传入num参数之前:"+num);
        //调用chuancan方法,传入参数num
        chuancan(num);
        System.out.println("传入num参数之后:"+num);

    }

    public static void chuancan(int n){       //传入参数n
        System.out.println("传入num参数到方法中运算前"+n);
        n+=20;
        System.out.println("传入num参数到方法中运算后"+n);
    }
    
//    传入num参数之前:100
//    传入num参数到方法中运算前100
//    传入num参数到方法中运算后120
//    传入num参数之后:100
    //传入num参数前后没有变化!不影响实参的值
}

2.址传递

引用类型作为参数传递,属于引用传递(址传递).传递的是地址值,形参的改变会影响实参的值!

方法的形参是数组类型

当咱们以后看到一个方法的形参要一个数组类型,你就传递一个该数组的地址值过去。

public class Test1 {
    public static void main(String[] args) {
        //定义数组
        int[] arr={1,2,3,4,5};
        //调用方法chuancan,传入引用类型的参数(数组)
        chuancan(arr);
        //遍历一下传参后的数组元素
        for(int i=0;i<arr.length;i++) {
            System.out.println(arr[i]);
        }
        
        //结果是1  4  3  8  5
        //传入的形参影响了实参的值
        }

    private static void chuancan(int[] arr) {     //传入数组
        for (int i=0;i<arr.length;i++){
        if (arr[i]%2==0){
            arr[i]*=2;
        }
        }
    }
}

如下图中的内存图!数组的地址值返回到了栈内!对其堆内的值进行修改需要找到地址值,然后进行修改!所以是完全的修改掉了!

 方法的形参是 类 类型

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

public class MyTest {
    public static void main(String[] args) {
        int num = 20;
        Student student = new Student();
        student.num = 50;
        //方法的形参要一个类 类型，就传递一该类的对象。
        test(student, num);
        System.out.println(student.num); //20(就近原则)
    }

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

class Student {
    int num = 100;

    public void show(Student studnet, int num) {
        studnet.num = num;
    }
}

 方法的形参是 抽象类 类型

当咱们以后看到一个方法的形参，要一个 抽象类 类型，你就传递一个该抽象类的子类对象。 说白了，就是多态的形式

public class MyTest {
    public static void main(String[] args) {
        //方法的形参要一个 抽象类 类型，就传递一个该抽象类的子类对象
        //多态形式
        AA aa = new BB();
        aa.num = 88;
        test(aa, 2);
        System.out.println(aa.num); //2
    }

    public static void test(AA aa, int num) { //AA aa=bb 多态
        //多态形式访问成员变量，编译看左边，运行也看左边。
        aa.num = num;
    }
}

abstract class AA {
    int num = 100;

    public abstract void aa(int num);
}

class BB extends AA {
    int num = 30;

    @Override
    public void aa(int num) {
        this.num = num;
    }
}

  方法的形参是 接口 类型

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

public class MyTest {
    public static void main(String[] args) {
        //方法的形参要一个 接口 类型，就传递一个该接口的实现类的对象。
        DD dd = new DD();
        test(dd);
        System.out.println(dd.num);//100
    }

}

interface MyInterface {
    public static final int num = 100;

    void show();
}

class DD implements MyInterface {
    @Override
    public void show() {
        System.out.println(this.num);
    }
}

   (小编也在努力学习更多哟!以后会多多分享哒!)  

希望对友友们有所帮助!!!!