Java 中方法形参为基本类型和引用类型

简单复习下

基本数据类型值传递

值传递,原变量的值不会被修改

private final Consumer sout = System.out::println;

    @Before
    public void init() {
    }

    /**
     * 基本数据类型值传递
     * 值传递,原变量的值不会被修改
     */
    @Test
    public void basicDataType() {
        final BiConsumer<Integer, Integer> biConsumer = (a, b) -> {
            // 11 ^ 101 = 110
            a = a ^ b;
            // 110 ^ 101 = 011
            b = a ^ b;
            // 110 ^ 011 = 101
            a = a ^ b;
        };

        int a = 3, b = 5;
        biConsumer.accept(a, b);

        sout.accept(a);
        sout.accept(b);
    }

 

传递数组类型的引用

结果值全部为1,全部被修改

@Test
    public void array() {
        Consumer<int[]> consumer = (int[] arr) -> Arrays.fill(arr, 1);
        int[] arr = {1, 2, 3, 4, 5};
        consumer.accept(arr);

        for (int i = 0; i < arr.length; i++) {
            sout.accept(arr[i]);
        }
    }

 

方法形参为对象

* 如果在方法内部修改该对象的属性,外部引用属性值会跟着变化
* 如果在方法内部修改该引用,外部不会发生变化

@Test
    public void object() {
        Consumer<DotaHero> setNameSF = (d) -> d.setName("SF");
        DotaHero sf = new DotaHero();
        setNameSF.accept(sf);

        // DotaHero(name=SF, kind=null, sex=null)
        // 引用的属性被修改
        sout.accept(sf);

        DotaHero karl = new DotaHero();
        karl.setName("karl");

        BiConsumer<DotaHero, DotaHero> swap = (s, k) -> {
            DotaHero temp;
            temp = s;
            s = k;
            k = temp;
        };

        // 未被更改
        // DotaHero(name=SF, kind=null, sex=null)
        // DotaHero(name=karl, kind=null, sex=null)
        sout.accept(sf);
        sout.accept(karl);


        Consumer<DotaHero> setNameKarl = (d) -> {
            DotaHero temp = d;
            temp.setName("karl");
        };

        setNameKarl.accept(sf);
        // 被更改
        // DotaHero(name=karl, kind=null, sex=null)
        sout.accept(sf);
    }

 

转载于:https://www.cnblogs.com/theRhyme/p/11577132.html

Java中,传入形参的子类报错参数类型不一致的情况通常是由于方法参数的类型声明实际传入的对象类型不匹配导致的。具体来说,主要有以下几个原因: 1. **方法签名不匹配**:如果方法声明的参数类型是父类,而实际传入的是子类对象,通常是可以正常运行的,因为子类对象可以被视为父类的实例。但是,如果方法声明的参数类型是子类,而实际传入的是父类对象,就会报错,因为父类对象不能被视为子类的实例。 2. **泛型擦除**:在泛型编程中,Java在编译时会进行类型擦除,泛型类型会被替换为原始类型(Raw Type)。如果传入的对象类型与泛型参数不匹配,也会导致参数类型不一致的错误。 3. **自动装箱拆箱**:在方法调用过程中,基本数据类型包装类之间的自动装箱拆箱也可能导致类型不匹配。例如,方法声明的参数类型是`Integer`,而实际传入的是`int`,虽然Java会自动进行装箱,但如果方法重载时存在多个版本,可能会导致调用错误。 4. **多态性限制**:虽然多态性允许父类引用指向子类对象,但如果方法内部对对象类型进行了特定的类型检查(如`instanceof`),并且方法实现依赖于具体的子类类型,可能会导致运行时错误。 以下是一个简单的示例,展示了参数类型不一致的情况: ```java class Animal { void makeSound() { System.out.println("Some generic animal sound"); } } class Dog extends Animal { void makeSound() { System.out.println("Bark"); } } public class Test { static void testAnimal(Animal a) { a.makeSound(); } public static void main(String[] args) { Dog d = new Dog(); testAnimal(d); // 这是允许的,因为Dog是Animal的子类 Animal a = new Animal(); testAnimal(a); // 这是允许的,因为a是Animal类型 // 如果方法声明的是Dog类型,而传入的是Animal类型,会报错 // testAnimal(Dog a) { // a.makeSound(); // } // Animal a = new Animal(); // testAnimal(a); // 报错,参数类型不一致 } } ``` 在这个示例中,`testAnimal`方法声明的参数类型是`Animal`,因此传入`Dog`对象是允许的,因为`Dog`是`Animal`的子类。但是,如果方法声明的参数类型是`Dog`,而传入的是`Animal`对象,就会报错,因为`Animal`对象不能被视为`Dog`的实例。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值