1.1 Java基础面试题总结

palomua

于 2024-09-03 16:40:24 发布

阅读量277

点赞数 13

文章标签： java

本文链接：https://blog.csdn.net/qq_43624584/article/details/141865731

版权

1、面向对象和面向过程的区别

面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发

面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以易维护、易复用、易扩展。可以设计出低耦合的系统。但是性能上来说，比面向过程要低。

AOP：AOP是一种编程范式，它通过将横切关注点（如日志记录、事务管理、安全性等）从业务逻辑中分离出来，以提高代码的模块化程度。AOP更关注如何将横切关注点模块化，通过切面、连接点、切入点和通知等机制将横切关注点分离出来，适用于日志记录、事务管理、安全性等横切关注点的实现。比如使用了 @Before 和 @After 注解来指定在 UserService 的 addUser 和 deleteUser 方法执行前后要执行的代码。

2、介绍下Java中的基本数据类型

Java 中有八种基本数据类型，分为四类：整数类型、浮点类型、字符类型和布尔类型。以下是每种数据类型的详细介绍：

整数类型

byte:
- 大小：8 位
- 范围：-128 到 127
- 用途：主要用于节省内存，在大型数组中使用时效果显著。
short:
- 大小：16 位
- 范围：-32,768 到 32,767
- 用途：与 byte 类似，用于节省内存。
int:
- 大小：32 位
- 范围：-2^31 到 2^31-1 (约 -21亿到 21亿)
- 用途：默认的整数类型，适用于一般的整数运算。
long:
- 大小：64 位
- 范围：-2^63 到 2^63-1
- 用途：用于需要更大范围的整数运算。

浮点类型

float:
- 大小：32 位
- 范围：约 1.4E-45 到 3.4E38，精度为7位有效数字
- 用途：用于保存小数，通常用于节省内存的大型数组中，浮点数后需加f或F后缀，如 3.14f。
double:
- 大小：64 位
- 范围：约 4.9E-324 到 1.8E308，精度为16位有效数字
- 用途：默认的浮点数类型，用于保存更高精度的浮点数值。

字符类型

char:
- 大小：16 位
- 范围：0 到 65,535 (表示单个 Unicode 字符)
- 用途：用于存储字符，例如字母、数字或符号。

布尔类型

boolean:
- 大小：非固定大小，通常由虚拟机来实现（通常是1位或者1字节）
- 取值：true 或 false
- 用途：用于逻辑操作，控制流程判断等。

需要注意：

int是基本数据类型，Integer是int的封装类，是引用类型。int默认值是0，而Integer默认值是null，所以Integer能区分出0和null的情况。一旦java看到null，就知道这个引用还没有指向某个对象，再任何引用使用前，必须为其指定一个对象，否则会报错。
基本数据类型在声明时系统会自动给它分配空间，而引用类型声明时只是分配了引用空间，必须通过实例化开辟数据空间之后才可以赋值。数组对象也是一个引用对象，将一个数组赋值给另一个数组时只是复制了一个引用，所以通过某一个数组所做的修改在另一个数组中也看的见。
虽然定义了boolean这种数据类型，但是只对它提供了非常有限的支持。在Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java虚拟机中的int数据类型来代替，而boolean数组将会被编码成Java虚拟机的byte数组，每个元素boolean元素占8位。这样我们可以得出boolean类型占了单独使用是4个字节，在数组中又是1个字节。使用int的原因是，对于当下32位的处理器（CPU）来说，一次处理数是32位（这里不是指的是32/64位系统，而是指CPU硬件层面），具有高效存取的特点。

3、标识符的命名规则

标识符的含义：是指在程序中，我们自己定义的内容，譬如，类的名字，方法名称以及变量名称等等，都是标识符。

命名规则：（硬性要求）标识符可以包含英文字母，0-9的数字，$以及_ 标识符不能以数字开头，标识符不是关键字
命名规范：（非硬性要求）类名规范：首字符大写，后面每个单词首字母大写（大驼峰式）。变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。方法名规范：同变量名。

4、instance of关键字的作用

在 Java 中，instanceof 是一个关键字，用于测试一个对象是否是一个特定类的实例，或者是否是该类的子类的实例。它返回一个布尔值，true 表示该对象是指定类或其子类的实例，false 表示不是。

使用场景

类型检查: instanceof 常用于在运行时检查对象的类型，以避免 ClassCastException 异常。
安全的类型转换: 在进行类型转换之前，可以使用 instanceof 来确保转换的安全性。
多态性判断: instanceof 可以用来判断某个对象是否实现了某个接口或继承自某个基类。

注意事项

instanceof 操作符用于引用类型的比较，不能用于基本数据类型。
如果左操作数为 null，instanceof 总是返回 false，因为 null 不是任何对象的实例。long·

5、Java重载和重写

Java 中的重载（Overloading）和重写（Overriding）是两种不同的机制，用于实现多态性，但它们的用途和实现方式有所不同。下面详细介绍它们的区别：

重载（Overloading）

定义

重载是指在同一个类中，多个方法具有相同的名称但参数列表不同（参数的个数、类型或顺序不同）。

特点

方法名称：相同。
参数列表：不同（参数的个数、类型或顺序）。
返回类型：可以相同，也可以不同。
访问修饰符：可以相同，也可以不同。
静态/实例方法：可以重载静态方法或实例方法。

作用

提高代码的可读性和灵活性，可以根据不同的输入来调用相应的重载方法。

重写（Overriding）

定义

重写是指在子类中定义一个与父类方法具有相同签名（方法名称、参数列表和返回类型）的实例方法，以实现子类对父类方法的特定实现。

特点

方法名称：相同。
参数列表：相同。
返回类型：相同或是返回类型的子类（Java 5 及以上版本）。
访问修饰符：不能比父类的方法更严格，但可以更宽松（例如，父类方法是 protected，子类可以是 public）。
静态/实例方法：只能重写实例方法，不能重写静态方法。

作用

提供子类对父类方法的具体实现，使子类对象在调用该方法时体现出多态性。

3. 重载 vs 重写的区别

