Java 核心知识整理

// if-else 示例
if (score >= 90) {
    System.out.println("A");
} else if (score >= 80) {
    System.out.println("B");
} else {
    System.out.println("C");
}

// switch 示例（JDK 14+ 语法）
switch (day) {
    case "Monday" -> System.out.println("工作日");
    case "Sunday" -> System.out.println("休息日");
    default -> System.out.println("其他");
}

// for 循环示例
for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

// while 循环示例
int i = 0;
while (i < 10) {
    System.out.println(i++);
}

// do-while 循环示例
int j = 0;
do {
    System.out.println(j++);
} while (j < 10);

// for-each 循环示例
int[] arr = {1, 2, 3};
for (int num : arr) {
    System.out.println(num);
}

。

// 一维数组  
int[] arr1 = new int[5];           // 动态初始化（默认值：0）  
int[] arr2 = {10, 20, 30};         // 静态初始化  
String[] arr3 = new String[]{"A", "B", "C"};  // 完整语法  

// 多维数组  
int[][] matrix = new int[3][4];    // 3行4列的二维数组  
int[][] triangle = {{1}, {2, 3}, {4, 5, 6}};  // 不规则二维数组  

// 动态初始化二维数组  
int[][] dynamic = new int[2][];    // 先定义行  
dynamic[0] = new int[3];           // 再定义列  
dynamic[1] = new int[2];  

// 一维数组长度
int len1 = arr.length;

// 二维数组行数
int rows = matrix.length;

// 二维数组列数（假设matrix至少有一行）
int cols = matrix[0].length;

// for循环（带索引）
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

// for-each循环（简化遍历）
for (int num : arr) {
    System.out.println(num);
}

// 浅拷贝（仅复制引用，共享同一对象）
int[] copy1 = arr;

// 深拷贝方式一：使用Arrays.copyOf
int[] copy2 = Arrays.copyOf(arr, arr.length);

// 深拷贝方式二：使用System.arraycopy（效率更高）
int[] copy3 = new int[arr.length];
System.arraycopy(arr, 0, copy3, 0, arr.length);

// 升序排序（基本类型数组）
int[] arr = {5, 3, 8};
Arrays.sort(arr); // 结果：[3, 5, 8]

// 降序排序（需使用包装类型）
Integer[] arrObj = {3, 1, 2};
Arrays.sort(arrObj, Collections.reverseOrder()); // 结果：[3, 2, 1]

// 线性查找（适用于未排序数组）
int target = 5;
int index = -1;
for (int i = 0; i < arr.length; i++) {
    if (arr[i] == target) {
        index = i;
        break;
    }
}

// 二分查找（仅适用于已排序数组）
Arrays.sort(arr); // 先排序
int pos = Arrays.binarySearch(arr, target);
if (pos >= 0) {
    // 找到元素，pos为索引
} else {
    // 未找到元素，pos为插入点取反-1
}

// 类的完整定义（含封装）
public class Person {
    // 私有属性（封装核心数据）
    private String name;
    private int age;
    private static final String DEFAULT_COUNTRY = "China"; // 静态常量

    // 构造方法（初始化对象状态）
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 公共方法（暴露访问接口）
    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", age " + age);
    }

    // Getter/Setter（属性访问控制）
    public String getName() { return name; }
    public void setName(String name) { 
        if (name != null && !name.isEmpty()) {
            this.name = name;
        }
    }
    public int getAge() { return age; }
    public void setAge(int age) { 
        if (age >= 0 && age <= 150) {
            this.age = age;
        }
    }

    // 静态方法（属于类而非实例）
    public static String getDefaultCountry() {
        return DEFAULT_COUNTRY;
    }
}

// 对象创建与使用示例
public class ObjectDemo {
    public static void main(String[] args) {
        // 实例化对象
        Person person = new Person("Alice", 25);

        // 调用方法
        person.sayHello(); // 输出：Hello, my name is Alice, age 25

        // 通过Setter修改属性
        person.setName("Bob");
        person.setAge(30);
        person.sayHello(); // 输出：Hello, my name is Bob, age 30

        // 访问静态成员
        System.out.println(Person.getDefaultCountry()); // 输出：China
    }
}

// 父类定义
public class Person {
    protected String name;
    protected int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hello, I'm a person.");
    }

    public void showInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

// 子类继承示例
public class Student extends Person {
    private String studentId;
    private double score;

    // 子类构造方法必须调用父类构造
    public Student(String name, int age, String studentId, double score) {
        super(name, age); // 显式调用父类构造
        this.studentId = studentId;
        this.score = score;
    }

    // 方法重写示例
    @Override
    public void sayHello() {
        super.sayHello(); // 调用父类方法
        System.out.println("I'm a student, ID: " + studentId);
    }

