java专项八股知识点（1）
目录[*]外部类&内部类
[*]String、StringBuilder和StringBuffer的区别
[*]super和this关键字
[*]
在 Java 中，类可以分为外部类和内部类。
[*]外部类是最常见的类，定义在 .java 文件的顶层。它可以用修饰符如 public、default、abstract、final 修饰，但不能使用 static 修饰。一个源文件中最多只能有一个 public 外部类，且文件名必须与该类名一致。外部类适合承载完整的业务逻辑，如服务类、控制器类、实体类等。
[*]内部类是定义在另一个类内部的类，主要有三种类型：成员内部类、静态内部类和匿名内部类。其中，只有静态内部类可以使用 static 修饰。成员内部类和匿名内部类都可以访问外部类的属性和方法，即使这些成员是私有的。静态内部类无法访问外部类的非静态成员。
从编译结果来看，外部类会被编译为 Outer.class，而内部类会被编译为 Outer$Inner.class 的字节码文件。
在实际开发中，内部类常用于构建辅助结构，增强封装性。例如：
[*]使用静态内部类实现 Builder 模式；
[*]使用匿名内部类实现按钮点击事件或线程回调；
[*]使用成员内部类管理与外部类高度耦合的数据结构。
（1）成员内部类（非静态）
成员内部类定义在类的内部，但不是静态的，因此它可以访问外部类的所有成员，包括私有变量。通常用于表达**“整体-部分”关系**，比如学校和学生、公司和员工。
应用场景：
[*]一个类的数据对象高度依赖外部类的上下文（如组织内的成员、设备内的部件）
public class School {
private String name = "大学";
// 成员内部类
public class Student {
private String studentName;
public Student(String studentName) {
this.studentName = studentName;
}
public void introduce() {
// 可以访问外部类成员
System.out.println("我是 " + studentName + "，来自 " + name);
}
}
public static void main(String[] args) {
School school = new School();
Student stu = school.new Student("小明");
stu.introduce();
}
} （2）静态内部类
静态内部类是用 static 修饰的内部类。它不能访问外部类的非静态成员，更像一个逻辑上嵌套的独立类，常用于Builder 模式、工具类组装等场景。
public class User {
private String name;
private int age;
// 静态内部类 - Builder 模式
public static class Builder {
private String name;
private int age;
public Builder name(String name) {
this.name = name;
return this;
}
public Builder age(int age) {
this.age = age;
return this;
}
public User build() {
User user = new User();
user.name = this.name;
user.age = this.age;
return user;
}
}
@Override
public String toString() {
return name + " - " + age;
}
public static void main(String[] args) {
User user = new User.Builder()
.name("张三")
.age(25)
.build();
System.out.println(user);
}
}（3）匿名内部类
匿名内部类是没有名字的内部类，常用于临时实现接口或继承类的逻辑，适用于只用一次的情况，比如线程创建、回调事件处理。
public class Test {
public static void main(String[] args) {
// 使用匿名内部类创建线程
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程已启动！");
}
});
t.start();
}
}
（1）String（不可变字符串）
String底层是final char[]，它是不可变的，所有字符串拼接、替换、substring等操作，都会创建新对象。不可变性有一些好处：
[*]线程安全（多个线程共享同一个字符串不会有并发问题）
String s = "hello";
Thread t1 = new Thread(() -> {
System.out.println(s);
});
Thread t2 = new Thread(() -> {
System.out.println(s);
});<br>两个线程都在访问s，但因为String是不可变的，所以很安全：<br>- 内部的char[]是final；<br>- 无法修改字符串内容，只能重新赋值；<br>- 无论多少线程读同一个字符串，都不会出现竞态条件。
[*]可以被安全缓存（字符串常量池）
Java 中有个优化机制叫 字符串常量池（String Pool）：
String a = "abc";
String b = "abc";
System.out.println(a == b);// true，指向同一个地址
[*]JVM 会自动把 字符串字面量缓存到堆外常量池中；
[*]下次用同样的字面量，就不会创建新对象，而是复用；
[*]前提是：对象不可变，否则池里的值就可能被污染！
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
页:
[1]