访问控制#

• private：只能在本类访问，不被子类继承可直接访问。
• default：同包可见。(无访问控制符)
• protected：同包或子类可见（推荐用于希望子类访问的成员）
• public：所有地方可见。
• 子类的访问权限要比父类更公开、或相同。
• private > default > protected > public

概念#

• Java多态：同一个引用，不同实现。

• 前提：继承 + 方法重写 + 父类引用指向子类对象。

• 表现：编译看左边（父类），运行看右边（实际子类）。

• 目的：提高代码扩展性和可维护性，便于统一处理不同子类。

• 静态多态（编译时多态）：

  • 通过 方法重载（Overload） 实现。
  • 编译器在 编译期 根据参数类型、个数、顺序决定调用哪个方法。
  • 与继承无关，同一个类或父子类中都可重载。

• 动态多态（运行时多态）：

  • @Override 注解提示编译器要检查
  • 通过 方法重写（Override） + 父类引用指向子类对象 实现。
  • JVM 在 运行期 根据实际对象类型决定调用哪个方法。
  • 必须有继承/实现关系，且方法不能是 private/static/final。

函数重载/重写#

重写（Override）

• 指子类重新定义父类中已有的方法（方法名、参数列表、返回类型相同），以实现不同的行为。属于运行时多态。
• 子类和父类方法签名必须相同：方法名、参数列表、返回类型
• 子类访问权限不能比父类更低：可以相等或更宽松
• 父类方法：protected修饰 → 子类方法：protected或public ✓
• 父类方法：public修饰 → 子类方法：private ✗
• 不能抛出更宽泛的异常

重载（Overload）

• 指在同一个类中定义多个同名方法，但参数列表不同（参数类型、个数或顺序不同）。属于编译时多态。

• 参数列表不同体现在三个方面：参数类型不同、参数个数不同、参数顺序不同

• 返回值类型（仅返回值不同不构成重载）

• 核心原则：只看方法名和参数列表，其他都不看。 编译器通过参数列表的差异来决定调用哪个重载方法。

对象类型转换：#

• 向上转型，将父类引用 -> 子类对象。无需强制转换，此时不能通过父类变量去调子类特有的方法
• 向下转型要 强制转换 最好用 instanceof

1
Animal animal = new Dog();
2

3
animal.eat();        // ✅ 可以调用（如果Dog重写了eat，执行Dog的版本）
4
animal.bark();       // ❌ 编译错误！Animal类没有bark()方法
5

6
//需要向下转型才能调用
7
//需要类型判断：`instanceof` 可以判断一个对象是否为某个类的实例
8
if (animal instanceof Dog) {
9
    Dog dog = (Dog) animal;  // 向下转型
10
    dog.bark();              // ✅ 现在可以调用
11
}

Contains#

• 抽象方法 - （必须显示指定public abstract）
• 其余和普通类所包含一致

Specific#

• 抽象类不能被实例化，只能被继承
• 继承该抽象类必须实现抽象类的所有抽象方法
• 抽象类不一定包含抽象方法
• 可以包含成员变量、常量、构造方法(供子类调用)

抽象类 = 有部分实现的模板，需要子类补全； 普通类 = 已完成的功能，你继承它只是为了复用代码。

抽象类的意义是：

让子类一定要干某件事（强制性规范）

Specific#

• 接口也不能实例化，只能被继承

• 继承该接口的子类方法必须实现接口的所有抽象方法

• 默认访问权限是 public abstract (隐式可省)

• 接口的所有非私有方法的访问控制权限 均是 public（隐式可省）

• 当一个接口是函数式接口是，只能包含一个抽象方法

Others#

• Serializable 是 标记接口（Marker Interface）

  • 它没有任何方法

  • 只用作标记，告诉 Java “这个类可以被序列化”

  • 序列化：把对象的状态（属性值）转换成 字节流，

    • 以便：写入文件（永久保存对象状态）
    • 通过网络传输对象存入数据库等

FunctionalInterface#

一个注解，提醒编译器检查

Lambda#

