🔥 本文由程序喵正在路上原创，CSDN首发！
💖 系列专栏：Java从入门到大牛
🌠 首发时间：2023年7月19日
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾
🌟 一以贯之的努力不得懈怠的人生

内部类
- 内部类概述
- 成员内部类（了解）
- 静态内部类（了解）
- 局部内部类（了解）
- 匿名内部类（重点）
枚举
- 认识枚举
- 枚举的常见应用场景
泛型
- 认识泛型
- 泛型类
- 泛型接口
- 泛型方法、泛型通配符、上下限
- 泛型的注意事项：擦除问题、基本数据类型问题
java.lang包下的常用API
- API概述
- Object类
- Objects
- 包装类
- StringBuilder、StringBuffer
- StringJoiner

内部类

内部类概述

什么是内部类

是类中的五大成分之一（成员变量、方法、构造器、内部类、代码块），如果一个类定义在另一个类的内部，这个类就是内部类
场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必须单独设计时，就可以把这个事物设计成内部类
```
public class Car {
	// 内部类
	public class Engine {
	}
}
```

内部类有四种形式

成员内部类、静态内部类、局部内部类、匿名内部类

成员内部类（了解）

什么是成员内部类

就是类中的一个普通成员，类似前面我们学过的普通的成员变量和成员方法

注意：JDK16 之前，成员内部类中不能定义静态成员，JDK16 开始也可以定义静态成员了

创建对象的格式

外部类名.内部类名 对象名 = new 外部类(...).new 内部类(...);
Outer.Inner in = new Outer().new Inner();

成员内部类中访问其他成员的特点

和前面学过的实例方法一样，成员内部类的实例方法中，同样可以直接访问外部类的实例成员和静态成员
可以在成员内部类的实例方法中，拿到当前外部类对象，格式是：外部类名.this

静态内部类（了解）

什么是静态内部类

有 static 修饰的内部类，属于外部类自己持有

public class Outer {
	// 静态内部类
	public static class Inner {
	}
}

创建对象的格式：

外部类名.内部类名 对象名 = new 外部类.内部类(...);
Outer.Inner in = new Outer.Inner();

静态内部类中访问外部类成员的特点

可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员

局部内部类（了解）

什么是局部内部类

局部内部类定义在方法中、代码块中、构造器等执行体中（没什么用）

匿名内部类（重点）

什么是匿名内部类

就是一种特殊的局部内部类；所谓匿名指的是程序员不需要为这个类声明名字

new 类或接口(参数值...) {
	类体(一般是方法重写);
};

new Animal() {
	@Override
	public void cry() {
	}
};

特点：匿名内部类本质就是一个子类，并会立即创建出一个子类对象
作用：用于更方便地创建一个子类对象

匿名内部类在开发中的使用场景

通常作为一个参数传输给方法

案例

需求：猫、狗参加游泳比赛

代码示例

Swimming.java

public interface Swimming {
    void swim();
}

Test.java

public class Test {
    public static void main(String[] args) {
        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("小狗游泳飞快~~");
            }
        };
        go(s1);

        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("小猫游泳也还行~~");
            }
        });

    }

    public static void go(Swimming s) {
        System.out.println("开始==============");
        s.swim();
    }
}

枚举

认识枚举

什么是枚举

枚举是一种特殊类

枚举类的格式

修饰符 enum 枚举类名 {
	名称1, 名称2, ...;
	其他成员...	
}

public enum A {
	X, Y, Z;
	...
}

注意事项

枚举类中的第一行，只能写一些合法的标识符（名称），多个名称用逗号隔开
这些名称，本质是常量，每个常量都会记住枚举类的一个对象

枚举类的特点

枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量记住的都是枚举类的一个对象
枚举类的构造器都是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象
枚举都是最终类，不可以被继承
枚举类中，从第二行开始，可以定义类的其他各种成员
编辑器为枚举类新增了几个方法，并且枚举类都是继承：java.lang.Enum 类的，从 enum 类也会继承到一些方法

枚举的常见应用场景

用来表示一组信息，然后作为参数进行传输

选择定义一个一个的常量来表示一组信息，并作为参数传输，参数值不受约束
选择定义枚举表示一组信息，并作为参数传输。代码可读性好，参数值得到了约束，对使用者更友好

泛型

认识泛型

什么是泛型

定义类、接口和方法时，同时声明了一个或多个类型变量（如：<E>），称为泛型类、泛型接口或泛型方法，它们统称为泛型
```
public class ArrayList<E> {
	...
}
```
作用：泛型提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力！这样可以避免强制类型转换及其可能出现的异常
泛型的本质：把具体的数据类型作为参数传给类型变量

泛型类

修饰符 class 类名<类型变量, 类型变量, ...> {
	...
}

public class ArrayList<E> {
	...
}

注意：类型变量建议用大写的英文字母，常见的有：E、T、K、V 等

泛型接口

修饰符 interface 类名<类型变量, 类型变量, ...> {
	...
}

public interface A<E> {
	...
}

注意：类型变量建议用大写的英文字母，常见的有：E、T、K、V 等

泛型方法、泛型通配符、上下限

泛型方法

修饰符 <类型变量, 类型变量, ...> 返回值类型 方法名(形参列表) {
	...
}

public static <T> void test(T t) {
	...
}

通配符

就是 “?”，可以在 “使用泛型” 的时候代表一切类型；E T K V 是在定义泛型的时候使用

泛型的上下限：

泛型上限：? extends Car：？能接收的必须是 Car 或者其子类
泛型下限：? super Car：？能接收的必须是 Car 或者其父类

简单应用

public class Car {
}

public class BENZ extends Car{
}

