Java数据类型分类，转换以及传参机制

数据类型的分类

Java 语言的数据类型分为两种：基本数据类型和引用数据类型。

(1) 基本数据类型包括 boolean（布尔型）、float（单精度浮点型）、char（字符型）、byte（字节型）、short（短整型）、int（整型）、long（长整型）和 double （双精度浮点型）共 8 种，详见表 1 所示。

所有的基本数据类型的大小（所占用的字节数）都已明确规定，在各种不同的平台上保持不变，这一特性有助于提高 Java 程序的可移植性。

(2) 引用数据类型建立在基本数据类型的基础上，包括数组、类和接口。引用数据类型是由用户自定义，用来限制其他数据的类型。另外，Java 语言中不支持 C++中的指针类型、结构类型、联合类型。

基本数据类型转换 

 

找出以下类型转换的编译错误：

public class Main {
    public static void main(String[] args) {
         int n1 = 10;
         float d1 = n1 + 1.1;
         double d2 = n1 + 1.1;
         float d3 = n1 + 1.1f;
         int n2 = 1.1;
         byte b1 = 10; // -128~127
         int n3 = 1;
         byte b2 = n3;
         char c1 = b1;
         byte b3 = 1;
         byte b4 = 2;
         short s1 = 1;
         short s2 = b3 + s1;
         int s3 = b3 + s1;
         byte b5 = b3 + b4;
         short s4 = 100;
         int num200 = 1;
         float num300 = 1.1f;
         double num500 = b4 + s3 + num200 + num300;
         short s = 12;
         s -= 9;
         byte b = 10;
//         b = b + 11;
         b = (byte)(b + 11);
         char c = 'a';
         int i = 16;
         float d = .314f;
         double result = c + i + d;
         byte b6 = 16;
         short s6 = 14;
         short t = s6 + b6; // byte + short -> int
    }
}

数据类型的传参机制 

基本数据类型的传参机制

值拷贝，形参任何改变不影响实参

我的理解：方法中的参数只是main函数中数据的副本（copy一份给方法），修改的是在引用的方法（swap）栈中的副本，之后栈销毁，main中基本数据类型不变。

public class BaseTransmit {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        A a1 = new A();
        a1.swap(a,b);
        System.out.println("main 中 a = " + a + " main 中 b = " + b);
        
    }
}
class A {
    public void swap(int a,int b) {
        int temp = a;
        a = b;
        b = temp;
        System.out.println("swap后 a = " + a + " swap 后 b = " + b);
    }
}

引用数据类型的传参机制

传递的是对象地址

public class QuoteTransmit {
    public static void main(String[] args) {
        B b = new B();
        int[] arr = {1,2,3};
        b.test1(arr);
        System.out.println("调用test1之后");
        for(int i : arr) {
            System.out.println(i);
        }
    }

}
class B {
    public void test1(int arr[]) {
        arr[0] = 1248;  // 修改元素
    }
}

 

思考下面这个片段：

public class QuoteTransmit01 {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "jack";
        person.age = 8;
        B b = new B();
        System.out.println("修改之前 " + person);
        b.test2(person);
        System.out.println("修改之后 " + person);
    }

}
class Person {
    String name;
    int age;
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class B {
    public void test2(Person p) {
        // 1 修改对象属性
//        p.age = 8848;
        // 2 将p指向新空间
        p = new Person();
        p.name = "tom";
        p.age = 12;
        // 3 将 p 置空
//        p = null;

    }
}

补充：方法调用机制

1：当程序执行到方法时，就会开辟一个独立的栈空间（向上开辟）

2：当方法执行完毕，或执行到return语句时，就会返回到调用该方法的地方

3：返回后，继续执行方法后面的代码

4：当main方法执行完毕，退出程序

文章可能存在错误，还请各位大佬不吝赐教，及时指出，感谢！