只能有一个函数式接口的抽象方法供lamda表达式使用

接口上标注有@FunctionalInterface表示该接口是函数式接口，要求编译器严格检查

1
//这个抽象方法就是lambda要填的空
2
@FunctionalInterface
3
public interface A{
4
    void add(int x,int y);
5
}

1
(int x,int y)->{return x+y;} //匿名方法
2
(x,y)-> x+y;
3
//编译器自动识别数据类型;
4
//一条语句，大括号可以省;
5
//只有一条return，return也可以省

1
//搭配使用
2
A a = (x,y)-> x+20 ;//相当于声明一个匿名类，这个表达式把抽象方法的具体实现定义了，并返回一个对象引用给a
3
System.Out.println(a.add(3,4));

Functional Interface In Java#

<T> 泛型

Specific#

• 不可变性（Immutability）
  • String对象一旦创建，其值就不能被修改
  • 所有看似修改的操作都返回新的String对象
  • 原对象在内存中保持不变

String是final类型(const) 一单创建内容长度不变

StringBuffer可以进行更改

Common Methods#

StringBuffer#

1.构造#

valueOf()方法 每个原始数据类型包装类都有此方法

1
Integer num1 = Integer.valueOf(10);      // 基本类型
2
Integer num2 = Integer.valueOf("10");    // 字符串
3
Integer num3 = 10;////自动装箱 编译器会转换为 Integer.valueOf(10)

被弃用的 直接构造对象方法

1
Integer num4 = Integer(10)// 在循环中创建大量 Integer 对象时 开销特别大
2
public void processNumbers() {
3
    // ❌ 低效
4
    for (int i = 0; i < 1000; i++) {
5
        Integer num = new Integer(i);
6
    }// 创建1000个不同对象
7

8
    // ✅ 高效 - 重用缓存对象
9
    for (int i = 0; i < 1000; i++) {
10
        Integer num = Integer.valueOf(i); // 对于-128到127的值，重用缓存对象
11
    }
12
}

1
// 缓存范围内的比较
2
Integer a = Integer.valueOf(100);
3
Integer b = Integer.valueOf(100);
4
System.out.println(a == b);  // true - 同一个缓存对象
5

6
// 缓存范围外的比较
7
Integer c = Integer.valueOf(200);
8
Integer d = Integer.valueOf(200);
9
System.out.println(c == d);  // false - 不同对象（大多数情况）

实际业务中，很多数字都在缓存范围内 比如：年龄、分数、数量等

1
Integer age = 25;           // 在缓存内
2
Integer score = 85;         // 在缓存内
3
Integer quantity = 10;      // 在缓存内

2.Why？#

数据结构这些容器类，必须使用包装类

1
List<Integer> numbers = new ArrayList<>();  // ✅ 必须用Integer
2
// List<int> numbers = new ArrayList<>();   // ❌ 编译错误

泛型必须用包装类

需要null的情况下(从数据库接受null值)

3.parseXXX()#

parseXXX() 方法是把字符串转换成基本类型的实用工具。

1
String numberStr = "123";
2
int number = Integer.parseInt(numberStr);
3
System.out.println(number);
4
// 输出：123（基本类型int）

Collection#

List#

Set#

• 所有 Set 实现类支持的方法，就是 Collection 的全部方法

LinkedList#

Map#

Map.Entry<K, V>#

异常#

• 程序运行中，发生不正常的，破坏程序执行流程的事件；

类型#

• 编译型异常(checked)
• 运行时异常(unchecked)：编译器不检查，可处理；RuntimeException也是此类异常

异常类#

异常处理#

关键字

• try：放可能出错的代码
• catch：捕获特定类型的异常并处理
• finally：清理资源，一定会执行（除非 System.exit(0)）

结构

• try……catch……finally结构

• try……with……resources结构

• throws

方法不靠谱时，可以设计向上一级函数抛出异常类

格式：方法名() throws 异常类列表

• throw

手动抛出一个对象类