特性重载（Overloading）重写（Overriding）
方法名称 相同相同
参数列表 不同相同
返回类型 可以相同或不同必须相同或是返回类型的子类
访问修饰符 可以相同或不同不能更严格，可以更宽松
静态/实例方法 可以重载静态或实例方法只能重写实例方法，不能重写静态方法
编译时检查 编译时根据参数列表确定调用的重载方法运行时根据对象类型确定调用的重写方法
实现位置 同一个类中子类中对父类方法进行重写

特性	重载（Overloading）	重写（Overriding）
方法名称	相同	相同
参数列表	不同	相同
返回类型	可以相同或不同	必须相同或是返回类型的子类
访问修饰符	可以相同或不同	不能更严格，可以更宽松
静态/实例方法	可以重载静态或实例方法	只能重写实例方法，不能重写静态方法
编译时检查	编译时根据参数列表确定调用的重载方法	运行时根据对象类型确定调用的重写方法
实现位置	同一个类中	子类中对父类方法进行重写

6、讲讲Java内部类

Java 内部类（Inner Class）是定义在另一个类中的类。内部类可以帮助实现更好的代码组织和封装，特别是在需要多个类紧密协作时。Java 提供了几种不同类型的内部类，每种都有其独特的特性和用途。

成员内部类（Member Inner Class）

成员内部类是在外部类的内部定义的类，与外部类的实例关联。

特点

成员内部类可以访问外部类的所有成员（包括私有成员）。
需要通过外部类的实例来创建成员内部类的实例。

class OuterClass {
    private String message = "Hello, World!";

    class InnerClass {
        public void printMessage() {
            System.out.println(message); // 访问外部类的成员
        }
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.printMessage();
    }
}

静态内部类（Static Nested Class）

静态内部类是使用 static 修饰符定义的内部类，它与外部类的实例没有关联，可以直接访问外部类的静态成员。

特点

静态内部类不能访问外部类的非静态成员。
可以直接通过外部类的名称来创建静态内部类的实例。

class OuterClass {
    private static String message = "Hello, Static World!";

    static class StaticInnerClass {
        public void printMessage() {
            System.out.println(message); // 访问外部类的静态成员
        }
    }

    public static void main(String[] args) {
        OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
        inner.printMessage();
    }
}

局部内部类（Local Inner Class）

局部内部类是在方法或代码块中定义的类，类似于局部变量，只能在定义它的方法或代码块中使用。

特点

局部内部类可以访问外部类的成员，以及定义它的作用域中的局部变量（但这些局部变量必须是 final 或有效 final）。
局部内部类不能有访问修饰符，因为它们的作用范围仅限于方法内部。

示例

class OuterClass {
    public void outerMethod() {
        final String localMessage = "Hello from Local Inner Class";
        //为什么加final，从生命周期角度考虑

        class LocalInnerClass {
            public void printMessage() {
                System.out.println(localMessage); // 访问局部变量
            }
        }

        LocalInnerClass inner = new LocalInnerClass();
        inner.printMessage();
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.outerMethod();
    }
}

匿名内部类（Anonymous Inner Class）

匿名内部类是没有名称的局部内部类，通常用于简化创建继承某个类或实现某个接口的类的实例。匿名内部类最常用于创建回调或事件处理器。

特点

匿名内部类必须立即实例化。
只能创建一个实例，并且类体只能出现一次。

interface Greeting {
    void sayHello();
}

public class OuterClass {
    public void greet() {
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hello from Anonymous Inner Class");
            }
        };
        greeting.sayHello();
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.greet();
    }
}

内部类的用途和优点

封装性：内部类可以访问外部类的私有成员，增强了封装性。
代码简洁：匿名内部类可以用来简化代码，特别是在只需要一次性使用的类或接口实现时。
重点聊匿名内部类

注意事项

内部类会隐式地保存对外部类对象的引用，可能会导致内存泄漏，特别是在 Android 开发中。
在外部类的静态上下文中不能直接访问非静态内部类。
静态内部类虽然是静态的，但它们仍然是外部类的成员，只是它们与外部类的实例无关。

Java 内部类是一个强大的工具，可以帮助开发者组织代码，并实现复杂的功能封装。根据实际需求选择合适的内部类类型，有助于提高代码的可读性和维护性。

7、Java中的四种引用

Java 中的四种引用类型（强引用、软引用、弱引用、虚引用）是为了管理对象的生命周期，帮助垃圾回收机制（Garbage Collection，GC）更有效地回收内存。它们的区别在于 GC 对待它们的态度不同。以下是对每种引用的详细介绍：

强引用（Strong Reference）

定义

强引用是 Java 中最常见的引用类型，当一个对象被一个强引用指向时，GC 永远不会回收该对象。

特点

即使内存不足，GC 也不会回收被强引用指向的对象，除非手动将该引用置为 null。
强引用通常用于普通的对象引用。

public class StrongReferenceExample {
    public static void main(String[] args) {
        Object obj = new Object();  // 强引用
        // 只要 obj 还指向该对象，GC 就不会回收这个对象
        obj = null;  // 手动释放对象
    }
}

软引用（Soft Reference）

定义

软引用用于描述一些有用但非必须的对象。GC 在内存不足时会回收这些被软引用指向的对象。

特点

软引用可以用于实现内存敏感的缓存。当内存足够时，这些缓存对象不会被回收，但在内存不足时，这些对象会被 GC 回收以释放空间。
如果 GC 发现一个对象只被软引用关联，并且内存不足，则会回收该对象。
可用场景：创建缓存的时候，创建的对象放进缓存中，当内存不足时，JVM就会回收早先创建的对象。

import java.lang.ref.SoftReference;

public class SoftReferenceExample {
    public static void main(String[] args) {
        Object obj = new Object();
        SoftReference<Object> softRef = new SoftReference<>(obj);

        obj = null; // 原对象现在只被软引用关联

        // 如果系统内存足够，softRef.get() 返回对象的强引用
        System.out.println(softRef.get());

        // 如果内存不足，softRef.get() 可能返回 null
    }
}

弱引用（Weak Reference）

定义

