Java基础知识（机试复习用）
|
2,149
|
0
|
后端

4859 字
|
40 分钟

Java 8 特性

  1. Lambda 表达式 ：允许使用更简洁的语法来定义匿名函数。它减少了样板代码并增强了可读性。
Java
List<Integer> numbers = Arrays.asList(1, 2, 3);
numbers.forEach(n -> System.out.println(n));
  1. 函数式接口 ：只有一个抽象方法的接口，可以与 Lambda 表达式一起使用，如 java.util.function 中的接口。
Java
@FunctionalInterface
interface MyFunction {
    void apply();
}
  1. Stream API ：提供处理集合数据的新方式，支持链式操作。
Java
List<String> list = Arrays.asList("a", "b", "c");
list.stream().filter(s -> s.startsWith("a")).forEach(System.out::println);
  1. 接口的默认方法和静态方法 ：可以在接口中定义默认实现和静态方法，解决了接口扩展的兼容问题。
Java
interface MyInterface {
    default void myMethod() { System.out.println("Default Method"); }
}
  1. Optional 类 ：用来避免 null 值引发的 NullPointerException。
Java
Optional<String> opt = Optional.of("value");
opt.ifPresent(System.out::println);
  1. 新日期时间 API ：java.time 包提供了全新的日期和时间处理类，如 LocalDate, LocalTime, LocalDateTime 等。

Java 基本语法

变量与数据类型

Java 是强类型语言，所有变量都需要声明类型。常见的数据类型分为两类：

  • 基本数据类型 ：
  • 整型：byte (8 位), short (16 位), int (32 位), long (64 位)
  • 浮点型：float (32 位), double (64 位)
  • 字符型：char (16 位，用于存储单个 Unicode 字符)
  • 布尔型：boolean (存储 true 或 false)
Java
int a = 10;
double pi = 3.14159;
boolean isJavaFun = true;
char grade = 'A';
  • 引用数据类型 包括类、接口、数组等。
Java
String name = "John";  // String 是引用类型
int[] numbers = new int[5];  // 数组是引用类型

运算符

Java 提供了丰富的运算符，主要分为以下几类：

  • 算术运算符 ：+, -, *, /, %
  • 关系运算符 ：==, !=, >, <, >=, <=
  • 逻辑运算符 ：&&, ||, !
  • 赋值运算符 ：=, +=, -=, *=, /=
  • 位运算符 ：&, |, ^, ~, <<, >>, >>>

控制结构

Java 提供的控制结构包括条件分支和循环。

  • 条件分支 ：if-else 和 switch 语句。
Java
if (a > 0) {
    System.out.println("Positive");
} else {
    System.out.println("Non-positive");
}

switch (day) {
    case 1: System.out.println("Monday"); break;
    case 2: System.out.println("Tuesday"); break;
    default: System.out.println("Other day");
}
  • 循环 ：for, while, do-while 结构。
Java
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

import java.util.Scanner;
Scanner scanner = new Scanner(System.in);
 do {
    System.out.print("请输入一个数字（输入负数结束）：");
    number = scanner.nextInt();
    if (number >= 0) {
        sum += number; // 只在输入非负数时累加
    }
} while (number >= 0); // 当输入非负数时继续循环

方法

方法是 Java 中用来执行某些任务的代码块，支持参数传递和返回值。

Java
public int sum(int a, int b) {
    return a + b;
}

int result = sum(5, 10);  // 调用方法

类与对象

Java 是面向对象编程语言，类是对象的蓝图或模板。

Java
class Person {
    String name;
    int age;

    // 构造方法
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法
    void greet() {
        System.out.println("Hello, " + name);
    }
}

// 创建对象
Person p = new Person("Alice", 25);
p.greet();  // 调用方法

异常处理机制

异常是程序执行过程中出现的错误，Java 提供了一套结构化的异常处理机制，确保程序能够优雅地处理错误。

  1. try-catch 结构：try 块中放置可能会引发异常的代码，catch 块用于捕获并处理异常。
Java
try {
    int result = 10 / 0;  // 会抛出 ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero!");
}
  1. finally 块：finally 块中的代码无论是否发生异常都会执行，通常用于关闭资源或清理操作。
Java
try {
    // 可能抛出异常的代码
} finally {
    System.out.println("This will always execute");
}
  1. throw 和 throws：
  • throw ：手动抛出异常。