    // 子类特有方法
    public void showScore() {
        System.out.println("Score: " + score);
    }
}

// 多态应用示例
public class PolymorphismDemo {
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Person p1 = new Student("Bob", 20, "S001", 90.5);
        Person p2 = new Person("Alice", 25);

        // 动态调用方法（根据实际对象类型）
        p1.sayHello(); // 输出子类重写的方法
        p1.showInfo(); // 输出父类方法（未重写）

        p2.sayHello(); // 输出父类方法

        // 多态与类型转换
        if (p1 instanceof Student) {
            Student student = (Student) p1; // 向下转型
            student.showScore(); // 调用子类特有方法
        }
    }
}

// 接口定义（含抽象方法和默认方法）
public interface Flyable {
    // 抽象方法（必须实现）
    void fly();

    // 默认方法（可选重写）
    default void takeOff() {
        System.out.println("Preparing to take off...");
    }

    // 静态方法（接口直接调用）
    static void printFlyableInfo() {
        System.out.println("This is a flyable object.");
    }
}

// 接口定义（继承其他接口）
public interface Swimmable {
    void swim();
}

// 类实现多个接口示例
public class Duck implements Flyable, Swimmable {
    private String name;

    public Duck(String name) {
        this.name = name;
    }

    // 实现Flyable接口方法
    @Override
    public void fly() {
        System.out.println(name + " is flying low over the water.");
    }

    @Override
    public void takeOff() {
        System.out.println(name + " is flapping wings to take off.");
    }

    // 实现Swimmable接口方法
    @Override
    public void swim() {
        System.out.println(name + " is swimming in the water.");
    }
}

// 接口使用示例
public class InterfaceDemo {
    public static void main(String[] args) {
        Duck duck = new Duck("Donald");
        duck.fly();       // 输出：Donald is flying low over the water.
        duck.takeOff();   // 输出：Donald is flapping wings to take off.
        duck.swim();      // 输出：Donald is swimming in the water.

        // 调用接口静态方法
        Flyable.printFlyableInfo(); // 输出：This is a flyable object.
    }
}

// 成员内部类示例
public class OuterClass {
    private int outerField = 10;
    private static int staticOuterField = 20;

    // 成员内部类（非静态）
    public class InnerClass {
        private int innerField = 5;

        // 访问外部类成员
        public void accessOuter() {
            System.out.println("Outer field: " + outerField);       // 访问外部类实例变量
            System.out.println("Static outer field: " + staticOuterField); // 访问静态变量
        }

        // 外部类方法中创建内部类实例
        public void innerMethod() {
            System.out.println("Inner method, field: " + innerField);
        }
    }

    // 静态内部类示例
    public static class StaticInnerClass {
        private int staticInnerField = 100;

        // 仅能访问外部类静态成员
        public void accessOuter() {
            System.out.println("Static outer field: " + staticOuterField);
            // 无法访问 outerField（非静态）
        }
    }

    // 局部内部类示例
    public void localInnerDemo() {
        final int localVar = 50; // 局部变量需为final或隐式final

        // 局部内部类定义在方法中
        class LocalInner {
            public void printLocal() {
                System.out.println("Local variable: " + localVar);
            }
        }

        LocalInner local = new LocalInner();
        local.printLocal();
    }

    // 匿名内部类示例
    public void anonymousInnerDemo() {
        // 创建接口的匿名实现
        Flyable flyable = new Flyable() {
            @Override
            public void fly() {
                System.out.println("Anonymous inner class is flying.");
            }
        };
        flyable.fly();
    }
}

// 内部类使用示例
public class InnerClassDemo {
    public static void main(String[] args) {
        // 创建成员内部类实例
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.accessOuter();
        inner.innerMethod();

        // 创建静态内部类实例
        OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
        staticInner.accessOuter();

        // 调用局部内部类方法
        outer.localInnerDemo();

        // 调用匿名内部类方法
        outer.anonymousInnerDemo();
    }
}

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理异常类型1
} catch (ExceptionType2 e2) {
    // 处理异常类型2
} finally {
    // 无论是否异常都会执行（如资源释放）
}

// 自定义受检异常（继承Exception）
class AgeValidationException extends Exception {
    public AgeValidationException(String message) {
        super(message);
    }
}

// 自定义非受检异常（继承RuntimeException）
class NegativeValueException extends RuntimeException {
    public NegativeValueException(String message) {
        super(message);
    }
}

// 使用异常的业务类
public class Person {
    private int age;
    private double salary;

    // 抛出受检异常的方法
    public void setAge(int age) throws AgeValidationException {
        if (age < 0 || age > 150) {
            throw new AgeValidationException("年龄必须在0-150之间，当前输入：" + age);
        }
        this.age = age;
    }

