1/31每日

1. Exception 和 Error 的区别

Exception 和 Error 都是 Throwable 类的子类，但它们有不同的用途和含义。

Exception: 代表程序运行时可以处理的异常情况。Exception 是可预料的，通常是程序逻辑错误或者其他外部因素导致的，程序可以通过捕获这些异常来做出适当的处理。例如：FileNotFoundException、IOException 等。
Error: 代表程序无法控制的严重错误，通常是由系统或硬件故障引起的。Error 不应当被捕获和处理，通常意味着程序的执行不能继续下去。例如：OutOfMemoryError、StackOverflowError 等。

总结：

Exception 是可以被捕获和处理的异常。
Error 是无法被程序处理的错误，通常表示虚拟机或硬件故障。

2. Checked Exception 和 Unchecked Exception 的区别

Checked Exception 和 Unchecked Exception 是 Java 中异常的两大类，主要区别在于是否需要显式处理（捕获或者声明）。

Checked Exception:
- 需要显式处理，即程序必须通过 try-catch 块捕获，或者通过 throws 声明抛出。
- 通常代表可以预见和处理的异常，如文件未找到、网络连接中断等。
- 例如：IOException、SQLException。
Unchecked Exception:
- 不需要显式处理，通常是程序中的错误，系统不会强制要求处理这些异常。
- 继承自 RuntimeException，通常是程序的逻辑错误，例如数组越界、空指针访问等。
- 例如：NullPointerException、ArrayIndexOutOfBoundsException。

Java 三大特性

Java 的三大特性是：封装 (Encapsulation)、继承 (Inheritance) 和 多态 (Polymorphism)。这三大特性是面向对象编程的核心，帮助开发者组织和管理代码，提升可重用性和扩展性

封装 (Encapsulation):
- 定义: 封装是将对象的状态（属性）和行为（方法）绑定在一起，并对外界隐藏实现细节，只有通过公有方法（如 getter 和 setter）访问对象的状态。
- 好处: 通过封装，可以保护对象的内部状态不被随意改变，增加了安全性和灵活性，也提高了代码的可维护性。
- 实现:
  - 将类的属性声明为 private，然后通过 public 方法提供对属性的访问。

继承 (Inheritance):

定义: 继承是指一个类（子类）可以继承另一个类（父类）的属性和方法，使得子类可以复用父类的代码，同时可以扩展或修改父类的行为。
好处: 继承使得代码得以复用，避免了重复代码，并且有助于构建类之间的层次结构。

多态 (Polymorphism):

定义: 多态是指同一个方法在不同的对象中表现出不同的行为。通过多态，可以用统一的接口调用不同实现类的对象，增强代码的灵活性和可扩展性。
好处: 多态支持程序设计中的“开放-封闭原则”，即对扩展开放，对修改封闭。即我们可以扩展新的子类，不需要修改现有代码。
实现:
- 方法重载：同一个类中，方法名称相同但参数不同，表现为编译时多态。
- 方法重写：子类重写父类的方法，表现为运行时多态。

方法重载 (Overloading):

同一个类中，方法名称相同，但参数类型、数量或顺序不同。
这种多态性是在编译时确定的，叫做编译时多态。

方法重写 (Overriding):

子类可以重写父类的方法，调用时会根据实际对象的类型来决定调用哪个方法。
这种多态性是在运行时确定的，叫做运行时多态。

多态的优势

灵活性: 可以通过父类引用指向子类对象，调用父类方法时实际执行的是子类重写的方法。

在上面的例子中，animal1 和 animal2 都是 Animal 类型的引用，但它们指向的是 Dog 和 Cat 的实例。调用 sound() 方法时，实际执行的是 Dog 和 Cat 中重写的方法，而不是 Animal 类中的方法，这体现了灵活性。