Java
if (age < 18) {
    throw new IllegalArgumentException("Age must be 18 or above");
}
  • throws ：在方法声明中，表明该方法可能抛出某种类型的异常，调用者需要处理这些异常。
Java
public void readFile(String filePath) throws IOException {
    FileReader file = new FileReader(filePath);
}

自定义异常

可以通过扩展 Exception 类来自定义异常。

Java
class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

数据结构

Java 提供了多种常见的数据结构，以下是一些常用的结构及其应用。

数组（Array）

数组是定长的、存储同一种类型数据的集合，元素通过索引访问。

Java
int[] numbers = new int[5];
numbers[0] = 10;
System.out.println(numbers[0]);  // 输出 10
  • 多维数组
Java
int[][] matrix = new int[2][3];
matrix[0][0] = 1;

链表（Linked List）

链表是动态数据结构，由节点组成，每个节点包含数据和指向下一个节点的指针。

Java
class Node {
    int data;
    Node next;
}

class LinkedList {
    Node head;

    public void insert(int data) {
        Node newNode = new Node();
        newNode.data = data;
        newNode.next = head;
        head = newNode;
    }
}

队列（Queue）

队列是一种 FIFO（先进先出）结构。Queue 接口在 Java 中由类 LinkedList 实现。

Java
Queue<Integer> queue = new LinkedList<>();
queue.add(10);
queue.add(20);
System.out.println(queue.poll());  // 输出 10

栈（Stack）

栈是一种 LIFO（后进先出）结构，Stack 类可以实现栈的功能。

Java
Stack<Integer> stack = new Stack<>();
stack.push(10);
stack.push(20);
System.out.println(stack.pop());  // 输出 20

树（Tree）

树是一种分层数据结构，由节点组成。二叉树是最常见的树结构，其中每个节点最多有两个子节点。

  • 二叉树的实现 ：
Java
class TreeNode {
    int data;
    TreeNode left, right;

    public TreeNode(int data) {
        this.data = data;
        left = right = null;
    }
}

class BinaryTree {
    TreeNode root;

    public void insert(int data) {
        root = insertRec(root, data);
    }

    private TreeNode insertRec(TreeNode root, int data) {
        if (root == null) {
            root = new TreeNode(data);
            return root;
        }
        if (data < root.data)
            root.left = insertRec(root.left, data);
        else if (data > root.data)
            root.right = insertRec(root.right, data);

        return root;
    }
}
  • 树的遍历 ：可以通过深度优先搜索（DFS）或广度优先搜索（BFS）来遍历树。

类的基础知识

定义

Java 是一种面向对象的编程语言，类 是 Java 的核心组成部分。类是对象的蓝图或模板，描述对象的属性（字段）和行为（方法）。通过类可以创建多个对象，每个对象拥有相同的属性和方法。

类的组成

  • 字段（Fields） 类中定义的变量，用来存储对象的状态。
Java
class Person {
    String name;  // 字段
    int age;
}
  • 方法（Methods） 定义了对象的行为。
Java
class Person {
    String name;
    int age;

    void greet() {
        System.out.println("Hello, my name is " + name);
    }
}
  • 构造方法（Constructors） 用于创建对象时初始化对象的状态。
Java
class Person {
    String name;
    int age;

    // 构造方法
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
  • 访问修饰符（Access Modifiers） ：控制类和成员的可见性。
  • public：公开访问，任何地方都可访问。
  • private：私有访问，仅类内部可以访问。
  • protected：允许同包的类和子类访问。
  • 默认（无修饰符）：同包访问。

类的生命周期

Java 类的生命周期涵盖了类从加载到卸载的整个过程。生命周期的主要阶段包括：

加载（Loading）

当 JVM 需要使用某个类时，类加载器会从字节码文件中读取类的定义，并将其加载到内存中。在此阶段，类的字节码会被读取，并生成一个 Class 对象（java.lang.Class），表示类的运行时表示形式。

链接（Linking）

加载之后，类进入链接阶段，链接过程分为以下三步：

  • 验证（Verification） ：确保类文件的字节码符合 JVM 规范，防止恶意代码破坏。
  • 准备（Preparation） ：为类中的静态变量分配内存，并初始化为默认值（如 int 为 0）。
  • 解析（Resolution） ：将类、方法、字段的符号引用解析为直接引用。

初始化（Initialization）

此阶段是类生命周期的最后一步，也是最关键的一步。类的静态变量被赋予实际的值，静态块被执行。

Java
class Example {
    static int counter = 10;