1
public void method() throws Exception{
2
    if(...)
3
      {....}
4
    else{
5
        throw new Exception("sth wrong here");
6
    }
7
}//这个方法可能会不符合程序设计需求，需要手动抛出一个异常，由上级函数捕获

自定义异常类#

extend异常父类即可 + throw

创建&运行#

• 创建一个新的类继承Thread，重写run()

1
MyThread thread1 = new Mythread();
2
Mythread.start();

• 创建一个新的类继承Runnable，重写run()
  • 并将该类传入Thread构造器
  • Thread构造里里有Runnable类型参数，传入继承runnable的子类调用run(),是可以的
  • run()是抽象方法,Runnable是函数式接口所以可以用Lamda简化

1
Runnable runnable = () -> System.out.println("It's a task");
2
Thread thread2 = new Thread(runnable);
3
thread2.start();

异步#

• 主线程 和 子线程 是异步执行的

1
Thread thread1 = new Thread(()->{
2
    System.out.println("thread1");
3
});
4
Thread thread2 = new Thread(()->{
5
    System.out.println("thread2");
6
});
7
    thread1.start();
8
    thread2.start();
9
    System.out.println(Thread.currentThread().getName());

join#

• join()方法用于让当前线程等待调用join()方法的线程执行完毕后再继续执行。
• 阻塞的永远是调用join的线程

1
Thread thread1 = new Thread(()->{
2
  System.out.println("thread1");
3
});
4
thread1.start();
5
System.out.println("Main thread is waiting for Thread2");
6
try{
7
    thread1.join();
8
}catch(Exception e){
9
  System.out.println(e.getMessage());
10
};
11
System.out.println("Main thread is finished");

InetAddress类#

• 用于封装一个IP地址，并提供一系列与IP地址相关的方法

• host：可以是域名、ip地址、特殊地址(localhost 127.0.0.1)

UDP#

1
//`buf`接受数据的缓冲区，`length` 读取的数据最大长度
2
public DatagramPacket(byte[] buf, int length)
3
//`offset` 在缓冲区中的偏移位置offset接收数据
4
public DatagramPacket(byte[] buf, int offset, int length)

1
//`address` 目标 IP 地址   `port` 目标端口号
2
public DatagramPacket(byte[] buf, int length, InetAddress address, int port)
3
//`offset` 在缓冲区中的偏移 `offset`位置发送数据
4
public DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)

1
//`port` 指定一个端口 用于 监听
2
new DatagramSocket(int port)

1
//系统自动分配没有被其他网络程序所使用的端口号
2
new DatagramSocket()

1
//用于计算机有多块网卡的情况，明确数据通过哪块网卡向外发送和接收哪块网卡的数据
2
new DatagramSocket(int port, InetAddress address)

含义#

​ Java JDBC（Java Database Connectivity）是一套用于连接和操作关系型数据库的 Java API。它提供了一组接口和类，使 Java 应用程序能够与各种数据库进行交互。迁移数据时，不需要大量更改代码

不同数据库的不同驱动

访问步骤#

1. 加载数据库驱动
2. 建立连接 DriverManager.getConnection()
3. 创建连接对象
4. 创建语句对象
5. 执行sql语句获取执行结果
6. 关闭连接（先开后关）

还没读完

概念#

注解（Annotation）:贴在代码上的“标签”，可以被编译器、框架或工具读取的特殊备注。

• 格式：@注解名

• 作用范围：package、class、method、field

• 访问：可以通过反射机制对这些元数据访问

内置注解#

• 包：java.lang

@SuppressWarnings参数

元注解#

包：java.lang.annotation

自定义注解#

• 1个参数，名为value，使用注解可以不给参数名
• default参数默认值：不显式声明时使用

1
@元注解
2
public @interface 注解名{
3
    //注解参数:
4
    类型 参数名() default 默认值;
5
}

概念#

• 静态语言：运行时代码能改变自身结构（Java、C、C++）

• 动态语言：运行时代码不能改变自身结构（C#、JavaScript、Python）

• 反射：程序运行期间，动态获取类的结构信息（类名、构造器、方法、字段、注解等），并对其进行操作（创建对象、调用方法、访问字段）。

