Java基础知识宝典(三)-只提供相关操作-供勾勒回忆-建议收藏（持续更新，一直到spring、springboot、mybatis、redis、mysql、消息队列、netty、微服务等等知识完结）

前言

本笔记旨在系统整理 Java 语法 中的重要知识点，涵盖各个方面的核心内容，从最原始的基础知识 到 -> 进阶API 到-> 框架API到->数据库API 到->中间件API到-> GitAPI``到-> 微服务 Linux API到->项目上线以及云服务API 。
通过表格与代码示例相结合的方式，帮助你快速查阅与理解常见的语法与用法。免去遗忘之苦。

只提供相关操作-供勾勒回忆-建议收藏（持续更新，一直到spring、springboot、mybatis、redis、mysql、消息队列、netty、微服务等等知识完结）

本文档适合作为 Java 速查手册，也可作为复习与面试准备的参考资料。 建议收藏。 左侧有目录

U14 ~ 抽象类

一、定义与命名建议

二、抽象类内部主要特征

三、使用规则

四、示例（完整代码）

下面示例展示一个抽象类 AbstractPlayer，含抽象方法 play() 和普通方法 sleep()；两个具体子类 BasketballPlayer / FootballPlayer 实现 play()；Demo 演示如何使用。

// 抽象基类
public abstract class AbstractPlayer {
	int age = 18;
	
    // 抽象方法：子类必须实现
    abstract void play();

    // 普通方法：子类可以直接继承使用
    public void sleep() {
        System.out.println("就算"+age+"岁运动员也要休息，而不是挑战极限。");
    }
}

// 具体子类：长跑运动员
class RunningPlayer extends AbstractPlayer {
    @Override
    void play() {
        System.out.println("开跑开跑 1万米！");
    }
}

// 具体子类：足球运动员
class FootballPlayer extends AbstractPlayer {
    @Override
    void play() {
        System.out.println("进攻 破门 守门。");
    }
}

// 测试类：展示创建子类实例并调用方法
public class Demo {
    public static void main(String[] args) {
        AbstractPlayer p1 = new RunningPlayer ();
        p1.play();   // 输出：开跑开跑 1万米！。
        p1.sleep();  // 输出：就算18岁运动员也要休息，而不是挑战极限。

        AbstractPlayer p2 = new FootballPlayer();
        p2.play();   // 输出：进攻 破门 守门。
        p2.sleep();  // 输出：就算18岁运动员也要休息，而不是挑战极限。
    }
}

U15 ~ 接口（重中之重： 一个项目 不可能离开接口）

1. 接口定义核心要点

2. 接口的核心作用

3. 接口的三种常用设计模式

4. 抽象类与接口的区别

实例展示（形状接口+圆规类和矩形类）

// 定义一个形状接口
public interface Shape {
    // 常量 - 隐式为public static final
    String UNIT = "厘米";
    
    // 抽象方法 - 隐式为public abstract
    double calculateArea();  // 计算面积
    double calculatePerimeter();  // 计算周长
    
    // 默认方法 (Java 8+)
    default void printInfo() {
        System.out.println("这是一个形状，单位：" + UNIT);
    }
    
    // 静态方法 (Java 8+)
    static void printShapeType(Shape shape) {
        System.out.println("形状类型：" + shape.getClass().getSimpleName());
    }
}
--------------------------------------
// 实现Shape接口的圆形类
public class Circle implements Shape {
    private double radius;  // 半径
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    // 实现接口的抽象方法
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
    
    // 可以重写默认方法
    @Override
    public void printInfo() {
        System.out.println("这是一个圆形，半径：" + radius + UNIT);
    }
}
-------------------------------------------
// 实现Shape接口的矩形类
public class Rectangle implements Shape {
    private double length;  // 长度
    private double width;   // 宽度
    
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    
    // 实现接口的抽象方法
    @Override
    public double calculateArea() {
        return length * width;
    }
    
    @Override
    public double calculatePerimeter() {
        return 2 * (length + width);
    }
}
-------------------------
// 测试类
public class InterfaceDemo {
    public static void main(String[] args) {
        // 接口不能直接实例化，只能通过实现类实例化
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);
        
        // 调用实现的方法
        System.out.println("圆形面积：" + circle.calculateArea());
        System.out.println("矩形周长：" + rectangle.calculatePerimeter());
        
        // 调用默认方法
        circle.printInfo();
        rectangle.printInfo();
        