弱引用用于描述非必要的对象，GC 在进行回收时，无论内存是否充足都会回收被弱引用指向的对象。

特点

当 GC 发现一个对象只被弱引用关联时，不论内存是否充足，都会回收该对象。
弱引用通常用于实现一些不必要的对象映射，如 WeakHashMap，用于缓存机制。
可用场景： Java源码中的 java.util.WeakHashMap 中的 key 就是使用弱引用，我的理解就是，一旦我不需要某个引用，JVM会自动帮我处理它，这样我就不需要做其它操作。

import java.lang.ref.WeakReference;

public class WeakReferenceExample {
    public static void main(String[] args) {
        Object obj = new Object();
        WeakReference<Object> weakRef = new WeakReference<>(obj);

        obj = null; // 原对象现在只被弱引用关联

        // GC 会在下次回收时直接回收弱引用对象
        System.out.println(weakRef.get()); // 可能为 null
    }
}

虚引用（Phantom Reference）

定义

虚引用是最弱的引用类型，不能通过虚引用访问对象。其主要作用是跟踪对象被垃圾回收的状态。

特点

虚引用必须与引用队列（ReferenceQueue）联合使用。
当 GC 准备回收一个对象时，如果发现它还有虚引用，会在回收后把这个虚引用加入到与之关联的引用队列中。
通过虚引用，程序可以在对象被收集器回收之前做一些清理工作。
可用场景：对象销毁前的一些操作，比如说资源释放等。 Object.finalize() 虽然也可以做这类动作，但是这个方式即不安全又低效

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class PhantomReferenceExample {
    public static void main(String[] args) {
        Object obj = new Object();
        ReferenceQueue<Object> refQueue = new ReferenceQueue<>();
        PhantomReference<Object> phantomRef = new PhantomReference<>(obj, refQueue);

        obj = null; // 原对象现在只被虚引用关联

        // 虚引用的 get 方法永远返回 null
        System.out.println(phantomRef.get()); // 始终为 null

        // 可以检查引用队列，以确定对象是否已经被回收
        System.out.println(refQueue.poll() == phantomRef); // 如果被回收，返回 true
    }
}

总结

引用类型	特点	GC 回收条件	常见用途
强引用	最常见的引用类型，不会被 GC 回收	内存不足也不会回收	常规对象引用
软引用	可有可无的对象，内存不足时会被 GC 回收	内存不足时回收	内存敏感的缓存
弱引用	非必要的对象，GC 一定会回收	下一次 GC 回收时	缓存、弱引用键的映射（如 `WeakHashMap`）
虚引用	无法通过虚引用访问对象，用于跟踪对象被 GC 回收的状态	对象被回收后	对象回收前的清理工作

这四种引用类型提供了不同的对象管理策略，允许开发者根据应用场景的需求来优化内存管理和垃圾回收。

8、HashCode的作用

hashCode() 是 Java 中 Object 类的一种方法，其主要作用是生成对象的哈希码。哈希码是一个整数值，通常用于高效地在数据结构中定位对象。hashCode() 方法在哈希表（如 HashMap、HashSet、Hashtable）中有着重要的作用。

hashCode() 的作用和用途

哈希表中的快速查找:
- 哈希表（如 HashMap、HashSet）利用哈希码来存储和查找对象。通过对象的 hashCode() 方法计算哈希码，然后根据哈希码决定对象在哈希表中的位置。
- 当需要查找、插入或删除一个对象时，哈希表首先使用 hashCode() 计算对象的哈希码，再在相应位置进行操作。这使得哈希表的操作通常能在常数时间内完成。
避免重复:
- hashCode() 配合 equals() 方法，用于判断两个对象是否相等。如果两个对象的 equals() 方法返回 true，它们的 hashCode() 值必须相等。
- 在哈希表中，如果两个对象的哈希码不同，那么它们肯定是不同的对象，无需再进行 equals() 比较。这减少了不必要的比较操作，提高了效率。

hashCode() 和 equals() 的关系

Java 中有以下两个重要的规则来确保哈希表的正确性：

相等的对象必须具有相同的哈希码:
- 如果两个对象根据 equals() 方法比较结果相等，那么它们的 hashCode() 值必须相等。否则，在哈希表中操作这些对象时可能会出现问题（如无法找到已经插入的对象）。
不相等的对象可以具有相同的哈希码，但尽量避免:
- 不相等的对象可以具有相同的哈希码，但这会导致哈希冲突，使得哈希表的效率下降。因此，实现 hashCode() 时应尽量减少哈希冲突。

总结

hashCode() 的主要作用是为对象生成一个哈希码，用于快速定位和操作对象，特别是在哈希表这样的数据结构中。为了确保哈希表的正确性和效率，hashCode() 与 equals() 方法之间必须遵循一定的规则。重写 hashCode() 方法时，应尽量减少哈希冲突，以提高数据结构的性能。

9、有没有可能两个不相等的对象有相同的hashcode

是的，在 Java 中，两个不相等的对象有可能具有相同的 hashCode() 值，这种情况称为哈希冲突（Hash Collision）。

为什么会有哈希冲突？

有限的哈希空间：hashCode() 返回一个 int 类型的整数，这意味着只有 2^32 个可能的哈希值。但对象的数量可能远远大于这个数量，因此不同的对象有可能映射到相同的哈希值。
哈希算法的局限性：即使是最好的哈希算法，在映射大量不同对象到有限的哈希值空间时，也无法完全避免冲突。

处理哈希冲突的方法

在哈希表（如 HashMap）中，处理哈希冲突的常用方法有以下几种：

拉链法（Separate Chaining）：
- 在发生哈希冲突时，将具有相同哈希码的对象存储在一个链表或其他数据结构（如 LinkedList）中。哈希表中的每个桶（bucket）实际存储的是一个链表，当冲突发生时，新对象会添加到链表中。
- 当查找某个对象时，先计算哈希码定位到桶，然后在桶中的链表中逐一查找对象。
```
HashMap<Integer, String> map = new HashMap<>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
// 假设 1 和 3 的 hashCode 相同，它们会存储在同一个链表中
```
开放地址法（Open Addressing）：