    static {
        System.out.println("Class is being initialized");
    }
}

使用（Usage）

当类被初始化后，它进入使用阶段。在此阶段，JVM 可以使用类的对象，调用类的静态方法和字段，执行程序的逻辑。

卸载（Unloading）

当类不再被使用且没有任何活动的引用时，JVM 会将类从内存中卸载，以释放资源。类的卸载通常由垃圾收集器（Garbage Collector, GC）负责。

类的加载过程

Java 中的类加载采用 懒加载 原则，只有当一个类被真正使用时才会被加载。类的加载过程通过 类加载器（Class Loader） 来完成，JVM 自带一套类加载机制。

类加载的三步

  1. 加载（Loading） ：
    类加载器从文件系统或网络中读取类的二进制字节码，并将其转换为 JVM 可以理解的内存结构，即 Class 对象。
  2. 验证（Verification） ：
    JVM 验证加载的字节码是否符合 Java 语言规范和安全约束。
  3. 初始化（Initialization） ：
    执行类的静态初始化块和静态变量赋值。

类加载器的种类

Java 使用了分层次的类加载器体系，主要包括以下几种类加载器：

  • 启动类加载器（Bootstrap ClassLoader） ：最顶层的类加载器，加载 Java 的核心类库（如 rt.jar 中的类）。
  • 扩展类加载器（Extension ClassLoader） ：加载 lib/ext 目录下的扩展类库。
  • 应用类加载器（Application ClassLoader） ：负责加载应用程序的类路径（classpath）中的类。

双亲委派模型

定义

双亲委派模型 是 Java 类加载机制的重要特性，它规定类加载器在加载类时，必须先将请求委派给父类加载器。如果父类加载器无法加载该类，才由当前类加载器尝试加载。双亲委派模型的核心思想是防止类的重复加载，确保 Java 的核心类不会被篡改。

过程

  1. 当某个类加载器需要加载一个类时，它首先将加载请求委派给它的父类加载器。
  2. 父类加载器依次向上委派，直到顶层的启动类加载器。
  3. 如果父类加载器可以成功加载该类，则返回加载的类。
  4. 如果父类加载器无法加载，则当前类加载器尝试自己加载。

优点

  • 安全性 ：通过双亲委派模型，核心类库（如 java.lang.String）只能由启动类加载器加载，避免了类被篡改的风险。
  • 性能优化 ：类加载器避免了重复加载同一个类的开销。

示例

比如，当我们尝试加载 java.lang.String 类时，应用类加载器会先将请求委派给扩展类加载器，扩展类加载器再委派给启动类加载器，最后由启动类加载器加载 String 类。

特殊情况

有时类加载器需要打破双亲委派模型，这种情况通常发生在 自定义类加载器 （如 Web 容器的类加载器）中。

总结

类管理机制 涉及到 Java 中类的加载与管理，包括以下几部分：

  1. 类的基础知识 ：类是对象的模板，定义了字段和方法，通过类可以创建多个对象。
  2. 类的生命周期 ：从类的加载、链接、初始化、使用到卸载，涵盖类在 JVM 中的整个生存过程。
  3. 类加载过程 ：类加载器负责将类的字节码加载到 JVM 中并验证、准备和初始化。
  4. 双亲委派模型 ：类加载器采用逐级委派的方式，确保核心类库的安全性。

常见类库

java.lang

java.lang 包含了 Java 核心语言的基础类。这个包会自动导入，所以我们通常不需要显式导入

主要类和功能

  • Object :
  • 功能 : 所有类的基类，提供了基础方法如 equals()、hashCode()、toString()、clone()、finalize() 等。这些方法可以被子类重写，以实现类的比较、哈希计算、对象字符串表示等功能。
  • 用法示例 :
Java
class Person {
    String name;
    int age;

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }
}
  • String :
  • 功能 : 处理字符串的不可变类，支持各种字符串操作，如拼接、查找、替换、拆分等。
  • 常用方法 : length()、substring()、indexOf()、replace()、split()、toLowerCase()、toUpperCase()。
  • 用法示例 :
Java
String text = "Hello, World!";
String upperCaseText = text.toUpperCase();  // 转为大写
int position = text.indexOf("World");  // 查找子字符串的位置
  • Math :
  • 功能 : 提供常用的数学函数，如取整、取绝对值、计算幂次、三角函数等。
  • 常用方法 : abs()、pow()、sqrt()、sin()、cos()、random()。
  • 用法示例 :