        // 调用静态方法
        Shape.printShapeType(circle);
        Shape.printShapeType(rectangle);
    }
}

U16 ~四种内部类(匿名内部类用的比较多)

U17 ~ Java 面向对象三大特性

一、封装

示例：封装与校验

public class Person {
    private String name;
    private int age;

    public Person(String name, int age){
        this.name = name;
        setAge(age); // 通过 setter 统一校验/处理
    }

    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 || age > 150) {
            throw new IllegalArgumentException("年龄不合法");
        }
        this.age = age;
    }
}

二、继承

示例：Animal 继承

class Animal {
    public void eat(){ System.out.println("动物吃"); }
    public void sayHello(){ System.out.println("hello"); }
}

class Dog extends Animal {
    @Override
    public void eat(){ System.out.println("狗吃骨头"); }
    public void bark(){ System.out.println("汪汪"); }
}

class Cat extends Animal {
    @Override
    public void eat(){ System.out.println("猫吃鱼"); }
    public void meow(){ System.out.println("喵喵"); }
}

三、多态

示例：多态（数组遍历）

Animal[] animals = { new Animal(), new Dog(), new Cat() };
for (Animal a : animals) {
    a.eat(); // 根据运行时对象类型执行不同实现（Animal/Dog/Cat）
}

向上转型 / 向下转型

Animal a = new Dog(); // 向上转型（隐式）
a.eat(); // 调用 Dog 的 eat()

// 向下转型（需谨慎，可能 ClassCastException）
if (a instanceof Dog) {
    Dog d = (Dog) a;
    d.bark();
}

四、综合示例（封装 + 继承 + 多态）

// 封装：Person 有私有字段和受控 setter
class Person {
    private String name;
    private int age;
    public Person(String name, int age){ setName(name); setAge(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) throw new IllegalArgumentException("age<0");
        this.age = age;
    }
}

// 继承：Employee 扩展 Person
class Employee extends Person {
    public Employee(String name, int age){ super(name, age); }
    public void work(){ System.out.println(getName() + " is working"); }
}

// 多态：通过父类型引用调用子类行为（需方法在父类声明并被重写）
class Animal { public void speak(){ System.out.println("动物叫"); } }
class Dog extends Animal { @Override public void speak(){ System.out.println("汪"); } }
class Cat extends Animal { @Override public void speak(){ System.out.println("喵"); } }

public class Demo {
    public static void main(String[] args){
        // 封装使用
        Person p = new Person("Alice", 30);
        System.out.println(p.getName());

        // 继承/多态
        Animal[] as = { new Animal(), new Dog(), new Cat() };
        for (Animal a : as) a.speak(); // 动态绑定选择实际实现
    }
}

U18 ~ Java注解

Java注解核心知识总结（含创建与使用）

1. 注解基础概念

2. 注解生命周期（RetentionPolicy枚举）

3. 注解装饰目标（ElementType枚举）

4. 自定义注解步骤与说明

对应代码展示

如下1：定义自定义注解JsonField

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 指定注解生命周期为运行时（RUNTIME）
@Retention(RetentionPolicy.RUNTIME)
// 指定注解仅用于字段（FIELD）
@Target(ElementType.FIELD)
public @interface JsonField {
    // 定义注解参数，参数名为value，默认值为空字符串
    String value() default "";
}

如下 2：在Writer类中使用JsonField注解

public class Writer {
    // 无@JsonField注解，不参与JSON序列化
    private int age;

    // 显式指定@JsonField参数值为"writerName"，序列化后key为"writerName"
    @JsonField("writerName")
    private String name;

    // 使用@JsonField默认值，序列化后key为字段名"bookName"
    @JsonField
    private String bookName;

    // 构造方法：初始化字段值
    public Writer(int age, String name, String bookName) {
        this.age = age;
        this.name = name;
        this.bookName = bookName;
    }

    // getter/setter方法（需手动补充，用于字段值访问）
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getBookName() { return bookName; }
    public void setBookName(String bookName) { this.bookName = bookName; }

    // toString方法：常规对象打印（非序列化逻辑）
    @Override
    public String toString() {
        return "Writer{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", bookName='" + bookName + '\'' +
                '}';
    }
}