通过探测空闲位置来解决冲突，例如线性探测、二次探测或双重哈希。每当发生冲突时，会按照某种规则寻找下一个空闲的桶。
一旦发生了冲突,就去寻找下一个空的散列地址,只要散列表足够大,空的散列地址总能找到,并将记录存入

再哈希（Rehashing）：
- 当哈希表中的冲突变得频繁时，可以增大哈希表的容量，并重新计算所有对象的哈希值，将它们重新分布在更大的哈希空间中。

哈希冲突的影响

哈希冲突会影响哈希表的性能，特别是在发生大量冲突时，查找、插入、删除等操作的时间复杂度可能会从理想情况下的 O(1) 退化到 O(n)。不过，现代哈希表实现通常能够通过优化（如减少初始容量、合理的哈希函数设计等）来减轻冲突的影响。

总结

哈希冲突是可能的，即使两个对象不同，它们的 hashCode() 也可能相同。为了应对这种情况，哈希表使用多种策略来处理冲突，确保数据结构仍然能有效运作。在编写代码时，理解和妥善处理哈希冲突可以帮助你设计出更健壮和高效的程序。

10、深拷贝和浅拷贝的区别

深拷贝和浅拷贝是两种不同的对象复制方式，它们的主要区别在于对象中引用类型的数据如何被复制。

浅拷贝（Shallow Copy）

浅拷贝创建一个新对象，这个新对象是对原对象的一个“浅表”复制。在浅拷贝中：

基本数据类型的字段（如 int、char 等）会被复制，因此新对象的这些字段与原对象的字段值相同。
引用数据类型的字段（如对象、数组等）并不会被复制，而是直接引用原对象中的子对象。这意味着浅拷贝后的新对象和原对象的引用类型字段指向相同的内存地址。

特点

对于浅拷贝，新对象和原对象共享引用类型的字段（如对象、数组等），因此如果修改了这些字段，新旧对象都会受到影响。
浅拷贝通常通过实现 Cloneable 接口并调用 Object.clone() 方法实现。

示例

class Person implements Cloneable {
    String name;
    int age;
    Address address;  // 引用类型字段

    public Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();  // 浅拷贝
    }

    @Override
    public String toString() {
        return name + ", " + age + ", " + address.street;
    }
}

class Address {
    String street;

    public Address(String street) {
        this.street = street;
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("123 Main St");
        Person p1 = new Person("John", 30, address);
        Person p2 = (Person) p1.clone();

        System.out.println(p1);  // John, 30, 123 Main St
        System.out.println(p2);  // John, 30, 123 Main St

        p2.address.street = "456 Elm St";
        System.out.println(p1);  // John, 30, 456 Elm St
        System.out.println(p2);  // John, 30, 456 Elm St
    }
}

在上面的示例中，p2 是 p1 的浅拷贝，但由于 address 是引用类型字段，p2 和 p1 共享同一个 Address 对象，所以修改 p2.address 会影响 p1.address。

深拷贝（Deep Copy）

深拷贝创建一个新对象，同时复制原对象及其引用的所有对象，即使是嵌套的对象也会被复制。深拷贝中的每一个对象（无论是基本类型还是引用类型）都会被独立复制到新\的内存区域。

特点

深拷贝生成的新对象完全独立于原对象，任何对新对象的修改都不会影响原对象，反之亦然。
深拷贝通常通过递归地拷贝对象中的所有引用类型字段来实现。这可能需要手动编写代码来实现，也可以通过序列化和反序列化的方式来实现。

示例

class Person implements Cloneable {
    String name;
    int age;
    Address address;

    public Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        // 深拷贝：不仅拷贝Person，还要拷贝Address
        Person cloned = (Person) super.clone();
        cloned.address = (Address) address.clone();
        return cloned;
    }

    @Override
    public String toString() {
        return name + ", " + age + ", " + address.street;
    }
}

class Address implements Cloneable {
    String street;

    public Address(String street) {
        this.street = street;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("123 Main St");
        Person p1 = new Person("John", 30, address);
        Person p2 = (Person) p1.clone();

        System.out.println(p1);  // John, 30, 123 Main St
        System.out.println(p2);  // John, 30, 123 Main St

        p2.address.street = "456 Elm St";
        System.out.println(p1);  // John, 30, 123 Main St
        System.out.println(p2);  // John, 30, 456 Elm St
    }
}

在这个示例中，p2 是 p1 的深拷贝，Address 对象也被单独复制了，所以修改 p2.address 不会影响 p1.address。

总结

特性	浅拷贝	深拷贝
拷贝对象	复制对象的基本数据类型字段和引用类型的引用	复制对象的基本数据类型字段和引用类型对象本身
是否独立	引用类型字段共享同一个对象，存在关联	完全独立，所有字段（包括引用类型）都是新的对象
实现复杂度	实现相对简单，直接调用 `super.clone()` 通常足够	实现复杂，需要递归复制每个引用类型字段或使用序列化
适用场景	当对象较简单，或对象中的引用类型不需要独立时	当对象较复杂，或所有字段需要完全独立时

深拷贝和浅拷贝各有适用场景，开发者应根据具体需求选择合适的拷贝方式。如果对象包含复杂的数据结构或需要完全独立的副本，通常需要使用深拷贝。

11、static都有哪些用法

在Java中，static关键字有几种主要用法，具体如下：

静态变量：
- 使用static声明的变量属于类，而不是类的实例。所有实例共享同一个静态变量。
- 例子：
```
class Example {
    static int staticVar = 0; // 静态变量
}
```
静态方法：
- 静态方法可以在没有创建类实例的情况下被调用。它只能访问静态变量和调用其他静态方法。
- 例子：
```
class Example {
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}
```
静态代码块：
- 静态代码块在类加载时执行，用于初始化静态变量。它在类被加载时运行一次。
- 例子：
```
class Example {
    static {
        System.out.println("Static block executed.");
    }
}
```

静态内部类：

静态内部类是一个被声明为static的内部类。它可以访问外部类的静态成员，但不能直接访问外部类的实例成员。

例子：

class Outer {
    static class Inner {
        void display() {
            System.out.println("Inside static inner class.");
        }
    }
}