Java
double squareRoot = Math.sqrt(16);  // 计算平方根
double randomNumber = Math.random();  // 生成 0 到 1 之间的随机数
  • Thread 和 Runnable :
  • 功能 : 用于多线程编程，Thread 类用于创建线程，Runnable 接口用于定义任务，允许并发执行任务。
  • 常用方法 : start()、run()、sleep()、join()、interrupt()。
  • 用法示例 :
Java
class MyTask implements Runnable {
    public void run() {
        System.out.println("Task is running");
    }
}

Thread thread = new Thread(new MyTask());
thread.start();  // 启动线程
  • Exception 和 Error :
  • 功能 : 用于异常处理，Exception 代表可处理的异常，Error 代表不可恢复的错误。通过 try-catch-finally 块处理异常。
  • 用法示例 :
Java
try {
    int result = 10 / 0;  // 可能抛出 ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
}

java.io

java.io 提供了输入输出（I/O）操作的类，主要用于处理文件、数据流、对象序列化等。

主要类和功能

  • File :
  • 功能 : 代表文件和目录，提供了文件和目录的创建、删除、重命名、属性查询等操作。
  • 常用方法 : exists()、createNewFile()、delete()、renameTo()、listFiles()。
  • 用法示例 :
Java
File file = new File("example.txt");
if (!file.exists()) {
    file.createNewFile();  // 创建新文件
}
  • FileInputStream 和 FileOutputStream :
  • 功能 : 用于字节流的输入输出操作，适合读取和写入二进制文件。
  • 常用方法 : read()、write()、close()。
  • 用法示例 :
Java
FileInputStream fis = new FileInputStream("example.txt");
int content;
while ((content = fis.read()) != -1) {
    System.out.print((char) content);
}
fis.close();
  • BufferedReader 和 BufferedWriter :
  • 功能 : 处理字符流，带有缓存功能，适合处理文本文件，能提升 I/O 效率。
  • 常用方法 : readLine()、write()、flush()、close()。
  • 用法示例 :
Java
BufferedReader reader = new BufferedReader(new FileReader("example.txt"));
String line;
while ((line = reader.readLine()) != null) {
    System.out.println(line);
}
reader.close();
  • ObjectInputStream 和 ObjectOutputStream :
  • 功能 : 用于对象的序列化和反序列化，适合将对象存储到文件或通过网络传输。
  • 常用方法 : writeObject()、readObject()。
  • 用法示例 :
Java
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
oos.writeObject(new Person("John", 30));  // 序列化对象
oos.close();

java.net

java.net 提供了网络通信的相关类，支持通过 TCP/IP 协议进行数据传输。

主要类和功能

  • URL :
  • 功能 : 代表网络资源的地址，可以通过 URL 访问网络资源。
  • 常用方法 : openConnection()、getHost()、getProtocol()。
  • 用法示例 :
Java
URL url = new URL("https://www.example.com");
System.out.println(url.getHost());  // 输出主机名
  • URLConnection :
  • 功能 : 用于访问 URL 资源，支持读取和写入网络数据。
  • 常用方法 : connect()、getInputStream()、getOutputStream()。
  • 用法示例 :
Java
URL url = new URL("https://www.example.com");
URLConnection connection = url.openConnection();
connection.connect();
BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
    System.out.println(inputLine);
}
in.close();
  • Socket 和 ServerSocket :
  • 功能 : 用于 TCP 网络通信。Socket 负责客户端的网络连接，ServerSocket 用于服务器端监听连接。
  • 常用方法 : accept()、connect()、getInputStream()、getOutputStream()。
  • 用法示例 :
Java
// 服务器端
ServerSocket serverSocket = new ServerSocket(8080);
Socket clientSocket = serverSocket.accept();  // 等待客户端连接
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
out.println("Hello, Client!");
clientSocket.close();

java.util

java.util 是 Java 中非常重要的工具包，包含集合框架、日期处理、随机数生成等。

主要类和功能

  • Collection 和 Collections :
  • 功能 : Collection 是集合框架的根接口，定义了集合的基本操作；Collections 类提供了操作集合的静态方法，如排序、搜索、反转等。
  • 用法示例 :
