【 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);  // 输出 2147483648System.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 自动提升为 longSystem.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);  // 字符串转 intdouble d = Double.parseDouble(str);  // 字符串转 double// 2. 数值类型 → 字符串String s1 = Integer.toString(num);  // 方法1String s2 = String.valueOf(d);      // 方法2String s3 = "" + num;              // 方法3（隐式转换）// 3. char → int（ASCII 码转换）char c = 'A';int ascii = c;  // 直接赋值，输出 65int 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

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