public class BMW extends Car{
}

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 目标：掌握泛型方法的定义和使用。
        String rs = test("java");
        System.out.println(rs);

        Dog d = test(new Dog());
        System.out.println(d);

        // 需求：所有的汽车可以一起参加比赛。
        ArrayList<Car> cars = new ArrayList<>();
        cars.add(new BMW());
        cars.add(new BENZ());
        go(cars);

        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        go(bmws);

        ArrayList<BENZ> benzs = new ArrayList<>();
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        go(benzs);
    }

    // ? 通配符，在使用泛型的时候可以代表一切类型   ? extends Car(上限)   ? super Car(下限)
    public static void go(ArrayList<? extends Car> cars){

    }

    public static <T extends Car> void go1(ArrayList<T> cars){

    }

    // 泛型方法
    public static <T> T test(T t){
        return t;
    }
}

泛型的注意事项：擦除问题、基本数据类型问题

泛型的擦除问题和注意事项

泛型是工作在编译阶段的，一旦程序编译成 class 文件，class 文件中就不存在泛型了，这就是泛型擦除
泛型不支持基本数据类型，只能支持对象类型（引用数据类型）

java.lang包下的常用API

API概述

什么是API

API（Application Programming Interface）：应用程序编程接口
就是 java 帮我们已经写好一些程序，如：类、方法等，我们直接拿过来用就可以解决一些问题

常用API
在这里插入图片描述

Object类

Object类的作用

Object 类是 java 中所有类的祖宗类，因此，java 中所有类的对象都可以直接使用 Object 类中提供的一些方法

Object类的常见方法

方法名	说明
`public String toString()`	返回对象的字符串表示形式
`public boolean equals(Object o)`	判断两个对象是否相等
`protected Object clone()`	对象克隆

toString 存在的意义：为了被子类重写，以便返回对象具体的内容

equals 存在的意义：直接比较两个对象的地址是否相同完全可以用 “==” 替代 equals，equals 存在的意义就是为了被子类重写，以便子类自己来定制比较规则（比如比较对象内容）

clone 的作用：当某个对象调用这个方法时，这个方法会复制一个一模一样的新对象返回

什么是浅克隆

拷贝出的新对象，与原对象中的数据一模一样（引用类型拷贝的只是地址）

什么是深克隆

对象中基本类型的数据直接拷贝
对象中的字符串数据拷贝的还是地址
对象中还包含的其他对象，不会拷贝地址，会创建新对象

Objects

什么是Objects

Objects 是一个工具类，提供了很多操作对象的静态方法给我们使用，使用其静态方法更安全

Objects类的常见方法

方法名	说明
`public static boolean equals(Object a, Object b)`	先做非空判断，再比较两个对象
`public static boolean isNull(Object obj)`	判断对象是否为 null，为 null 则返回 true，反之
`public static boolean nonNull(Object obj)`	判断对象是否不为 null，不为 null 则返回 true，反之

包装类

什么是包装类

包装类就是把基本类型的数据包装成对象

基本数据类型	对应的包装类（引用数据类型）
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

基本类型的数据包装成对象的方案：public static Integer valueOf(int i)

自动装箱：基本数据类型可以自动转换为包装类型

自动拆箱：包装类型可以自动转换为基本数据类型

包装类的其他常见操作

可以把基本类型的数据转换成字符串类型

public static String toString(double d)
public String toString()

可以把字符串类型的数值转换成数值本身对应的数据类型

public static int parseInt(String s)
public static Integer valueOf(String s)

StringBuilder、StringBuffer

什么是StringBuilder

StringBuilder 代表可变字符串对象，相当于是一个容器，它里面装的字符串是可以改变的，就是用来操作字符串的
好处：StringBuilder 比 String 更适合做字符串的修改操作，效率会更高，代码也会更简洁

构造器	说明
`public StringBuilder()`	创建一个空白的可变的字符串对象，不包含任何内容
`public StringBuilder(String str)`	创建一个指定字符串内容的可变字符串对象

方法名称	说明
`public StringBuilder append(任意类型)`	添加数据并返回 StringBuilder 对象本身
`public StringBuilder reverse()`	将对象的内容反转
`public int length()`	返回对象内容长度
`public String toString()`	通过 toString() 就可以实现把 StringBuilder 转换为 String

为啥操作字符串建议使用StringBuilder，而不用String?

public class Test {
	public static void main(String[] args) {
		String s = "";
		for (int i = 0; i < 1000000; i++) {
			s = s + "abc";	// 很慢
		}
		System.out.println(s);
	}
}

public class Test {
	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < 1000000; i++) {
			sb.append("abc");	// 很快
		}
		System.out.println(s);
	}
}

对于字符串相关的操作，如频繁的拼接、修改等，建议用 StringBulider，效率更高
注意：如果操作字符串较少，或者不需要操作，以及定义字符串变量，还是建议用 String

StringBuilder与StringBuffer

StringBuffer 的用法与 StringBuilder 是一模一样的
但 StringBuilder 是线程不安全的，StringBuffer 是线程安全的

StringJoiner

什么是StringJoiner

JDK8 开始才有的，跟 StringBuilder 一样，也是用来操作字符串的，也可以看成是一个容器，创建之后里面的内容是可变的
好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码会更简洁

构造器	说明
`public StringJoiner(间隔符号)`	创建一个 StringJoiner 对象，指定拼接时的间隔符号
`public StringJoiner(间隔符号, 开始符号, 结束符号)`	创建一个 StringJoiner 对象，指定拼接时的间隔符号、开始符号和结束符号

方法名称	说明
`public StringJoiner add(添加的内容)`	添加数据，并返回对象本身
`public int length()`	返回长度（字符出现的个数）
`public String toString()`	返回一个字符串（该字符串就是拼接之后的结果）