Java
List<Integer> numbers = new ArrayList<>(Arrays.asList(3, 2, 1));
Collections.sort(numbers);  // 对列表进行排序
  • List（如 ArrayList、LinkedList） :
  • 功能 : List 是一个有序的集合，允许重复元素。ArrayList 是基于数组实现的，适合随机访问；LinkedList 是基于链表实现的，适合频繁的插入删除操作。
  • 用法示例 :
Java
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
System.out.println(names.get(0));  // 访问第一个元素
  • Map（如 HashMap、TreeMap） :
  • 功能 : Map 用于存储键值对，不允许重复键。HashMap 提供快速查找，TreeMap 按照键的自然顺序或自定义排序存储。
  • 用法示例 :
Java
Map<String, Integer> map = new HashMap<>();
map.put("Alice", 30);
map.put("Bob", 25);
System.out.println(map.get("Alice"));  // 输出 30
  • Set（如 HashSet、TreeSet） :
  • 功能 : Set 表示不包含重复元素的集合，HashSet 基于哈希表实现，TreeSet 基于红黑树实现，提供排序功能。
  • 用法示例 :
Java
Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Alice");
uniqueNames.add("Alice");  // 重复的值不会被添加
  • Date 和 Calendar :
  • 功能 : 用于处理日期和时间，Date 类较为基础，Calendar 提供了更灵活的日期操作。
  • 用法示例 :
Java
Date date = new Date();
System.out.println(date);

Calendar calendar = Calendar.getInstance();
calendar.set(2024, Calendar.OCTOBER, 15);
System.out.println(calendar.getTime());
  • Optional :
  • 功能 : 用于表示可能为空的值，避免 null 引发的空指针异常。
  • 用法示例 :
Java
Optional<String> name = Optional.ofNullable(null);
System.out.println(name.orElse("Unknown"));  // 输出 "Unknown"

java.sql

java.sql 提供了与数据库交互的 JDBC API，允许通过 SQL 操作数据库。

主要类和功能

  • Connection :
  • 功能 : 表示与数据库的连接，使用 DriverManager 或 DataSource 获取连接。
  • 用法示例 :
Java
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "user", "password");
  • Statement 和 PreparedStatement :
  • 功能 : 用于执行 SQL 语句，PreparedStatement 支持参数化查询，可以防止 SQL 注入。
  • 用法示例 :
Java
PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM users WHERE age > ?");
pstmt.setInt(1, 30);
ResultSet rs = pstmt.executeQuery();
  • ResultSet :
  • 功能 : 用于存储和操作查询结果，支持遍历、更新结果集。
  • 用法示例 :
Java
while (rs.next()) {
    String name = rs.getString("name");
    int age = rs.getInt("age");
    System.out.println(name + ", " + age);
}
  • DriverManager :
  • 功能 : 用于管理数据库驱动程序并创建数据库连接。
  • 用法示例 :
Java
DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "user", "password");

javax.sql

javax.sql 类库是 Java EE 中用于提供对关系数据库的访问和操作的 API。它包含多个主要类和接口，帮助开发者进行数据库连接、事务管理、并发访问等操作。以下是 javax.sql 类库中的一些主要类和功能，以及相应的简单代码示例。

主要类和功能

  1. DataSource``DataSource 接口用于获取数据库连接，通常比 DriverManager 更灵活且可配置。它支持连接池、分布式事务等。
Java
import javax.sql.DataSource;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.sql.Connection;
import java.sql.SQLException;

public class DataSourceExample {
    public static void main(String[] args) {
        try {
            InitialContext ctx = new InitialContext();
            DataSource ds = (DataSource) ctx.lookup("java:/comp/env/jdbc/MyDataSource");
            try (Connection conn = ds.getConnection()) {
                // 使用连接
            }
        } catch (NamingException | SQLException e) {
            e.printStackTrace();
        }
    }
}
  1. ConnectionPoolDataSource``ConnectionPoolDataSource 接口扩展了 DataSource，提供连接池功能。它用于创建和管理连接池。
Java
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import javax.sql.DataSource;
import java.sql.SQLException;