• Java：通过反射机制成为准动态语言

Class#

包：java.lang.Class、java.lang.reflect

• 动态获取类的结构信息通过Class类
• Class 本身也是一个类
• Class 对象只能由系统建立对象
• 一个加载的类在 JVM 中只会有一个 Class 实例
• 一个 Class 对象对应的是一个加载到 JVM 中的一个 class 文件
• 每个类的实例都会记得自己是由哪个 Class 实例所生成
• 通过 Class 可以完整地得到一个类中的所有被加载的结构
• Class 类是 Reflection 的根源，针对任何你想动态加载、运行的类，唯有先获得相应的 Class 对象

四种方式获取：

1
// 1. 通过类名（最常用，最灵活）
2
Class<?> c1 = Class.forName("com.example.User");
3

4
// 2. 通过类.class（编译期已知）
5
Class<User> c2 = User.class;
6

7
// 3. 通过对象.getClass()
8
User u = new User();
9
Class<? extends User> c3 = u.getClass();
10

11
// 4. 包装类通过TYPE属性
12
Class c4 = Integer.TYPE;

常用方法#

获取类信息

1
c1.getName();                // 全限定名
2
c1.getSimpleName();         // 类名
3
c1.getSuperclass();         // 父类
4
c1.getInterfaces();         // 接口
5
c1.getAnnotations();        // 注解

示例

1
class User {
2
    private String name;
3

4
    private User(String name) {
5
        this.name = name;
6
    }
7

8
    private void hello() {
9
        System.out.println("Hello " + name);
10
    }
11
}
12

13
// 反射使用
14
Class<?> clazz = Class.forName("User");
15

16
// 创建对象
17
Constructor<?> con = clazz.getDeclaredConstructor(String.class);
18
con.setAccessible(true);
19
Object obj = con.newInstance("Tom");
20

21
// 调用方法
22
Method m = clazz.getDeclaredMethod("hello");
23
m.setAccessible(true);
24
m.invoke(obj);

优缺点#

1. 高度灵活，解耦严重依赖

2. 支持运行时扩展

3. 是大型框架的基础

4. 性能较低（绕过编译期优化）

5. 破坏封装性

6. 编译期无法检查错误

7. 代码可读性、可维护性下降

结论： 业务代码慎用，框架代码必用

对比#

构造方法 vs 普通方法#

1. 名字不同

   • 构造方法名必须和类名完全相同。
   • 普通方法名不能和类名相同（虽然技术上可以，但强烈不建议，且不是构造方法）。

2. 返回值类型

   • 构造方法没有返回值类型，连 void 都不能写。
   • 普通方法必须有返回值类型（包括 void）。

3. 调用时机

   • 构造方法在创建对象时自动调用（用 new 时）。
   • 普通方法需要通过对象显式调用（如 obj.method()）。

4. 作用不同

   • 构造方法用于初始化对象（比如给成员变量赋初值）。
   • 普通方法用于实现具体功能（比如计算、打印等）。

5. 能否被继承/重写

   • 构造方法不能被继承，也不能被重写（override）。
   • 普通方法可以被继承和重写。

重写 vs 重载#

1. 发生位置不同

   • 重载：发生在同一个类中。

   • 重写：发生在子类和父类之间。

2. 方法签名要求不同

   • 重载：方法名相同，但参数列表不同（参数类型、个数、顺序至少一个不同）。返回值可以不同，但不能仅靠返回值不同来重载。

   • 重写：方法名、参数列表必须完全相同。返回值类型也必须相同或是其子类型（协变返回）。

3. 访问修饰符

   • 重载：无特别限制。

   • 重写：子类方法的访问权限不能比父类更严格（比如父类是 protected，子类不能是 private）。

4. 是否涉及多态

   • 重载：属于编译时多态（静态绑定），编译器根据参数决定调用哪个方法。

   • 重写：属于运行时多态（动态绑定），JVM 在运行时根据对象实际类型决定调用哪个方法。

接口 vs 抽象类#

字节流 vs 字符流#