目录
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
| 修饰类 | 代表类不能被继承 |
| 修饰方法 | 代表方法不能被重写 |
| 修饰变量 | 如果是基本类型，值不能被修改，是引用类型，值可以被修改，地址不能修改 |