JAVA引用数据类型汇总

引用数据类型

定义

在Java中，引用数据类型（Reference Data Types）与基本数据类型（Primitive Data Types）不同，它们是通过引用来访问的。引用数据类型包括类、接口、数组和枚举等。

1. 类（Class）

类是Java中最常见的引用数据类型。类定义了一种数据结构，它包含字段（属性）和方法（行为）。类是面向对象编程的基础。

java
class Person {
    String name;
    int age;

    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "Alice";
        person.age = 30;
        person.display();
    }
}

2. 接口（Interface）

接口是一种特殊的引用数据类型，它定义了一组方法，但不提供实现。类可以实现一个或多个接口，以定义特定的行为。

java
interface Animal {
    void eat();
    void sleep();
}

class Dog implements Animal {
    public void eat() {
        System.out.println("Dog is eating");
    }

    public void sleep() {
        System.out.println("Dog is sleeping");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.eat();
        dog.sleep();
    }
}

3. 数组（Array）

数组是一种引用数据类型，用于存储固定大小的相同类型元素的集合。数组在创建时需要指定大小，且大小不能更改。

java
public class Main {
    public static void main(String[] args) {
        int[] numbers = new int[5];
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;

        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

4. 枚举（Enum）

枚举是一种特殊的引用数据类型，它表示一组固定的常量。枚举用于定义一组预定义的值。

enum Color {
    RED, GREEN, BLUE
}

public class Main {
    public static void main(String[] args) {
        Color color = Color.RED;
        switch (color) {
            case RED:
                System.out.println("Red color");
                break;
            case GREEN:
                System.out.println("Green color");
                break;
            case BLUE:
                System.out.println("Blue color");
                break;
        }
    }
}

5. 字符串（String）

字符串在Java中是一个类，专门用来表示字符序列。字符串是不可变的，即一旦创建就不能修改。

public class Main {
    public static void main(String[] args) {
        String message = "Hello, World!";
        System.out.println(message);
    }
}

6. 泛型类型（Generic Types）

泛型类型允许类、接口和方法操作任意类型的数据，这样就可以使用一种通用方法，而不需要为每种数据类型编写特定的方法。

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        for (String fruit : list) {
            System.out.println(fruit);
        }
    }
}

class Box<T> {
    private T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }
}

public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.set("Hello, World!");
        System.out.println(stringBox.get()); // 输出：Hello, World!

        Box<Integer> intBox = new Box<>();
        intBox.set(123);
        System.out.println(intBox.get()); // 输出：123
    }
}

在这个例子中，Box是一个泛型类，其中T是一个类型参数。我们可以使用Box来创建一个存储字符串的盒子，或者使用Box来创建一个存储整数的盒子。

• 泛型方法

class Util {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] stringArray = {"A", "B", "C", "D", "E"};

        Util.printArray(intArray); // 输出：1 2 3 4 5
        Util.printArray(stringArray); // 输出：A B C D E
    }
}

在这个例子中，printArray是一个泛型方法，其中是类型参数。这个方法可以接受任何类型的数组，并打印出数组的每个元素。

面试题

String a = new String（“1”） 和 String a = “1” 有什么区别？

在Java中，String a = new String(“1”); 和 String a = “1”; 都是有效的 String 初始化方法，但它们之间有一些重要的区别：

1. 字符串池（String Pool）

String a = “1”;

• 描述：这行代码会将字符串 “1” 赋值给变量 a。Java 使用字符串池来管理字符串常量。如果池中已经存在内容为 “1” 的字符串，那么 a 将指向池中的那个字符串对象。
• 优点：字符串池可以减少内存占用，因为相同的字符串常量只会存储一次。此方式是创建字符串的推荐方式，因为它利用了字符串池的特性来提高效率。

String a = new String(“1”);

• 描述：这行代码会创建一个新的 String 对象，即使池中可能已经存在 “1” 字符串。new String(“1”) 的构造函数会在堆内存中创建一个新的 String 实例，内容是 “1”。
• 缺点：即使字符串池中已经存在 “1”，这个语句仍然会创建一个新的 String 对象。这样会增加内存消耗，因为你会有两个不同的 String 对象，内容相同但不是同一个实例。

2. 对象比较

String a = “1”;

对象比较：

• 使用 == 比较：a == “1” 会返回 true，因为 a 和 “1” 指向同一个池中的对象。
• 使用 equals() 比较：a.equals(“1”) 也会返回 true，因为它比较的是内容。
  String a = new String(“1”);

对象比较：

• 使用 == 比较：a == “1” 会返回 false，因为 a 是一个新创建的对象，而 “1” 是池中的对象，它们不是同一个实例。
• 使用 equals() 比较：a.equals(“1”) 会返回 true，因为它比较的是内容，a 的内容和 “1” 的内容相同。

3. 性能和内存

String a = “1”;：

• 性能：更高效，因为它利用了字符串池，避免了重复创建对象。
• 内存：节省内存，因为重复的字符串常量都指向同一个对象。

String a = new String(“1”);：

• 性能：相对较低，因为每次使用 new String() 都会在堆上创建一个新的 String 实例。
• 内存：增加内存消耗，因为每个 new String() 都会创建一个新的对象，即使内容相同。

总结

• String a = “1”;：这种方式利用了字符串池，创建的是池中的共享字符串，效率更高，节省内存。
• String a = new String(“1”);：这种方式总是创建一个新的 String 对象，尽管内容相同，但会在堆上额外分配内存。
• 通常情况下，推荐使用 String a = “1”;，因为它更高效，充分利用了字符串池。如果确实需要创建新的 String 对象，可以使用 new String()，但这种情况较少见。