如下 3：实现注解逻辑（JsonSerializer序列化类）

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class JsonSerializer {
    // 核心方法：将对象中带@JsonField的字段序列化为JSON字符串
    public static String serialize(Object object) throws IllegalAccessException {
        // 获取对象的Class对象，用于反射操作
        Class<?> objectClass = object.getClass();
        // 存储JSON键值对：key（注解参数/字段名）、value（字段值）
        Map<String, String> jsonElements = new HashMap<>();

        // 遍历对象所有声明字段（包括private字段）
        for (Field field : objectClass.getDeclaredFields()) {
            // 突破private权限限制，允许反射访问字段值
            field.setAccessible(true);
            // 判断字段是否带有@JsonField注解
            if (field.isAnnotationPresent(JsonField.class)) {
                // 获取JSON的key（调用工具方法处理注解参数与字段名）
                String jsonKey = getSerializedKey(field);
                // 获取字段的实际值（强转为String，此处假设字段为字符串类型）
                String fieldValue = (String) field.get(object);
                // 将键值对存入map
                jsonElements.put(jsonKey, fieldValue);
            }
        }

        // 将map转换为标准JSON格式字符串
        return toJsonString(jsonElements);
    }

    // 工具方法：处理JSON的key——注解有值则用注解值，无值则用字段名
    private static String getSerializedKey(Field field) {
        // 获取字段上的@JsonField注解实例
        JsonField jsonField = field.getAnnotation(JsonField.class);
        // 读取注解的value参数值
        String annotationValue = jsonField.value();
        // 注解值为空则返回字段名，否则返回注解值
        return annotationValue.isEmpty() ? field.getName() : annotationValue;
    }

    // 工具方法：将map转换为标准JSON字符串（使用Stream流处理）
    private static String toJsonString(Map<String, String> jsonMap) {
        // 遍历map条目，转换为"key":"value"格式字符串
        String jsonEntries = jsonMap.entrySet()
                .stream()
                .map(entry -> "\"" + entry.getKey() + "\":\"" + entry.getValue() + "\"")
                .collect(Collectors.joining(",")); // 用逗号连接所有条目
        // 包裹大括号，形成JSON对象格式
        return "{" + jsonEntries + "}";
    }
}

如下 4：测试注解效果（JsonFieldTest测试类）

public class JsonFieldTest {
    public static void main(String[] args) {
        // 1. 实例化Writer对象，传入字段值
        Writer writer = new Writer(18, "沉默王二", "Web全栈开发进阶之路");
        
        // 2. 调用序列化方法，验证注解效果
        try {
            String jsonResult = JsonSerializer.serialize(writer);
            // 3. 打印序列化结果（预期：age无注解不输出，name映射为writerName，bookName用字段名）
            System.out.println(jsonResult); 
            // 实际输出：{"bookName":"Web全栈开发进阶之路","writerName":"沉默王二"}
        } catch (IllegalAccessException e) {
            // 捕获反射权限异常并打印
            e.printStackTrace();
        }
    }
}

U19 ~ Java 枚举

一、枚举定义与基础语法

public enum Color {
    RED,
    GREEN,
    BLUE
}

二、有参枚举（带字段与构造器）

public enum PlayerType {
    TENNIS("网球"),
    FOOTBALL("足球"),
    BASKETBALL("篮球");

    private final String name;

    PlayerType(String name) { this.name = name; }

    public String getName() { return name; }
}

三、枚举集合：EnumSet 与 EnumMap

EnumSet<PlayerType> all = EnumSet.allOf(PlayerType.class);
EnumSet<PlayerType> none = EnumSet.noneOf(PlayerType.class);

EnumMap<PlayerType, String> map = new EnumMap<>(PlayerType.class);
map.put(PlayerType.BASKETBALL, "篮球运动员");
System.out.println(map.get(PlayerType.BASKETBALL));

四、使用枚举实现单例（推荐）

public enum AppConfig {
    INSTANCE;

    private int value;

    public int getValue() { return value; }
    public void setValue(int v) { this.value = v; }

    public void doSomething() {
        System.out.println("执行单例方法");
    }
}

// 使用
AppConfig.INSTANCE.setValue(10);
AppConfig.INSTANCE.doSomething();

五、常用 API 与操作

for (PlayerType p : PlayerType.values()) {
    System.out.println(p + " => " + p.getName());
}

PlayerType t = PlayerType.valueOf("TENNIS");

switch (t) {
    case TENNIS: System.out.println("网球"); break;
    case FOOTBALL: System.out.println("足球"); break;
    default: System.out.println("其他");
}

27届双非硕士持续学习 ！ 每日更新！
建议收藏 – 持续更新中…