Java核心知识 - Java学习笔记

Java基础知识

Java是一种广泛使用的计算机编程语言，拥有跨平台、面向对象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。

Java语言特点

简单性：Java语法与C++类似，但移除了指针等复杂特性
面向对象：完全支持面向对象的设计理念
平台无关性：一次编写，到处运行
安全性：提供安全的执行环境
多线程：内置多线程支持

Java基本语法

以下是一个简单的Java程序示例：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Java数据类型

Java中的数据类型分为两大类：

基本数据类型：byte, short, int, long, float, double, boolean, char
引用数据类型：类、接口、数组

注意：Java中的基本数据类型有固定的大小，例如int占4个字节，long占8个字节。这与C/C++不同，后者的数据类型大小可能因平台而异。

面向对象编程

Java是一种纯面向对象的编程语言，所有的代码都必须位于类中。面向对象编程的三大特性是：封装、继承和多态。

封装

封装是将数据和操作数据的方法绑定在一起，对外部世界隐藏内部实现细节。在Java中，我们使用访问修饰符（public, private, protected）来实现封装。

public class Person {
    private String name;
    private int age;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

继承

继承允许一个类获取另一个类的属性和方法。在Java中，使用extends关键字实现继承。

public class Employee extends Person {
    private double salary;
    
    public double getSalary() {
        return salary;
    }
    
    public void setSalary(double salary) {
        this.salary = salary;
    }
}

多态

多态允许不同类的对象对同一消息作出响应。在Java中，多态通过方法重写和方法重载实现。

public class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}

集合框架

Java集合框架提供了一套性能优良、可扩展的集合类，用于存储和操作对象组。

主要接口

Collection：集合层次结构的根接口
List：有序集合，允许重复元素
Set：不允许重复元素的集合
Map：键值对映射，不允许重复键

常用实现类

ArrayList：基于动态数组的List实现
LinkedList：基于双向链表的List实现
HashSet：基于哈希表的Set实现
TreeSet：基于红黑树的有序Set实现
HashMap：基于哈希表的Map实现
TreeMap：基于红黑树的有序Map实现

集合使用示例

import java.util.*;

public class CollectionDemo {
    public static void main(String[] args) {
        // List示例
        List list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        
        for (String fruit : list) {
            System.out.println(fruit);
        }
        
        // Map示例
        Map map = new HashMap<>();
        map.put("Apple", 10);
        map.put("Banana", 20);
        map.put("Orange", 30);
        
        for (Map.Entry entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

并发编程

Java提供了强大的并发编程支持，包括线程创建、同步机制和并发工具类。

线程创建

在Java中创建线程有两种方式：

继承Thread类
实现Runnable接口

// 方式1：继承Thread类
public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running...");
    }
}

// 方式2：实现Runnable接口
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable is running...");
    }
}

// 使用示例
public class ThreadDemo {
    public static void main(String[] args) {
        // 使用Thread子类
        MyThread thread = new MyThread();
        thread.start();
        
        // 使用Runnable实现类
        Thread thread2 = new Thread(new MyRunnable());
        thread2.start();
    }
}

同步机制

Java提供了synchronized关键字和Lock接口来实现线程同步。

// 使用synchronized关键字
public class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

// 使用Lock接口
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockCounter {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
    
    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

Java 8特性

Java 8引入了许多新特性，包括Lambda表达式、Stream API、新的日期时间API等。

Lambda表达式

Lambda表达式是一种匿名函数，可以更简洁地表示只有一个抽象方法的接口（函数式接口）的实例。

// 传统方式
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
};

// Lambda表达式
Runnable runnable = () -> System.out.println("Hello World");

Stream API

Stream API提供了一种函数式编程的方式来处理集合数据。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamDemo {
    public static void main(String[] args) {
        List names = Arrays.asList("John", "Jane", "Jack", "Joe");
        
        // 过滤以J开头的名字并转换为大写
        List filteredNames = names.stream()
                .filter(name -> name.startsWith("J"))
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        
        System.out.println(filteredNames);
    }
}

新的日期时间API

Java 8引入了新的日期时间API，解决了旧API的设计缺陷。

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class DateTimeDemo {
    public static void main(String[] args) {
        // 获取当前日期
        LocalDate today = LocalDate.now();
        System.out.println("Today: " + today);
        
        // 获取当前时间
        LocalTime time = LocalTime.now();
        System.out.println("Current time: " + time);
        
        // 获取当前日期和时间
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println("Current date and time: " + dateTime);
        
        // 格式化日期时间
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = dateTime.format(formatter);
        System.out.println("Formatted date and time: " + formattedDateTime);
    }
}

Java 17新特性

Java 17是一个长期支持版本（LTS），引入了多项新特性和改进。

密封类（Sealed Classes）

密封类允许类的作者控制哪些类可以继承该类，增强了封装性。

// 密封类示例
public sealed class Shape permits Circle, Rectangle, Triangle {
    // 类的内容
}

public final class Circle extends Shape {
    // Circle的实现
}

public final class Rectangle extends Shape {
    // Rectangle的实现
}

public final class Triangle extends Shape {
    // Triangle的实现
}

模式匹配（Pattern Matching）

Java 17增强了instanceof的模式匹配功能，简化了类型检查和转换。

// 传统方式
if (obj instanceof String) {
    String s = (String) obj;
    // 使用字符串s
}

// 使用模式匹配
if (obj instanceof String s) {
    // 直接使用字符串s
}

文本块（Text Blocks）

文本块使多行字符串的表示更加简洁和直观。

// 传统方式
String html = "<html>\n" +
              "    <body>\n" +
              "        <p>Hello, World!</p>\n" +
              "    </body>\n" +
              "</html>\n";

// 使用文本块
String html = """
              <html>
                  <body>
                      <p>Hello, World!</p>
                  </body>
              </html>
              """;

记录类（Records）

记录类是一种特殊的类，主要用于存储数据，自动生成构造函数、getter方法、equals()、hashCode()和toString()方法。

// 传统的数据类
public class Person {
    private final String name;
    private final int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    // equals(), hashCode(), toString()方法
}

// 使用记录类
public record Person(String name, int age) {
    // 自动生成构造函数、getter方法、equals()、hashCode()和toString()方法
}

目录

Java基础知识

Java语言特点

Java基本语法

Java数据类型

面向对象编程

封装

继承

多态

集合框架

主要接口

常用实现类

集合使用示例

并发编程

线程创建

同步机制

Java 8特性

Lambda表达式

Stream API

新的日期时间API

Java 17新特性

密封类（Sealed Classes）

模式匹配（Pattern Matching）

文本块（Text Blocks）

记录类（Records）