静态导入：

可以使用static import来导入静态成员，使其在类中可以直接使用而不需要类名。

例子：

import static java.lang.Math.*;

class Example {
    void calculate() {
        double result = sqrt(16); // 可以直接使用sqrt
    }
}

使用static的主要目的是提高内存效率和访问速度，但要注意它的生命周期是与类的生命周期相同的，这可能会导致一些特殊的内存管理和线程安全问题。

12、介绍下Object中的常用方法

在Java中，Object类是所有类的父类，提供了一些重要的基础方法。以下是Object类中的常用方法及其简要介绍：

toString()：
- 返回对象的字符串表示。默认实现返回对象的类名和哈希码，但通常可以在子类中重写此方法以提供更有意义的输出。
- 例子：
```
@Override
public String toString() {
    return "MyClass{name='" + name + "'}";
}
```

equals(Object obj)：

用于比较两个对象是否相等。默认实现比较对象的内存地址，可以在子类中重写以进行内容比较。

例子：

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (!(obj instanceof MyClass)) return false;
    MyClass other = (MyClass) obj;
    return this.id == other.id;
}

hashCode()：
- 返回对象的哈希码。它与equals方法一起使用，确保相等的对象具有相同的哈希码。通常在重写equals时也需要重写hashCode。
- 例子：
```
@Override
public int hashCode() {
    return Objects.hash(id);
}
```
getClass()：

返回运行时对象的类对象，提供有关对象的类型信息。

clone()：
- 创建并返回对象的一个副本。要使用此方法，类必须实现Cloneable接口，并重写clone方法。
- 例子：
```
@Override
protected Object clone() throws CloneNotSupportedException {
    return super.clone();
}
```
notify() 和 notifyAll()：

用于唤醒在该对象监视器上等待的单个或所有线程，通常与线程同步相关。

wait()：

使当前线程等待，直到其他线程调用此对象的notify或notifyAll方法，通常用于线程间通信。

finalize()：
- 在垃圾收集器确定不存在对对象的更多引用时调用，允许对象在被回收之前执行清理操作。自Java 9起不推荐使用。

这些方法为Java中的对象操作提供了基础，允许开发者实现自定义的对象行为和比较逻辑。

13、Java 创建对象有几种方式？

在 Java 中，创建对象有几种常见的方式，主要包括以下几种：

使用 new 关键字：
这是最常见的方式，直接通过类的构造函数创建一个新对象。
```
ClassName obj = new ClassName();
```

使用反射（Reflection）：
通过 Class 对象的 newInstance() 方法（已被弃用）或者使用 Constructor 类的 newInstance() 方法。

ClassName obj = ClassName.class.newInstance();  // 过时方法

Constructor<ClassName> constructor = ClassName.class.getConstructor();
ClassName obj = constructor.newInstance();

使用 clone() 方法：
如果类实现了 Cloneable 接口并重写了 clone() 方法，可以通过调用对象的 clone() 方法来创建对象的副本。
```
ClassName obj1 = new ClassName();
ClassName obj2 = obj1.clone();
```

通过序列化和反序列化：
通过将对象序列化为字节流，然后再将其反序列化，可以创建一个新的对象。

ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("file.txt"));
out.writeObject(obj1);

ObjectInputStream in = new ObjectInputStream(new FileInputStream("file.txt"));
ClassName obj2 = (ClassName) in.readObject();

使用工厂方法或其他设计模式：
使用设计模式如工厂方法、单例模式等，间接地创建对象。例如：
```
ClassName obj = FactoryClass.createObject();
```

使用 ClassLoader 加载类：
通过自定义的类加载器加载类并实例化对象。

ClassLoader classLoader = MyClassLoader();
Class<?> clazz = classLoader.loadClass("ClassName");
ClassName obj = (ClassName) clazz.newInstance();

这些方法涵盖了 Java 中创建对象的各种方式，不同的场景适用于不同的方法。

14、有了数组为什么还要再搞一个ArrayList呢？

虽然数组在 Java 中是非常基础的数据结构，但它们有一些局限性，而 ArrayList 通过提供更多的功能和灵活性，弥补了这些局限性。以下是 ArrayList 相对于数组的一些主要优势：

动态大小
- 数组：大小是固定的。一旦创建，不能再更改它的长度。如果需要存储更多的元素，就必须创建一个更大的数组并手动将数据复制过去。
- ArrayList：可以动态调整大小。当需要添加元素时，它会自动扩展自身的容量。这使得管理集合的大小更加方便。
便捷的元素操作
- 数组：在数组中，插入或删除元素相对繁琐，需要手动调整其他元素的位置。
- ArrayList：提供了内置的方法，如 add()、remove() 和 clear()，这些方法可以方便地在列表中插入、删除和清空元素。此外，还提供了 contains() 等方法，可以直接检查某个元素是否存在。
灵活性
- 数组：数组只能存储一种类型的数据。如果想存储多种类型的数据，需要使用 Object 数组，这会增加类型转换的风险。
- ArrayList：通过泛型可以存储任何类型的对象，提供了更高的灵活性和类型安全性。
方便的遍历
- 数组：可以使用传统的 for 循环来遍历，但如果使用增强的 for 循环，代码的可读性和简洁性会稍差。
- ArrayList：支持增强的 for 循环以及使用迭代器 (Iterator) 进行遍历，这在某些场景下更为方便。
内置方法
- 数组：只提供了基本的索引访问，没有提供任何内置的集合操作方法。
- ArrayList：提供了诸如 size()、isEmpty()、indexOf()、lastIndexOf() 等方法，使得集合操作更加简便。
类型安全
- 数组：如果是对象数组，在存入或取出元素时，可能需要进行类型转换，这带来了潜在的类型转换异常风险。
- ArrayList：通过泛型，ArrayList 提供了编译时的类型检查，减少了类型转换错误的可能性。

ArrayList 提供了更灵活、更易用的接口来处理动态数据集合，适合用于那些大小不确定或需要频繁增删元素的场景。而数组则更适合那些大小固定、对性能有较高要求的场景。

