基本#

特点概述：

封装：封装是将对象的属性和行为封装起来，不需要让外界知道具体实现细节；

继承：继承是可以在无需重新编写原有类的情况下，对原有类的功能进行扩展；

多态：多态指的是在一个类中定义的属性和功能被其他类继承后，当把子类对象直接赋值给父类引用变量时，相同引用类型的变量调用同一个方法所呈现出的多种不同行为特性。 技术平台：Java EE、Java SE、Java ME

Java组成：JDK > JRE > JVM

• JDK = JRE + 开发工具集(javac 编译器、javadoc、jdb 调试器等)；开发工具包（用于开发）
• JRE = JVM + Java标准类库；运行时环境（用于运行）
• JVM = 虚拟机（实际执行代码） Java执行过程：编写代码、编译、加载、验证、执行

javac 命令把 .java 源文件编译成 .class 字节码文件,然后用 java 命令启动 JVM（Java虚拟机），JVM 通过类加载器加载 .class 文件，再由解释器或 JIT 编译器将字节码转为机器码执行。 数据类型：基本数据类型、引用数据类型（类/接口/数组/枚举） JVM（Java Virtual Machine）、JDK（Java Development Kit）、JRE（Java Runtime Environment）

命名规范#

类：单词首字母大写。

变量/方法：从第二个单词起大写。

包：全小写。

类中方法外定义的变量称为字段（Field）

构造方法#

一次性完成字段初始化

方法名和类名相同、无返回值类型声明

方法中不能用return 返回值，但可单独写return语句来作为方法的结束。

没有自定义构造方法时，JVM提供一个默认的无参构造方法

只有实例类才有构造器，接口和抽象类没有

1
Class(参数列表){//方法名和类名相同
2
    this.属性=参数;
3
}//无返回值
4

5
Class name=new Class(参数列表);

static#

初始化顺序： 父类静态块 → 子类静态块 → 父类实例变量/构造块 → 父类构造器 → 子类实例变量/构造块 → 子类构造器。（级别相同按先后顺序）

封装#

实现：用 private 修饰成员变量，通过 public 的 getter/setter 方法访问。

目的：隐藏内部实现，只暴露必要接口，提高安全性和可维护性。

访问控制

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

继承#

单继承：Java类只支持单继承（一个子类只能有一个直接父类），但可通过接口实现多继承效果。

关键字：用 extends 实现继承，如 class Child extends Parent。

继承内容：

• 子类继承父类的 非私有成员（字段、方法）。
• 构造器 不被继承，但子类构造器必须（隐式或显式）调用父类构造器。
• private 成员虽不可见，但依然被继承。

父类无构造方法？

• 若父类未定义任何构造方法，编译器会自动提供默认无参构造方法，子类可正常继承（隐式调用 super()）。
• 若父类显式定义了任意构造方法（包括有参），则不再生成默认无参构造，此时子类必须显式调用 super(...)，否则编译报错。

方法重写（Override）

• 可重写父类非 private、非 final、非 static 的方法。
• 要求：方法名、参数列表、返回类型（协变）一致；访问权限不能更严格。

this 关键字

• 变量this.attribute
• 方法this.method()
• 构造方法this()
• 本类型 this

super 关键字

• super()：调用父类构造器，必须在子类构造器第一行。
• super.method() / super.field：访问父类成员。
• super() 和 this() 都必须是构造方法中的第一条语句，所以不能同时出现在同一个构造方法中。
• 父类先于子类实例化

final 限制

• 修饰类：不能被继承
• 修饰方法：不能被子类重写。
• 修饰的变量（成员变量和局部变量）是常量，只能赋值一次

Object 类：

• 所有类默认继承自 java.lang.Object
• 定义类时，未指定他的父类默认继承Object类
• toString() 输出实例名自动调用该方法

1
public class Object {
2
    public String toString() {
3
        // 默认获取运行时的类的对象的类名@十六进制哈希码
4
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
5
    }
6
}

多态#

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
}

1
  public Car(String brand, String model, int year, String color) {
2
        this.brand = brand;
3
        this.model = model;
4
        this.year = year;
5
        this.color = color;
6
    }
7
  // 1
8
    public Car(String brand, String model, int year) {
9
        this(brand, model, year, "白色");
10
    }
11
  // 2
12
    public Car(String brand, String model) {
13
        this(brand, model, 2023);
14
    }
15
  // 3
16
    public Car(String brand) {
17
        this(brand, "未知型号");
18
    }
19
  // 4
20
  public Car() {
21
        this("未知品牌");
22
    }
23
//  调用构造函数4 -> 调用3 -> 调用2 -> 调用1 -> Car("未知品牌","未知型号",2023,"白色")
24
//  简洁代码量的构造传递
25
//即使我给定 形参数最少的构造方法 去实例化一个对象，但这个对象依然具有多个的默认属性。

抽象类#

包含

• 抽象方法 - （必须显示指定public abstract）
• 其余和普通类所包含一致 重点
• 抽象类不能被实例化，只能被继承
• 继承该抽象类必须实现抽象类的所有抽象方法
• 抽象类不一定包含抽象方法
• 可以包含成员变量、常量、构造方法(供子类调用)

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

抽象类的意义是：让子类一定要干某件事（强制性规范）

接口#

相关子类和不相关子类之间抽象出来都具有的行为（约束）。

弥补 了JAVA只能单继承类 ，一个类可以实现多个接口

• Java 7及之前：完全抽象，只能声明常量和抽象方法
• Java 8：引入默认方法（default）和静态方法
• Java 9：引入私有方法

包含

• 常量 - (默认 public static final)
• 抽象方法 - （默认 public abstract） (除该方法，其余均为具体方法)
• 静态方法
• 默认方法
• 私有方法
• 函数式接口

重点

• 接口也不能实例化，只能被继承
• 继承该接口的子类方法必须实现接口的所有抽象方法
• 默认访问权限是 public abstract (隐式可省)
• 接口的所有非私有方法的访问控制权限 均是 public（隐式可省）
• 当一个接口是函数式接口时，只能包含一个抽象方法

抽象类实现接口时：

• 可以不实现接口里的抽象方法
• 前提是：它自己仍然是 abstract

Lambda表达式#

使用函数式接口：

• 用@FunctionalInterface注解，提醒编译器检查
• 只有1个抽象方法 定义

1
@FunctionalInterface
2
public interface A{
3
    void add(int x,int y);
4
}

使用

1
// 1.基本使用
2
(int x,int y)->{return x+y;}
3
// 2.省略类型、编译器自动识别
4
(x,y)->{return x+y;}
5
// 3. 一条语句，大括号可以省;
6
(int x,int y)->return x+y;
7
// 4.1个return，return也可以省
8
(int x,int y)-> x+y;
9
// 5.都省
10
(x,y)->x+y;

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

内部类#

#todo

String#

特点

• 不可变性（Immutability）String对象一旦创建，其值就不能被修改；所有看似修改的操作都返回新的String对象；原对象在内存中保持不变
• String是final类型(const) 一单创建内容长度不变
• StringBuffer可以进行更改

异常处理机制#

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