public class ConnectionPoolDataSourceExample {
    public static void main(String[] args) {
        ConnectionPoolDataSource cpds = // 创建连接池数据源
        try {
            PooledConnection pconn = cpds.getPooledConnection();
            // 使用 PooledConnection
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
  1. Connection``Connection 接口表示与数据库的连接，提供用于执行 SQL 语句的方法。
Java
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class ConnectionExample {
    public static void main(String[] args) {
        try (DataSource ds = /* 初始化数据源 */) {
            try (Connection conn = ds.getConnection();
                 Statement stmt = conn.createStatement()) {
                ResultSet rs = stmt.executeQuery("SELECT * FROM users");
                while (rs.next()) {
                    System.out.println(rs.getString("username"));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
  1. RowSet``RowSet 接口是 ResultSet 的扩展，支持对结果集的操作并可以轻松与 JavaBeans 结合使用。它可以实现离线访问。
Java
import javax.sql.rowset.RowSet;
import javax.sql.rowset.RowSetProvider;
import javax.sql.rowset.jdbc.JdbcRowSet;

public class RowSetExample {
    public static void main(String[] args) {
        try {
            JdbcRowSet rowSet = RowSetProvider.newFactory().createJdbcRowSet();
            rowSet.setUrl("jdbc:mysql://localhost:3306/mydb");
            rowSet.setUsername("user");
            rowSet.setPassword("password");
            rowSet.setCommand("SELECT * FROM users");
            rowSet.execute();

            while (rowSet.next()) {
                System.out.println(rowSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. DataSource 的主要功能
  • 连接管理 ：通过 DataSource 和连接池实现高效的数据库连接管理。
  • 事务管理 ：可以使用 Connection 对象进行事务处理。
  • 并发访问 ：支持多线程并发访问数据库。

Spring 相关

IoC（控制反转）

IoC（Inversion of Control）是一种设计原则，用于将对象的创建和管理交给容器，而不是由对象自身控制。Spring通过容器实现IoC，容器负责实例化、配置和管理这些对象的生命周期。

代码示例

Java
// 定义一个服务接口
public interface GreetingService {
    void greet(String name);
}

// 实现接口
public class GreetingServiceImpl implements GreetingService {
    @Override
    public void greet(String name) {
        System.out.println("Hello, " + name);
    }
}

// Spring配置类
@Configuration
public class AppConfig {
    @Bean
    public GreetingService greetingService() {
        return new GreetingServiceImpl();
    }
}

// 使用IoC
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        GreetingService service = context.getBean(GreetingService.class);
        service.greet("World");
    }
}

DI（依赖注入）

DI（Dependency Injection）是IoC的一种实现方式，通过构造函数、Setter方法或接口注入依赖的对象。Spring使用DI来实现对象之间的解耦，使得代码更易于测试和维护。

代码示例

Java
// 定义一个消费者类
public class MessagePrinter {
    private final GreetingService greetingService;

    // 构造器注入
    public MessagePrinter(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    public void printMessage(String name) {
        greetingService.greet(name);
    }
}

// Spring配置类
@Configuration
public class AppConfig {
    @Bean
    public GreetingService greetingService() {
        return new GreetingServiceImpl();
    }

    @Bean
    public MessagePrinter messagePrinter() {
        return new MessagePrinter(greetingService());
    }
}

AOP（面向切面编程）

AOP（Aspect-Oriented Programming）是为了分离关注点而提出的一种编程思想。通过定义切面（Aspect），可以在不修改业务逻辑的情况下添加功能，如日志记录、事务管理等。

代码示例

Java
@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Executing: " + joinPoint.getSignature());
    }
}

// 在服务类中使用
@Service
public class UserService {
    public void createUser(String username) {
        // 创建用户的业务逻辑
    }
}

Spring体系产品

Spring Core

Spring Core是Spring框架的基础，提供IoC和DI功能。适用于需要管理对象生命周期和依赖关系的Java应用。

Spring Boot

Spring Boot是基于Spring的快速开发框架，简化了Spring应用的配置和部署。适用于微服务、RESTful API和快速原型开发。

代码示例

Java
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

Spring Data

Spring Data为数据访问提供了一套统一的编程模型，简化了数据库操作。适用于需要与不同数据源（如关系型数据库、NoSQL数据库）交互的应用。

代码示例

Java
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByLastName(String lastName);
}

Spring MVC

Spring MVC是一个用于构建Web应用程序的框架，提供了模型-视图-控制器的设计模式。适用于需要构建Web应用或RESTful服务的场景。

代码示例

Java
@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public String getUsers(Model model) {
        model.addAttribute("users", userService.findAll());
        return "userList";
    }
}

javajava8中间件基础知识复习
暂无评论

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																

							
							
						

															
					
											
						

	

		
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
	

	

		
颜文字
Emoji
小恐龙
花!
	


									

			

			
			
		

	






上一篇
下一篇