Java-运算

参数传递

一针见血，Java参数传递是以值传递的方式进行的。

将对象作为参数传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Dog {

    String name;

    Dog(String name) {
        this.name = name;
    }

    String getName() {
        return this.name;
    }

    void setName(String name) {
        this.name = name;
    }

    String getObjectAddress() {
        return super.toString();
    }
}

当对象作为参数传递时，本质是将对象的地址以值的方式传递到形参中。

所以在方法中改变对象的字段值会改变原对象的字段值，因为引用的是同一个对象。

1
2
3
4
5
6
7
8
9
10
11
class PassByValueExample {
    public static void main(String[] args) {
        Dog dog = new Dog("A");
        func(dog);
        System.out.println(dog.getName());          // B
    }

    private static void func(Dog dog) {
        dog.setName("B");
    }
}

如果在方法中引用了其他对象，此时方法里和方法外的两个指针指向了不同对象，在一个指针改变其所指向对象的内容对另一个指针所指向的对象没有影响。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class PassByValueExample {
    public static void main(String[] args) {
        Dog dog = new Dog("A");
        System.out.println(dog.getObjectAddress()); // Dog@4554617c
        func(dog);
        System.out.println(dog.getObjectAddress()); // Dog@4554617c
        System.out.println(dog.getName());          // A
    }

    private static void func(Dog dog) {
        System.out.println(dog.getObjectAddress()); // Dog@4554617c
        dog = new Dog("B");
        System.out.println(dog.getObjectAddress()); // Dog@74a14482
        System.out.println(dog.getName());          // B
    }
}

将基本类型作为参数传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Test1 {

       public static void main(String[] args) {

        int n = 3;

        System.out.println("Before change, n = " + n);//3

        changeData(n);

        System.out.println("After changeData(n), n = " + n);//3

    }

       public static void changeData(int nn) {

        n = 10;

    }

}

基本类型作为参数传递时，是传递值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的

结论

  1. 基本类型作为参数传递时，是传递值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的
  2. 对象作为参数传递时，是把对象在内存中的地址拷贝了一份传给了参数。

参考：CS-NOTES)、java参数传递（到底是值传递还是引用传递？）

float 和 double

Java 不能隐式执行向下转型，因为这会使得精度降低。

1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。

1
// float f = 1.1;

1.1f 字面量才是 float 类型。

1
float f = 1.1f;

## 隐式类型转换

因为字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型向下转型为 short 类型。

1
2
short s1 = 1;
// s1 = s1 + 1;

但是使用 += 或者 ++ 运算符会执行隐式类型转换。

1
2
s1 += 1;
s1++;

上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：

1
s1 = (short) (s1 + 1);

switch

从 Java 7 开始，可以在 switch 条件判断语句中使用 String 对象。

1
2
3
4
5
6
7
8
9
String s = "a";
switch (s) {
    case "a":
        System.out.println("aaa");
        break;
    case "b":
        System.out.println("bbb");
        break;
}

switch 不支持 long，是因为 switch 的设计初衷是对那些只有少数几个值的类型进行等值判断，如果值过于复杂，那么还是用 if 比较合适。

1
2
3
4
5
6
7
8
9
// long x = 111;
// switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
//     case 111:
//         System.out.println(111);
//         break;
//     case 222:
//         System.out.println(222);
//         break;
// }