程序员必须要知道的编程范式，你掌握了吗？

public class CommandExample {
    public static void main(String[] args) {
        int num1 = 5;
        int num2 = 10;
        int sum = 0;

        // 计算两个数的和
        sum = num1 + num2;

        // 打印结果
        System.out.println("Sum: " + sum);
    }
}

// 定义一个汽车类
class Car {
    private String brand;
    private String color;

    public Car(String brand, String color) {
        this.brand = brand;
        this.color = color;
    }

    public void start() {
        System.out.println("The " + color + " " + brand + " car starts.");
    }

    public void stop() {
        System.out.println("The " + color + " " + brand + " car stops.");
    }
}

public class OOPExample {
    public static void main(String[] args) {
        // 创建一个Car对象
        Car myCar = new Car("Toyota", "Red");

        // 调用对象的方法
        myCar.start();
        myCar.stop();
    }
}

import java.util.Arrays;
import java.util.List;

public class FPExample {
    public static void main(String[] args) {
        // 创建一个字符串列表
        List<String> words = Arrays.asList("apple", "banana", "orange", "pear");

        // 使用函数式编程方式进行操作
        words.stream()
             .filter(word -> word.length() > 5) // 过滤长度大于5的单词
             .map(String::toUpperCase) // 将单词转换为大写
             .forEach(System.out::println); // 打印结果
    }
}

-- 创建一个示例表
CREATE TABLE students (
  id INT PRIMARY KEY,
  name VARCHAR(50),
  age INT
);

-- 查询年龄小于20岁的学生姓名
SELECT name FROM students WHERE age < 20;

% 定义一些逻辑规则和事实
parent(john, jim).
parent(john, ann).
parent(jim, lisa).
parent(lisa, mary).

% 定义一个递归规则，判断某人是否是某人的祖先
ancestor(X, Y) :- parent(X, Y).
ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y).

% 查询某人的祖先
?- ancestor(john, mary).

public class ConcurrentExample {
    public static void main(String[] args) {
        // 创建一个共享的计数器对象
        Counter counter = new Counter();

        // 创建多个线程并发执行增加计数的操作
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();

        // 等待线程执行完毕
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出计数器的值
        System.out.println("Counter value: " + counter.getValue());
    }
}

class Counter {
    private int value = 0;

    public void increment() {
        value++;
    }

    public int getValue() {
        return value;
    }
}

public class GenericExample<T> {
    private T value;

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

    public T getValue() {
        return value;
    }

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

    public static <E> void printArray(E[] array) {
        for (E element : array) {
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        GenericExample<String> example1 = new GenericExample<>("Hello");
        System.out.println(example1.getValue());

        GenericExample<Integer> example2 = new GenericExample<>(123);
        System.out.println(example2.getValue());

        Integer[] numbers = {1, 2, 3, 4, 5};
        printArray(numbers);

        String[] words = {"apple", "banana", "cherry"};
        printArray(words);
    }
}

public class UserService {
    public void saveUser(User user) {
        // 保存用户信息的业务逻辑
        // ...
    }
}

@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.UserService.saveUser(..))")
    public void beforeSaveUser(JoinPoint joinPoint) {
        // 在saveUser方法执行之前执行的通知
        System.out.println("Before saving user: " + joinPoint.getArgs()[0]);
    }
}

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // 配置其他组件和Bean
    // ...
}

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    UserService userService = context.getBean(UserService.class);

    User user = new User("John Doe");
    userService.saveUser(user);
}

implementation 'io.reactivex.rxjava3:rxjava:3.1.2'

import io.reactivex.rxjava3.core.Observer;
import io.reactivex.rxjava3.disposables.Disposable;

public class LoginObserver implements Observer<User> {
    @Override
    public void onSubscribe(Disposable d) {
        // 当观察者订阅时执行的操作
    }

    @Override
    public void onNext(User user) {
        // 用户登录成功后执行的操作
        String welcomeMessage = "Welcome, " + user.getUsername();
        System.out.println(welcomeMessage);
    }

    @Override
    public void onError(Throwable e) {
        // 处理错误的操作
    }

    @Override
    public void onComplete() {
        // 用户登录完成后执行的操作
    }
}

import io.reactivex.rxjava3.core.Flowable;

public class LoginFlow {
    private Flowable<User> loginFlow;

    public LoginFlow() {
        // 创建登录流
        loginFlow = Flowable.create(emitter -> {
            // 模拟用户登录过程
            // ...

            // 当用户登录成功后，发射用户信息
            User user = new User("John Doe");
            emitter.onNext(user);

            // 完成登录流
            emitter.onComplete();
        }, BackpressureStrategy.BUFFER);
    }

    public Flowable<User> getLoginFlow() {
        return loginFlow;
    }
}

public static void main(String[] args) {
    LoginFlow loginFlow = new

 LoginFlow();
    Flowable<User> loginStream = loginFlow.getLoginFlow();

    // 订阅登录流并处理事件
    loginStream.subscribe(new LoginObserver());
}

public interface Shape {
    void draw();
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

import java.util.ArrayList;
import java.util.List;

public class Canvas implements Shape {
    private List<Shape> shapes;

    public Canvas() {
        shapes = new ArrayList<>();
    }

    public void addShape(Shape shape) {
        shapes.add(shape);
    }

    @Override
    public void draw() {
        System.out.println("Drawing canvas:");
        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}

public static void main(String[] args) {
    Canvas canvas = new Canvas();
    canvas.addShape(new Rectangle());
    canvas.addShape(new Circle());
    canvas.draw();
}

Drawing canvas:
Drawing a rectangle
Drawing a circle

import java.util.ArrayList;
import java.util.List;

public class Button {
    private List<ActionListener> listeners;

    public Button() {
        listeners = new ArrayList<>();
    }

    public void addActionListener(ActionListener listener) {
        listeners.add(listener);
    }

    public void click() {
        System.out.println("Button clicked");
        // 触发按钮点击事件
        for (ActionListener listener : listeners) {
            listener.onActionPerformed(new ActionEvent(this));
        }
    }
}

public class TextBox implements ActionListener {
    @Override
    public void onActionPerformed(ActionEvent event) {
        System.out.println("Text box updated: " + event.getSource());
    }
}

public static void main(String[] args) {
    Button button = new Button();
    TextBox textBox = new TextBox();

    button.addActionListener(textBox);

    // 模拟用户点击按钮
    button.click();
}

Button clicked
Text box updated: Button@2c8d66b2