    // 抛出非受检异常的方法
    public void setSalary(double salary) {
        if (salary < 0) {
            throw new NegativeValueException("薪资不能为负数，当前输入：" + salary);
        }
        this.salary = salary;
    }

    // 异常链示例
    public void processData() {
        try {
            // 调用可能抛出异常的方法
            setAge(-5);
        } catch (AgeValidationException e) {
            // 包装异常并抛出，保留原始异常信息
            throw new IllegalStateException("数据处理失败", e);
        }
    }
}

// 异常处理示例
public class ExceptionDemo {
    public static void main(String[] args) {
        Person person = new Person();

        // 处理受检异常
        try {
            person.setAge(200);
        } catch (AgeValidationException e) {
            System.err.println("错误：" + e.getMessage());
            e.printStackTrace(); // 打印异常栈轨迹
        }

        // 处理非受检异常
        try {
            person.setSalary(-5000);
        } catch (NegativeValueException e) {
            System.err.println("运行时错误：" + e.getMessage());
        }

        // 处理异常链
        try {
            person.processData();
        } catch (IllegalStateException e) {
            System.err.println("业务异常：" + e.getMessage());
            System.err.println("原始异常：" + e.getCause()); // 获取原始异常
        }

        // try-with-resources示例（自动关闭资源）
        try (java.io.FileReader reader = new java.io.FileReader("test.txt")) {
            int data = reader.read();
            // 处理文件读取
        } catch (java.io.IOException e) {
            System.err.println("文件读取失败：" + e.getMessage());
        }
    }
}

// String 示例
String s1 = "hello";
String s2 = s1 + " world"; // 生成新字符串

// StringBuilder 示例
StringBuilder sb = new StringBuilder();
sb.append("a").append("b"); // 高效拼接

// 使用 Math.random() 生成指定范围整数
int randomNum = (int)(Math.random() * 9000 + 1000);  // 生成 1000~9999 的整数

// 使用 Random 类生成随机数
Random random = new Random();
int rand = random.nextInt(100);  // 生成 [0, 100) 的整数

// 二维数组赋值示例
String[] str2 = {"1 2", "3 4"};
String[][] str1 = new String[str2.length][];
for (int j = 0; j < str2.length; j++) {
    str1[j] = str2[j].split(" ");  // 按空格分割字符串并赋值给二维数组
}

// 数组复制示例
int[] src = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(src, 1, dest, 0, 3);  // 从src[1]复制3个元素到dest[0]

// LocalDate 示例
LocalDate today = LocalDate.now();
LocalDate birthday = LocalDate.of(2000, 1, 1);

// LocalDateTime 示例
LocalDateTime dt = LocalDateTime.now();
dt.plusDays(1); // 加一天

// 自动装箱/拆箱示例
Integer num = 10; // 自动装箱（int → Integer）
int value = num;  // 自动拆箱（Integer → int）

Double d = 3.14;  // 自动装箱（double → Double）
double primitive = d;  // 自动拆箱（Double → double）

public class 类名<T1, T2, ...> {  // 类型参数列表（可多个）
    private T1 field1;
    private T2 field2;

    public T1 getField1() { return field1; }
    public void setField1(T1 field1) { this.field1 = field1; }
    // ...
}

// 泛型类：通用容器 Box
public class Box<T> {
    private T content;  // 类型参数 T 作为属性类型

    public Box() {}
    public Box(T content) {
        this.content = content;
    }

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }

    // 泛型类中定义泛型方法
    public <S> Box<S> createBox(S content) {
        return new Box<>(content);
    }
}

// 泛型方法：打印任意类型数组
public class GenericMethods {
    // 类型参数 T 定义在方法签名中
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    // 多类型参数方法
    public static <K, V> void printMap(Map<K, V> map) {
        map.forEach((k, v) -> System.out.println(k + " -> " + v));
    }
}

// 使用示例
public class GenericDemo {
    public static void main(String[] args) {
        // 泛型类实例化（类型擦除前）
        Box<Integer> intBox = new Box<>(100);
        Box<String> strBox = new Box<>("Hello");

        intBox.setContent(200);
        System.out.println(intBox.getContent()); // 输出：200

        // 调用泛型方法
        Integer[] nums = {1, 2, 3, 4};
        String[] names = {"Alice", "Bob"};
        GenericMethods.printArray(nums);  // 输出：1 2 3 4
        GenericMethods.printArray(names); // 输出：Alice Bob

        // 泛型类中的泛型方法
        Box<Double> doubleBox = intBox.createBox(3.14);
        System.out.println(doubleBox.getContent()); // 输出：3.14
    }
}