15、说说什么是 fail-fast？

fail-fast 是一种设计原则，尤其在并发编程或集合类中，它指的是当一个系统、操作或方法检测到一个错误时，它会立即报告错误（通常通过抛出异常），而不是继续运行可能产生更多错误或不可预测行为的代码。

在 Java 中的集合框架中的 fail-fast 行为

在 Java 的集合框架中（如 ArrayList, HashMap 等），fail-fast 机制是指，当使用迭代器遍历集合时，如果在迭代过程中检测到集合被其他线程或操作修改了，迭代器会立即抛出一个 ConcurrentModificationException。
- 示例：
```
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String value = iterator.next();
    list.remove("A"); // 修改集合
}
```
  在上述代码中，如果在迭代 list 的同时修改 list，就会触发 fail-fast 机制，抛出 ConcurrentModificationException。
工作原理
- 快速失败检测：
  fail-fast 迭代器通过检查集合的 modCount 字段来检测集合是否被修改。modCount 是一个记录集合结构性修改次数的计数器。当迭代器创建时，它会记录集合当前的 modCount 值。
- 一致性检查：
  每次调用迭代器的 next() 或 remove() 方法时，都会检查当前的 modCount 值是否与迭代器创建时的 modCount 相同。如果不同，则意味着集合在迭代过程中被修改过，于是抛出 ConcurrentModificationException。
用途和重要性
- 早期检测错误：fail-fast 机制可以在错误发生时尽早提醒开发者或程序，避免因问题未及时暴露而导致更多复杂的问题或更难调试的错误。
- 提高代码质量：通过快速失败，开发人员可以在开发和测试阶段更早发现并修复问题，从而提高代码的稳定性和可靠性。
注意事项
- 非线程安全：fail-fast 机制并不提供线程安全的保障。它只能检测出明显的并发修改问题，但并不能完全防止并发问题的发生。
- 避免修改集合：在遍历集合时，最好不要直接对集合进行修改，除非使用 Iterator 提供的 remove() 方法。或者可以考虑使用线程安全的集合（如 CopyOnWriteArrayList）或其他并发工具来避免 fail-fast 异常。

总结

fail-fast 是一种设计原则，它能够在程序运行过程中尽早地发现并报告问题，以防止更严重的错误发生。在 Java 中，fail-fast 机制广泛应用于集合框架中，用于快速检测并发修改问题。

16、介绍下你对Java集合的理解

Java 集合框架（Java Collections Framework, JCF）是 Java 提供的一组数据结构类和接口，用于存储和操作一组对象。集合框架为开发者提供了标准化的方式来处理数据集合，包括列表、集、队列、和映射等常用数据结构。这使得开发者能够以更高效和结构化的方式管理数据。

集合框架的核心接口

Java 集合框架包含多个核心接口，这些接口定义了集合的不同类型和操作。主要的接口包括：
- Collection 接口：
  - 是所有集合的根接口，定义了集合的基本操作，如添加、删除、遍历元素等。
  - 主要子接口有 List, Set, Queue。
- List 接口：
  - 表示有序的集合，允许重复元素。
  - 常见实现类：ArrayList, LinkedList, Vector。
  - 典型应用：保存需要按插入顺序访问的元素，如学生名单或购物车。
- Set 接口：
  - 表示不允许重复元素的集合，无序（没有特定顺序）。
  - 常见实现类：HashSet, LinkedHashSet, TreeSet。
  - 典型应用：保存独一无二的元素，如用户 ID 或数据库中的主键值。
- Queue 接口：
  - 表示先进先出的集合（FIFO），主要用于排队操作。
  - 常见实现类：LinkedList, PriorityQueue。
  - 典型应用：任务调度、消息队列。
- Map 接口：
  - 表示键值对的集合，允许通过键查找值。
  - 常见实现类：HashMap, LinkedHashMap, TreeMap, Hashtable。
  - 典型应用：存储键值对，如用户名和密码、配置项和它们的值。
集合框架的实现类

Java 集合框架提供了多个实现了上述接口的类，每个类有其特定的用途和性能特点：
- ArrayList：
  - 基于动态数组实现，提供快速的随机访问。
  - 适合频繁读取或添加操作，但插入和删除操作性能较差，尤其在中间位置。
- LinkedList：
  - 基于双向链表实现，适合频繁的插入和删除操作。
  - 随机访问性能较差，但可以用作双端队列（Deque）或栈（Stack）。
- HashSet：
  - 基于哈希表实现，不保证元素的顺序。
  - 适合查找、添加、删除操作，时间复杂度为 O(1)。
- TreeSet：
  - 基于红黑树实现，元素自动排序。
  - 适合需要排序集合的场景，查找、添加、删除的时间复杂度为 O(log n)。
- HashMap：
  - 基于哈希表实现，键值对无序存储。
  - 适合快速查找、插入、删除操作。
- TreeMap：
  - 基于红黑树实现，键值对按照键的自然顺序或指定的比较器排序。
  - 适合需要有序键值对存储的场景。
集合操作

Java 集合框架提供了丰富的操作方法：
- 添加元素：add(), put()
- 删除元素：remove(), removeIf()
- 查找元素：contains(), get()
- 遍历集合：iterator(), 增强的 for 循环
线程安全的集合
- 默认情况下，Java 集合类不是线程安全的。
- 通过 Collections.synchronizedList()、Collections.synchronizedMap() 等方法，可以将集合包装为线程安全版本。
- Java 还提供了并发集合类，如 ConcurrentHashMap、CopyOnWriteArrayList 等，适用于多线程环境。
迭代器
- 集合框架中的大多数集合都支持迭代器 (Iterator)，用于遍历集合元素。
- 迭代器提供 hasNext() 和 next() 方法来顺序访问集合中的元素。
- 对于列表类集合，还可以使用 ListIterator，它支持双向遍历和修改操作。
fail-fast 机制
- 当一个集合在迭代过程中被修改时，会抛出 ConcurrentModificationException，这是 Java 集合框架中的 fail-fast 机制的体现，用于早期检测并发修改问题。

