Java总结-Java

class Parent {
    static String staticVar = initStaticVar(); // 1. 静态变量

    static {
        System.out.println("1. 父类的静态代码块");
    }

    String instanceVar = initInstanceVar(); // 3. 实例变量

    {
        System.out.println("3. 父类的实例代码块");
    }

    Parent() {
        System.out.println("4. 父类的构造方法");
    }

    static String initStaticVar() {
        System.out.println("0. 父类的静态变量初始化");
        return "staticVar";
    }

    String initInstanceVar() {
        System.out.println("2. 父类的实例变量初始化");
        return "instanceVar";
    }
}

class Child extends Parent {
    static {
        System.out.println("5. 子类的静态代码块");
    }

    {
        System.out.println("7. 子类的实例代码块");
    }

    Child() {
        System.out.println("8. 子类的构造方法");
    }
}

public class ClassLoadOrder {
    public static void main(String[] args) {
        new Child(); // 创建子类对象
    }
}

class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

class Engine {
    void start() {
        System.out.println("Engine is starting");
    }
}

class Car {
    private Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }

    void start() {
        engine.start();
        System.out.println("Car is starting");
    }
}

private static final long serialVersionUID = 1L;

private void test() {
    Class<?> clazz = Class.forName("com.example.MyClass");
    Object instance = clazz.getConstructor().newInstance();

    Field field = clazz.getDeclaredField("name");
    field.setAccessible(true);
    field.set(instance, "Hello");

    Method method = clazz.getMethod("printName");
    method.invoke(instance);
}

Class<?> driverClass = Class.forName("com.mysql.cj.jdbc.Driver");

private void test() {
    if (clazz.isAnnotationPresent(Service.class)) {
        // 执行服务类的初始化逻辑
    }
}

// 1. 定义接口
interface Subject {
    void request();
}

// 2. 真实对象
class RealSubject implements Subject {
    public void request() {
        System.out.println("真实对象的请求");
    }
}

// 3. 代理类
class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    public void request() {
        preRequest();
        realSubject.request(); // 调用真实对象的方法
        postRequest();
    }

    private void preRequest() {
        System.out.println("代理前置处理");
    }

    private void postRequest() {
        System.out.println("代理后置处理");
    }
}

// 使用
public class Client {
    public static void main(String[] args) {
        RealSubject real = new RealSubject();
        Proxy proxy = new Proxy(real);
        proxy.request();
    }
}

public class SingletonLazy {
    // 静态实例变量，初始为 null
    private static SingletonLazy instance;

    // 私有构造方法，防止外部实例化
    private SingletonLazy() {
    }

    public static SingletonLazy getInstance() {
        // 只有在需要时才创建
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
}

public class SingletonEager {
    // 直接初始化
    private static final SingletonEager instance = new SingletonEager();

    // 私有构造方法
    private SingletonEager() {
    }

    public static SingletonEager getInstance() {
        // 直接返回实例
        return instance;
    }
}

public class SingletonDCL {
    // `volatile` 防止指令重排序
    private static volatile SingletonDCL instance;

    private SingletonDCL() {
    }