class Animal {public void sound() {System.out.println("Animal makes a sound");}
}class Dog extends Animal {@Overridepublic void sound() {System.out.println("Dog barks");}
}class Cat extends Animal {@Overridepublic void sound() {System.out.println("Cat meows");}
}public class Test {public static void main(String[] args) {Animal animal1 = new Dog();  // 父类引用指向子类对象Animal animal2 = new Cat();  // 父类引用指向子类对象animal1.sound();  // 输出 "Dog barks"animal2.sound();  // 输出 "Cat meows"}
}

可扩展性: 新增子类时，不需要修改已有代码，只需新增子类并实现父类的接口或方法。

// 定义 Shape 接口
interface Shape {void draw();
}// Circle 类实现了 Shape 接口
class Circle implements Shape {@Overridepublic void draw() {System.out.println("Drawing Circle");}
}// Rectangle 类实现了 Shape 接口
class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("Drawing Rectangle");}
}// Triangle 类实现了 Shape 接口
class Triangle implements Shape {@Overridepublic void draw() {System.out.println("Drawing Triangle");}
}// 测试类
public class Test {public static void main(String[] args) {// 创建 Shape 类型的数组Shape[] shapes = { new Circle(), new Rectangle(), new Triangle() };// 使用多态遍历数组并调用每个形状的 draw 方法for (Shape shape : shapes) {shape.draw();}}
}

代码简洁: 通过多态，代码更加简洁，避免了大量的 if 或 switch 语句来判断类型。

class Animal {public void sound(String animalType) {if (animalType.equals("Dog")) {System.out.println("Dog barks");} else if (animalType.equals("Cat")) {System.out.println("Cat meows");} else {System.out.println("Unknown animal");}}
}public class Test {public static void main(String[] args) {Animal animal = new Animal();animal.sound("Dog");  // 通过判断字符串来调用不同的行为animal.sound("Cat");}
}abstract class Animal {public abstract void sound();
}class Dog extends Animal {@Overridepublic void sound() {System.out.println("Dog barks");}
}class Cat extends Animal {@Overridepublic void sound() {System.out.println("Cat meows");}
}public class Test {public static void main(String[] args) {Animal dog = new Dog();Animal cat = new Cat();dog.sound();  // 输出 "Dog barks"cat.sound();  // 输出 "Cat meows"}
}

                                Collection|----------------------------------------------------------------|                               |                               |List                           Set                            Queue|                               |                               |-----------------              ---------------               --------------|               |              |             |               |            |
ArrayList    LinkedList      HashSet     TreeSet        LinkedList    PriorityQueue|LinkedHashSet

Collection：这是所有集合类的根接口。它定义了一些基本的集合操作方法，如 add()、remove()、size() 等。

List：继承自 Collection，是有序的集合，允许重复元素。常见的实现类有：
- ArrayList：基于动态数组实现，查找速度快，插入和删除效率较低。
- LinkedList：基于双向链表实现，适合频繁的插入和删除操作。
Set：继承自 Collection，是无序的集合，不允许重复元素。常见的实现类有：
- HashSet：基于哈希表实现，元素无序，查找速度快。
- LinkedHashSet：基于哈希表和链表实现，保持插入顺序。
- TreeSet：基于红黑树实现，元素自动按升序排序。
Queue：继承自 Collection，用于按顺序处理元素。常见的实现类有：
- LinkedList：既是 List 的实现类，也是 Queue 的实现类，适用于队列操作。
- PriorityQueue：基于优先级堆实现，元素按优先级排序。。

HashMap 的扩容机制是基于负载因子（load factor）和容量（capacity）来动态调整大小的。具体流程如下：

负载因子：HashMap 默认的负载因子是 0.75，意味着当 HashMap 中存储的元素个数达到了容量的 75% 时，会触发扩容。
容量：HashMap 的容量是它可以存储的桶的数量。扩容时，HashMap 会将桶的数量扩展为原来容量的两倍。
扩容触发条件：当 HashMap 中的元素数量超过了负载因子和当前容量的乘积时（即元素数量 >= 容量 * 负载因子），就会触发扩容。
扩容过程：
- 新的容量是原来容量的两倍。
- 所有的键值对都会重新计算哈希值并被重新分配到新的桶中，因为桶的数量发生了变化。这个过程可能会带来一定的性能开销，特别是当数据量很大的时候。
扩容后的影响：扩容后，HashMap 的性能通常会稍微降低，直到再填充一些元素后，性能才会回到正常水平。