【 java 基础问题第一篇】

1.概念

1.1.java的特定有哪些？

1.2.java有哪些优势哪些劣势？

1.3.java为什么可以跨平台？

1.4JVM,JDK,JRE它们有什么区别？

1.5.编译型语言与解释型语言的区别？

2.数据类型

2.1.long与int类型可以互转吗？

2.2.数据类型转变形式有哪些？

2.3.类型转换会出现哪些问题？

2.4.为什么用bigDecimal 不用double？

2.5.装箱与拆箱会出现什么问题？

2.6.Integer为什么会存在一个缓存池？

3.面向对象

3.1.怎么理解面向对象？

3.2.说一下封装继承多态？

3.3.多态体现在哪几个方面？

3.4.重写与重载的区别？

3.5.抽象类与普通类的区别？

3.6.抽象类与接口的区别？

3.7.抽象类可以加final关键字吗？

3.8.解释一下静态变量与静态方法？

3.9.为什么静态不能调用非静态？

3.10.为什么非静态内部类可以访问外部类？

4.关键字

4.1.final

1.概念

1.1.java的特定有哪些？

平台无关性："一次编译终身运行"，就是说java编译器会将源代码先编译成字节码（不同机器上只要源代码相同，那么就字节码一定相同），然后JVM会将字节码翻译成对应的机器码（JVM有不同系统的版本，JVM会根据你的环境进行翻译），总的来说就是字节码保证编译一致，然后根据不同的JVM翻译对应机器码
面向对象：java是一个面向对象的语言，更方便代码的维护和使用
内存管理：java拥有垃圾回收机制，开发人员不需要自己手动删除内存（不需要考虑这么多），由垃圾回收机制来自动实现内存释放

1.2.java有哪些优势哪些劣势？

优势：（特定那里）

跨平台：java有平台无关性
内存管理：拥有垃圾回收机制
面向对象：使代码更好维护和使用
强大的生态系统：如Spring全家桶，其他的工具包等等
稳定性：支持企业长期使用，版本向后兼容

劣势：

内存消耗大：JVM虚拟机本身就需要一定的内存
启动时间长：由于需要JVM将字节码翻译成机器码
代码复杂：由于java过于面向对象，一个简单的程序的代码复杂（麻烦）

1.3.java为什么可以跨平台？

java在编译时，java编译器会直接将源代码编写成字节码文件，等到你需要运行时，会根据你的JVM虚拟机版本不同，然后通过不同的JVM将字节码翻译成机器码（让机器识别）

1.4JVM,JDK,JRE它们有什么区别？

JVM：JVM是java虚拟机，是java程序运行的环境

JDK：JDK是java的一个开发工具包（各种类，工具）

JRE：JRE是java运行的环境，是java程序所需的最小环境

1.5.编译型语言与解释型语言的区别？

编译型：在运行之前需要编译，将源代码编写成字节码或者机器码（C++），如果它编写成机器码，在本机上可以直接识别机器码，从而它的运行速度快，跨平台性差

解释性：不需要编译，它会在运行时逐行解释代码，因运行速度慢，跨平台性好

2.数据类型

2.1.long与int类型可以互转吗？

可以：但是你需要考虑数据的溢出与丢失

比如：你将long类型转成int类型，如果你的long类型的数很大，大到int无法全部接收，那么就会出现数据的丢失

比如：你将int类型转成long类型，如果你的int类型的数很小，那么用long接收，由于long精度大，其他位将用0填充，出现数据溢出

public class TypeConversion {
    public static void main(String[] args) {
        long bigLong = 2147483648L; // 超出 int 最大值（2147483647）
        int intValue = (int) bigLong; // 强制转换
        
        System.out.println("原始 long 值: " + bigLong);  // 输出 2147483648
        System.out.println("转换后的 int 值: " + intValue); // 输出 -2147483648（溢出）
    }
}

2.2.数据类型转变形式有哪些？