Java 集合框架是一个功能强大且灵活的数据结构库，提供了丰富的接口和类来满足不同的数据处理需求。理解这些集合的特性、性能和使用场景，可以帮助开发者编写更高效和可靠的 Java 应用程序。

17、介绍下你对红黑树的理解

红黑树（Red-Black Tree）是一种自平衡的二叉搜索树，具有较好的平衡性，可以在最坏情况下依然保持高效的操作性能。红黑树广泛用于实现各种数据结构，如 Java 中的 TreeMap 和 TreeSet。下面是对红黑树的详细讲解。

红黑树的定义和特性

红黑树是一种带有颜色属性的二叉搜索树，它满足以下五个性质：

节点是红色或黑色的：每个节点都会被标记为红色或黑色，这是红黑树名称的由来。
根节点是黑色的：红黑树的根节点必须是黑色的，这是为了确保树的整体平衡性。
所有叶子节点（NIL节点）都是黑色的：在红黑树中，所有的叶子节点（通常用 null 表示）都视为黑色节点。
红色节点的子节点必须是黑色的：红色节点的子节点（即父节点和子节点不能连续出现两个红色节点），这保证了从根到叶子的最长路径不会超过最短路径的两倍，确保树的平衡。
从任一节点到其每个叶子节点的所有路径包含相同数目的黑色节点：这称为黑色高度（black-height），它保证了红黑树的平衡性。
红黑树的操作

红黑树的基本操作包括插入、删除和查找，且这些操作都在 O(log n) 时间内完成。为了维护红黑树的平衡性，插入和删除操作之后，可能需要通过旋转和重新着色来调整树的结构。

插入操作

插入节点的基本步骤如下：

标准的二叉搜索树插入：首先按照二叉搜索树的规则将新节点插入到适当的位置。
着色：新插入的节点被着色为红色。
调整树：如果插入后违反了红黑树的性质（如出现了两个连续的红色节点），需要通过旋转和重新着色来修复。
- 旋转：通过左旋和右旋操作调整树的结构。
- 重新着色：通过改变节点的颜色来恢复红黑树的平衡。

删除操作

删除节点的基本步骤如下：

标准的二叉搜索树删除：首先按照二叉搜索树的规则删除目标节点。
处理双黑：如果删除的是黑色节点，可能会导致红黑树性质被破坏，这时会出现双黑（Double Black）情况，需要调整树。
- 修复双黑：通过旋转和重新着色来消除双黑并恢复红黑树的平衡。
红黑树的旋转

旋转是红黑树中用来维护平衡的重要操作，主要有以下两种：

左旋（Left Rotation）：将节点的右子树提升为父节点，原父节点降为左子树。
右旋（Right Rotation）：将节点的左子树提升为父节点，原父节点降为右子树。

通过旋转操作，可以改变节点的相对位置，从而帮助恢复红黑树的平衡。

红黑树的优点

平衡性：虽然红黑树不是完全平衡的，但它的路径长度不会超过最短路径的两倍，因此仍能保证良好的性能。
高效的插入、删除和查找操作：由于其平衡性，红黑树的插入、删除和查找操作都能在 O(log n) 时间内完成。
广泛应用：红黑树被用于许多实际的数据结构实现中，如 Java 的 TreeMap 和 TreeSet，C++ 的 map 和 set，以及 Linux 内核中的调度器等。

红黑树与其他平衡二叉树的比较

红黑树 vs AVL树：AVL树是一种更严格的平衡二叉树，具有更快的查找性能（因为它更平衡），但插入和删除操作可能更慢，因为需要更多的旋转操作。而红黑树则在插入和删除操作上更高效，因此在许多实际应用中更为常见。

总结

红黑树是一种高效的、自平衡的二叉搜索树，适用于需要频繁插入、删除和查找操作的数据结构。它通过颜色标记和旋转操作来维持树的平衡性，确保了在最坏情况下依然可以提供 O(log n) 的操作性能。由于其平衡性和高效性，红黑树在实际应用中非常广泛。

18、try-finally中的return关键字

在 Java 中，try-finally 语句块用于确保无论是否发生异常，finally 块中的代码都会执行。return 关键字在 try-finally 中的使用有一些细节值得注意，因为它可能会影响程序的执行流程。

基本结构

try {
    // 可能抛出异常的代码
} finally {
    // 总是执行的清理代码
}

在 try 块中使用 return 关键字

当 try 块中有 return 语句时，Java 会在执行 return 之前，首先执行 finally 块中的代码。即使在 try 块中执行了 return，finally 块仍然会被执行。

示例：

public int exampleMethod() {
    try {
        return 1;
    } finally {
        System.out.println("Finally block executed");
    }
}

在这个例子中，当调用 exampleMethod() 时，控制流会先进入 try 块并准备返回 1。但是，在实际返回之前，finally 块中的代码（即打印 “Finally block executed”）会被执行。最终，该方法会返回 1。

在 finally 块中使用 return 关键字

如果 finally 块中也包含 return 语句，那么 finally 块中的 return 会覆盖 try 块中的 return。这意味着 finally 块的 return 值将成为方法的返回值，try 块中的 return 值会被忽略。

示例：

public int exampleMethod() {
    try {
        return 1;
    } finally {
        return 2;
    }
}

在这个例子中，尽管 try 块中准备返回 1，但 finally 块中的 return 2 会覆盖它，最终 exampleMethod() 将返回 2。

总结

finally 块中的代码总会执行，即使 try 块中有 return 语句。
如果 finally 块中有 return 语句，它会覆盖 try 块中的 return 语句。
通常建议避免在 finally 块中使用 return，因为它会使代码更难理解和调试。

最佳实践：
在开发中，尽量避免在 finally 中使用 return 语句，这样可以避免意外的行为。finally 块通常应该用于释放资源、关闭流、解除锁定等操作，而不是修改控制流。

return语句的本质：

return语句获取到变量的地址
return将获取的地址返回，也就是return本质是传地址

19、异常处理影响性能吗

是的，Java 的异常处理机制会对性能产生一定的影响，但这种影响通常是在异常实际抛出和捕获时才显著。了解异常处理对性能的影响有助于在开发中做出更好的设计决策。