// 上界通配符：打印数字集合（? extends Number）
public static void printNumbers(List<? extends Number> list) {
    for (Number num : list) {
        System.out.println(num);
    }
    // list.add(1); 报错：无法向? extends Number的集合添加元素
}

// 下界通配符：向集合添加整数（? super Integer）
public static void addIntegers(List<? super Integer> list) {
    list.add(10);
    list.add(20);
    // Integer num = list.get(0); 报错：无法确定具体类型
}

// 无界通配符：读取集合元素（?）
public static void printElements(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
    // list.add("abc"); 报错：未知类型无法添加
}

// 多边界泛型：类型同时继承多个接口（T extends A & B & C）
public interface Printable { void print(); }
public interface Comparable<T> { int compareTo(T o); }

public class GenericBounds<T extends Printable & Comparable<T>> {
    public void process(T obj) {
        obj.print();
        // 使用 Comparable 方法
    }
}

// 使用示例
public class WildcardDemo {
    public static void main(String[] args) {
        List<Integer> intList = Arrays.asList(1, 2, 3);
        List<Double> doubleList = Arrays.asList(3.14, 2.71);
        List<Object> objList = new ArrayList<>();

        printNumbers(intList);   // 输出整数
        printNumbers(doubleList); // 输出浮点数

        addIntegers(intList);    // 向Integer集合添加元素
        addIntegers(objList);    // 向Object集合添加元素

        // 多边界示例（假设Integer实现了Printable接口）
        GenericBounds<Integer> processor = new GenericBounds<>();
        processor.process(100);
    }
}

public class ErasureDemo {
    public static void main(String[] args) {
        Box<Integer> intBox = new Box<>(10);
        Box<String> strBox = new Box<>("Hello");

        // 运行时类型擦除，类型参数被替换为Object
        System.out.println(intBox.getClass() == strBox.getClass()); // 输出：true

        // 泛型限制示例
        // Box<int> errorBox = new Box<int>(5);  // 编译错误：不能使用基本类型
        // T[] arr = new T[10];  // 编译错误：无法创建泛型数组
    }
}

// 泛型限制解决方案
public class GenericRestrictions<T> {
    // 方案1：通过反射实例化类型参数
    public T createInstance(Class<T> clazz) throws Exception {
        return clazz.getDeclaredConstructor().newInstance();
    }

    // 方案2：使用数组包装类
    public static <T> List<T> createList(Class<T> clazz, int size) {
        T[] arr = (T[]) new Object[size]; // 强制转换，需确保类型安全
        return Arrays.asList(arr);
    }
}

// List 操作示例（ArrayList vs LinkedList）
List<String> arrayList = new ArrayList<>();
List<String> linkedList = new LinkedList<>();

// 通用操作
arrayList.add("apple");
arrayList.add("banana");
arrayList.add(1, "cherry"); // 指定位置插入
System.out.println(arrayList.get(1)); // 输出：cherry
System.out.println(arrayList.size()); // 输出：3
arrayList.remove(0); // 按索引删除

// LinkedList 特有操作（双向链表）
linkedList.addFirst("head");
linkedList.addLast("tail");
System.out.println(linkedList.getFirst()); // 输出：head
System.out.println(linkedList.poll()); // 移除并返回头部元素

// Set 操作示例
Set<Integer> hashSet = new HashSet<>();
Set<Integer> treeSet = new TreeSet<>();

// 通用操作
hashSet.add(3);
hashSet.add(1);
hashSet.add(2);
System.out.println(hashSet.contains(2)); // 输出：true
System.out.println(hashSet.size()); // 输出：3
hashSet.remove(1);

// TreeSet 特有操作（有序）
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
System.out.println(treeSet.first()); // 输出：1（最小值）
System.out.println(treeSet.last());  // 输出：3（最大值）

// Map 操作示例
Map<String, Integer> hashMap = new HashMap<>();
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
Map<String, Integer> treeMap = new TreeMap<>();

// 通用操作
hashMap.put("one", 1);
hashMap.put("two", 2);
hashMap.put("three", 3);
System.out.println(hashMap.get("two")); // 输出：2
System.out.println(hashMap.containsKey("three")); // 输出：true
hashMap.remove("one");

// LinkedHashMap 维护插入顺序
linkedHashMap.put("b", 2);
linkedHashMap.put("a", 1);
linkedHashMap.put("c", 3);
System.out.println(linkedHashMap.keySet()); // 输出：[b, a, c]

// TreeMap 按键排序（自然顺序）
treeMap.put("b", 2);
treeMap.put("a", 1);
treeMap.put("c", 3);
System.out.println(treeMap.keySet()); // 输出：[a, b, c]