自动类型转换（隐式转换）：假如：你使用long类型与int类型进行相加，它会默认将int类型隐式转换成long，再进行运算

public class AutoConversion {
    public static void main(String[] args) {
        int a = 10;
        long b = 20L;
        long result = a + b;  // int 自动提升为 long
        
        System.out.println(result);  // 输出 30
    }
}

强制类型转换（显示转换）：假如：你使用long类型与int类型进行相加，那么最后的结果只能用long类型接收，如果你想要使用int类型接收，那么需要强制类型转换

public class ForceConversion {
    public static void main(String[] args) {
        long a = 2147483648L;  // 超过 int 最大值（2147483647）
        int b = (int) a;       // 强制转换
        
        System.out.println(b);  // 输出 -2147483648（高位截断）
    }
}

字符串转换：使用包装类里面的方法进行转换，比如：你将char类型转换成int，那么它会根据ASCII码对应表转成对应数

public class StringConversion {
    public static void main(String[] args) {
        // 1. 字符串 → 数值类型（需处理异常）
        String str = "123";
        int num = Integer.parseInt(str);  // 字符串转 int
        double d = Double.parseDouble(str);  // 字符串转 double
        
        // 2. 数值类型 → 字符串
        String s1 = Integer.toString(num);  // 方法1
        String s2 = String.valueOf(d);      // 方法2
        String s3 = "" + num;              // 方法3（隐式转换）

        // 3. char → int（ASCII 码转换）
        char c = 'A';
        int ascii = c;  // 直接赋值，输出 65
        int numericValue = Character.getNumericValue('9');  // 输出 9
    }
}

2.3.类型转换会出现哪些问题？

数据丢失：小类型转大类型（精度不同，造成数据丢失）

数据溢出：大类型转小类型（高位全用0填充）

精度不同：float是单精度，double是双精度，两者转换精度会出现丢失

类型不同：不同类型的转换会出现编译错误

2.4.为什么用bigDecimal 不用double？

举例：你能使用十进制表示1/3吗？无法表示，一直在循环，而double是进行二进制运算的，比如：0.1你能使用二进制进行表示吗？也是一直循环，而double是有精度的，到达它的精度限度后，它不会在循环下去，因此会出现精度丢失问题

解决：使用bigDecimal（注意：如果你还是使用浮点数赋值给它，还是会出现该问题（默认浮点数就是double类型），因此使用字符串赋值）

System.out.println(0.1 + 0.2); // 输出 0.30000000000000004（精度丢失）

import java.math.BigDecimal;

public class BadExample {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal(0.1); // 用 double 初始化（错误！）
        BigDecimal b = new BigDecimal(0.2);
        BigDecimal result = a.add(b);
        
        System.out.println(result); // 输出 0.3000000000000000166533453694...
    }
}

import java.math.BigDecimal;

public class GoodExample {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("0.1"); // 用字符串初始化（正确！）
        BigDecimal b = new BigDecimal("0.2");
        BigDecimal result = a.add(b);
        
        System.out.println(result); // 输出 0.3
    }
}

2.5.装箱与拆箱会出现什么问题？

装箱：就是将基本类型包装成包装类

拆箱：就是将包装类拆成基本类型

问题：由于java可以实现自动装箱与拆箱，如果你定义一个Integer类型，但是没有给它赋值，它会默认null，然后将它拆箱，但是null值是无法拆箱的，因此会出现空指针异常

2.6.Integer为什么会存在一个缓存池？

由于我们需要使用对应的包装类，但是每次都需要重新创建对象（消耗内存），并且进行一个运算就会创建一个对象（无关内存），因此为了节省内存，java将我们常使用的-128到127的对象已经创建好了，放在静态缓存池中，你使用.valueInt()这个方法进行赋值，它就会去复用池中对象（地址相同）