异常的创建
- 当抛出异常时，Java 需要创建一个新的异常对象，这涉及到调用异常类的构造函数。
- 构造函数中会捕获当前的调用堆栈信息（stack trace），这些操作是比较耗费资源的，尤其是堆栈越深，消耗越大。
异常的抛出和捕获
- 当一个异常被抛出时，Java 虚拟机（JVM）需要执行非本地跳转来寻找相应的 catch 块，这涉及到遍历方法调用栈，寻找最近的异常处理器。这一过程比正常的顺序执行要耗时。
- 如果异常被捕获，处理异常的代码块（catch 块）会执行。捕获和处理异常相较于正常代码执行要慢，因为它打破了程序的正常控制流。
正常情况下 try-catch 对性能的影响
- Minimal impact: 在没有抛出异常的情况下，仅仅是 try-catch 语句本身不会带来显著的性能影响。JVM 对 try-catch 块的管理是非常高效的，当没有异常抛出时，代码执行不会受到明显影响。
- 在性能敏感的代码中（如内层循环中），避免使用异常处理机制进行控制流管理，因为即使 try-catch 本身开销小，但频繁抛出和处理异常会显著影响性能。
异常的滥用会影响性能
- 控制流管理：有时开发者可能会使用异常来控制程序的正常流程，例如用异常来终止循环或分支。这种用法在设计上是不推荐的，因为它会带来不必要的性能开销。
- 频繁抛出异常：在高频操作中（如循环或递归调用中）频繁抛出和捕获异常，会导致性能显著下降。因为每次抛出异常都会涉及堆栈信息捕获和上下文切换，这在大量数据或高频调用场景下代价很高。
如何优化异常处理的性能
- 避免使用异常进行正常控制流管理：异常应仅用于处理错误或意外情况，而不是控制正常的程序流程。
- 在性能关键代码中尽量减少异常的抛出：可以通过在抛出异常前进行前置条件检查（如用 if 判断）来避免不必要的异常抛出。
- 理解异常的成本：在设计系统时，要考虑异常处理的开销，特别是在需要高性能的场景中。选择合适的数据验证和错误处理策略，尽量减少异常的产生。

Java 异常处理机制在异常实际发生时会对性能产生一定的影响，主要是由于异常对象的创建、堆栈追踪的生成以及控制流的跳转。然而，在没有异常抛出的情况下，try-catch 语句对性能的影响是非常小的。关键在于避免滥用异常作为控制流工具，并在性能关键的代码中采取适当的优化措施。

20、介绍下try-with-resource语法

try-with-resources 是 Java 7 引入的一种用于简化资源管理的语法糖，专门设计用于在使用完资源后自动关闭它们。它使得资源管理更安全、更简洁，避免了因资源未关闭而导致的资源泄漏问题。

基本概念

资源：指的是那些在程序运行后需要手动关闭的对象，如文件流（FileInputStream、FileOutputStream）、数据库连接、网络套接字等。这些对象通常实现了 AutoCloseable 接口或更早的 Closeable 接口。
AutoCloseable 接口：所有能够在 try-with-resources 语句中使用的资源类都必须实现 AutoCloseable 接口，该接口定义了 close() 方法，用于释放资源。

基本语法

try (ResourceType resource = new ResourceType()) {
    // 使用资源的代码块
} catch (ExceptionType e) {
    // 异常处理代码
} finally {
    // 可选的最终操作
}

ResourceType：表示要管理的资源类型，必须实现 AutoCloseable 接口。
资源声明：在 try 语句后的小括号中声明和初始化资源。可以声明多个资源，资源之间用分号分隔。

工作原理

当 try 代码块执行完毕后（无论是正常执行完毕还是因异常提前退出），Java 会自动调用在 try-with-resources 语句中声明的每个资源的 close() 方法。
如果 try 代码块中抛出了异常，Java 会首先捕获该异常，然后调用资源的 close() 方法，接着再处理该异常。

示例代码

以下是一个使用 try-with-resources 的简单示例，用于读取文件内容：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，BufferedReader 和 FileReader 是资源，它们都实现了 AutoCloseable 接口。
当 try 代码块执行完毕后，BufferedReader 和 FileReader 会被自动关闭，避免了手动关闭资源的麻烦。

多个资源的管理

如果在 try-with-resources 语句中声明多个资源，Java 会按照声明的顺序依次初始化它们，而在关闭时则按照相反的顺序进行关闭。

示例：

try (BufferedReader br = new BufferedReader(new FileReader("test.txt"));
     BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    // 使用资源的代码块
} catch (IOException e) {
    e.printStackTrace();
}

在这个例子中，BufferedWriter 会在 BufferedReader 之后关闭。

与传统 try-finally 的对比

简洁性：try-with-resources 语法更简洁，不需要显式地在 finally 块中关闭资源。
安全性：它确保了即使在资源初始化失败或者 try 块中发生异常时，资源也能被正确关闭，减少了资源泄漏的风险。

异常处理

如果在 try 块中抛出异常，同时在关闭资源时也抛出异常，那么 try 块中的异常会被抛出，而关闭资源时的异常会被作为“抑制异常”附加到原始异常上，可以通过 Throwable.getSuppressed() 方法获取。

try-with-resources 语法极大地简化了资源管理，使代码更加简洁和可靠。它自动处理资源的关闭问题，减少了资源泄漏的风险，并确保即使在异常情况下资源也能被正确关闭。对于任何实现了 AutoCloseable 接口的资源类，都应优先使用 try-with-resources 进行管理。

palomua

关注

13
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
1.1 Java基础面试题总结

Java 中有八种基本数据类型，分为四类：整数类型、浮点类型、字符类型和布尔类型。整数类型byte大小：8 位范围：-128 到 127用途：主要用于节省内存，在大型数组中使用时效果显著。short大小：16 位范围：-32,768 到 32,767用途：与byte类似，用于节省内存。int大小：32 位范围：-2^31 到 2^31-1 (约 -21亿到 21亿)用途：默认的整数类型，适用于一般的整数运算。long大小：64 位。
复制链接

扫一扫