    public static SingletonDCL getInstance() {
        // 先检查实例是否存在
        if (instance == null) {
            // 线程同步
            synchronized (SingletonDCL.class) {
                // 二次检查
                if (instance == null) {
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }
}

public class Stack<T> {
    private T[] m_item;

    public T Pop() {...}

    public void Push(T item) {...}

    public Stack(int i) {
        this.m_item = new T[i];
    }
}

public void test() {

    //实例化只能保存int类型的类
    Stack<int> a = new Stack<int>(100);

    a.Push(10);

    //这一行编译不通过，因为类a只接收int类型的数据
    a.Push("8888");
    ...
}

public class Box<T> {
    private T value;

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

    public T getValue() {
        return value;
    }
}

public class ListWrapper<E> {
    private List<E> list;

    public void addElement(E element) {
        list.add(element);
    }

    public E getElement(int index) {
        return list.get(index);
    }
}

public class MyMap<K, V> {
    private Map<K, V> map;

    public void put(K key, V value) {
        map.put(key, value);
    }

    public V get(K key) {
        return map.get(key);
    }
}

//（同上，V 已在 MyMap<K, V> 中解释）

public void printList(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
}

public void processNumbers(List<? extends Number> list) {
    for (Number num : list) {
        System.out.println(num);
    }
}

public void addIntegerToList(List<? super Integer> list) {
    list.add(42);  // 可以添加 Integer 或其父类类型的元素
}

public class ClassTypeDemo {

    public static void main(String[] args) {
        // Class<T> 用于已知类型
        Class<String> stringClass = String.class;
        // java.lang.String
        System.out.println("stringClass: " + stringClass.getName());

        // Class<?> 适用于未知类型
        // 传入 Integer
        Class<?> unknownClass = getClassType(42);
        // java.lang.Integer
        System.out.println("unknownClass: " + unknownClass.getName());
    }

    // 使用 Class<?> 处理不确定的类型
    public static Class<?> getClassType(Object obj) {
        return obj.getClass();
    }

}

// 定义泛型类
public static class MyObject<T> {
    private T value;

    public MyObject(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

public class GenericExample {
    public static void main(String[] args) {
        // 使用 Class<T>，类型已知
        MyObject<String> obj = new MyObject<>("Hello");
        System.out.println("Value: " + obj.getValue());

        // 使用 Class<?>，可以处理任何类型
        MyObject<?> unknownObj = new MyObject<>(123);
        System.out.println("Unknown Value: " + unknownObj.getValue());
    }
}

// 泛型代码
public class Box<T> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

// 擦除泛型后的代码
public class Box {
    // 泛型 T 变成 Object
    private Object value;

    public void setValue(Object value) {
        this.value = value;
    }

    public Object getValue() {
        return value;
    }
}

@FunctionalInterface
interface Greeting {
    void sayHello(String name);
}

public class LambdaTest {
    public static void main(String[] args) {
        // Lambda 表达式实现接口
        Greeting greeting = name -> System.out.println("Hello, " + name);
        greeting.sayHello("Tom");
    }
}

Greeting greeting = name -> System.out.println("Hello, " + name);

private void test() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

    List<Integer> evenNumbers = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());

    System.out.println(evenNumbers); // 输出 [2, 4]
}

public void test() {
    if (user != null) {
        if (user.getDept() != null) {
            String deptName = user.getDept().getName();
            if (StrUtil.isBlank(deptName)) {
                System.out.println("未指定部门");
            } else {
                System.out.println(deptName);
            }
        } else {
            System.out.println("未指定部门");
        }
    }
}

private void test() {
    String deptName = Optional.ofNullable(user)           // 创建 Optional
            .map(User::getDept)                            // 提取 Dept
            .map(Dept::getName)                             // 提取 Dept 的名字
            .filter(StrUtil::isNotBlank)                   // 判断是否为空
            .orElse("未指定部门");                          // 终结操作（默认值）

    System.out.println(deptName);
}

private void test() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

    numbers.parallelStream().forEach(n -> {
        System.out.println(n + " - " + Thread.currentThread().getName());
    });
}

import java.util.*;

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();

        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Orange", 3);
        map.put("Grapes", 4);
        // 发生哈希冲突，替换原有值
        map.put("Banana", 5);

        // 输出: {Apple=1, Banana=5, Orange=3, Grapes=4}
        System.out.println(map);
    }
}

import java.util.Hashtable;

public class OpenAddressingExample {
    public static void main(String[] args) {
        Hashtable<Integer, String> table = new Hashtable<>();

        // 插入元素
        table.put(1, "One");
        table.put(2, "Two");
        table.put(3, "Three");
        table.put(4, "Four");

        // 打印元素
        System.out.println(table);
    }
}