Integer a = Integer.valueOf(100);  // 从缓存池获取（地址相同）
Integer b = 100;                   // 隐式调用 valueOf()，复用缓存
Integer c = new Integer(100);      // 强制创建新对象（地址不同）

System.out.println(a == b);  // true（同一对象）
System.out.println(a == c);  // false（不同对象）

3.面向对象

3.1.怎么理解面向对象？

面向对象就是将现实生活中的各个事务抽象成对象

3.2.说一下封装继承多态？

封装：就是将共性的属性与方法封装到类中，隐藏类中的细节，仅暴露出你想要暴露的接口来与外界交互，增加了代码的安全性和扩展性

继承：子类共享父类的属性与方法，是代码实现复用，建立了类与类之间的联系，是类之间的结构更加清晰

多态：不同类对应不同消息的不同操作方式，是代码更加灵活

3.3.多态体现在哪几个方面？

方法重载：同一个类可以有多个方法名相同的方法（参数不同）

方法重写：子类重写父类的方法

接口实现：不同的类实现同一个接口，那么创建对象时，可以使用接口创建，调用方式一致

向上与向下转型：向上：父类转子类向下：子类转父类

3.4.重写与重载的区别？

重写：子类重写父类方法，需要与父类方法名，返回类型，参数保持一致，只能修改其内部的代码

重载：在同一个类中你可以重载多个方法名相同的方法，但是区别在于参数不同（1.参数类型不同，2.参数数量不同，3.参数顺序不同），满足一个即可

3.5.抽象类与普通类的区别？

实例化：抽象类不可以实例化，普通类可以

-----

方法实现：抽象类方法可以实现可以只定义，而普通类需要具体的方法实现

3.6.抽象类与接口的区别？

实现方式：抽象类需要继承extends，接口需要实现implements

-----

访问修饰符不同：两者的属性与方法默认修饰符不同

-----

方法实现不同：抽象类方法可以定义可以实现，接口只能定义

-----

变量：抽象类可以有实例变量和静态变量，而接口只有静态变量

-----

特点：接口是定义类的功能或行为，抽象类是描述类的共性和行为的

3.7.抽象类可以加final关键字吗？

不可以，抽象类本身就是一个基类就是让其他类继承的，而类加上final会让该类无法被继承

因此两者互斥

3.8.解释一下静态变量与静态方法？

静态的东西只有当类加载完后，它就会加载，只会在内存中加载一次

3.9.为什么静态不能调用非静态？

静态只有当类加载完就会加载，因此静态会优先于非静态加载（需要实例化），你一个没加载的怎么能被调用呢？

比如：静态方法里面调用非静态方法，我静态方法都已经加载完了，而你非静态方法必须要实例化才能加载，没有实例化不加载，那么我怎么调用你呢？（不能确定非静态是否加载）

比如：反过来，就可以解释为什么非静态可以调用静态，因为非静态加载慢，它加载完就一定有静态加载完，因此可以调用

public class Example {
    static int staticVar = 10;  // 类加载时初始化
    int instanceVar = 20;      // 对象实例化时初始化
}

public class Example {
    static void staticMethod() {
        instanceMethod();  // 编译错误：无法调用非静态方法
        System.out.println(instanceVar);  // 编译错误：无法访问非静态变量
    }

    void instanceMethod() {
        System.out.println("非静态方法");
    }
}

public class Example {
    static int staticVar = 10;

    void instanceMethod() {
        System.out.println(staticVar);  // 合法：静态成员已加载
        staticMethod();                // 合法：静态方法已加载
    }

    static void staticMethod() {
        System.out.println("静态方法");
    }
}

3.10.为什么非静态内部类可以访问外部类？

就是当外部类实例化后，会将外部类的实例化地址（引用）当作参数传给非静态内部类，因此它可以根据引用来访问

4.关键字

4.1.final

修饰类	代表类不能被继承
修饰方法	代表方法不能被重写
修饰变量	如果是基本类型，值不能被修改，是引用类型，值可以被修改，地址不能修改