一、内部类
内部类是类中的五大成分之一（成员变量、方法、构造器、代码块、内部类）；
如果一个类定义在另一个类的内部，这个类就是内部类；
场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。
内部类分为四种
成员内部类：位于一个类里面成员位置的类
静态内部类：使用static修饰的成员内部类
局部内部类：在方法里面定义的类
匿名内部类[重要]：一种特殊的局部内部类
1、成员内部类
定义在一个类中成员位置的类叫做成员内部类，在内部类中也可以定义成员属性和方法
成员内部类中创建对象的格式：
示例
public class Outer {
// 成员内部类
public class Inner {
// 成员属性和方法
}
}
创建对象：
外部类名.内部类名 对象名 = new 外部类(...).new 内部类(...);
Outer.Inner in = new Outer().new Inner();
成员内部类访问其他成员的特点：
1、成员内部类中可以定义实例成员，静态成员 (注意: 静态成员从JDK16开始支持)
2、成员内部类中的实例方法中，可以直接访问外部类的实例成员，静态成员
3、如果内部类和外部类出现了重名的成员，可以通过(外部类名.this.xxx) 强行访问外部类的成员
2、静态内部类
即为用static修饰的成员内部类
public class Outer{
// 静态内部类
public static class Inner{
}
}
创建对象的格式
外部类名.内部类名 对象名 = new 外部类.内部类(…);
Outer.Inner in = new Outer.Inner();
静态内部类中访问外部类成员的特点:
可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员。
3、局部内部类
局部内部类是定义在方法中、代码块中、构造器等执行体中
格式：
class 外部类名 {
数据类型 变量名;
修饰符 返回值类型 方法名(参数列表) {
// …
class 内部类 {
// 成员变量
// 成员方法
}
}
}4、匿名内部类
一种特殊的局部内部类，是内部类的简化写法，是一个隐含了名字的内部类。
格式：
new 类名或者接口名() {
重写方法;
};
//举例子：
new Animal(){
@Override
public void cry() {
}
};
tips：从语法上来讲，这个new出来的整体其实是匿名内部类的对象
作用：更方便的创建一个子类对象(简化操作类、接口的代码)；
本质：匿名内部类本质就是一个子类，并会立即创建出一个子类对象；
tips：或者是一个接口的实现类，在new的后面必须跟它的父类或者接口
场景: 通常作为一个参数传输给方法。
举个例子，以接口为例：
interface Swim {
public abstract void swimming();
}
public class Demo {
public static void main(String[] args) {
// 使用匿名内部类
new Swim() {
@Override
public void swimming() {
System.out.println("自由泳...");
}
}.swimming();
// 接口 变量 = new 实现类(); // 多态,走子类的重写方法
Swim s2 = new Swim() {
@Override
public void swimming() {
System.out.println("蛙泳...");
}
};
s2.swimming();
}
}可以看出，接口Swim定义了一个抽象方法swimming()，匿名内部类实际上是接口的实现类，所以必须重写接口中的抽象方法。
从下往上看，创建了一个对象s2，如果是传统的方法想要调用swimming方法，首先要单独定义并命名一个Swim接口的实现类（假设名字为SwimImpl），然后用多态的写法创建s2对象：Swim s2 = new SwimImpl(); 然后再用s2.swimming() 调用方法。
很麻烦对吧？所以用匿名内部类就可以避免定义实现类，还有起名字等等过程。请看上面给出的代码里，定义匿名内部类时只需在new的后面先写上你想要创建的匿名内部类的父类或接口名，然后打一个大括号，在大括号里直接重写父类或接口中的方法即可。
再往上面看，有一个直接new Swim() 的东西，这里想要说明的是new出来的这一整块东西其实就是匿名内部类的一个对象。用我刚才举的例子中的名字来说，这一块东西便是子类（接口实现类）SwimImpl的对象，所以你可以看到在后面直接 .swimming() 来调用方法，因为他就是一个对象。
二、泛型
定义类、接口、方法时，同时声明的类型变量（如：<E>） ，称为泛型。
tips：把E想象成数学方程中的x就行。
作用：泛型提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力！这样可以避免强制类型转换，及其可能出现的异常。
本质：把具体的数据类型作为参数传给类型变量
分类：泛型类、泛型接口、泛型方法
1、泛型类
格式：
public class ArrayList<E>{
. . .
}
泛型类在声明时使用类型参数来指定类可以接受的类型，这样在使用类时可以传入具体的类型实参
举例子：
public class Demo {
public static void main(String[] args) {
//1、创建MyList对象
MyList<String> list = new MyList<>();
//2、向MyList中存放数据
list.add("丁真");
System.out.println(list.get(0));
}
}
//自定义一个泛型类, 模仿ArrayList的add和get功能，只能存放10条数据
class MyList<E> {
//1、定义一个长度为10的数组
private Object [] arr = new Object[10];
//2、定一个当前存放元素的索引位置
private int index = 0;
//方法1：添加元素
public void add (E e) {
arr[index] = e;
//索引加+1
index ++ ;
}
//方法2：根据索引查询元素并返回
public E get(int index) {
return (E) arr[index];
}
}
注意：类型变量建议用大写的英文字母，常用的有：E、T、K、V 等
2、泛型接口
泛型接口的定义与泛型类相似，只是在接口声明时使用类型参数来指定接口可以接受的类型。
格式：
public interface A<E>{
. . .
}
3、泛型方法
格式：
public static <T> void test(T t){
}
举例子：
public class Demo {
public static void main(String[] args) {
//需求: 编写一个将两个相同类型的对象放入一个集合的方法
ArrayList<String> list1 = add("hello", "world");
//将两个Teacher放入一个集合
Teacher t1 = new Teacher();
Teacher t2 = new Teacher();
ArrayList<Teacher> list2 = add(t1, t2);
//将两个Student放入一个集合
Student s1 = new Student();
Student s2 = new Student();
ArrayList<Student> list3 = add(s1, s2);
System.out.println(list3.size());
}
//泛型方法
public static <T> ArrayList<T> add(T t1,T t2) {
ArrayList<T> list = new ArrayList<>();
list.add(t1);
list.add(t2);
return list;
}
}
class Teacher {
}
class Student {
}
本例中，泛型方法add（）的类型变量为T，返回值是一个T类型的集合ArrayList<T>，参数列表是两个T类型的参数。
对于Teacher和Student两个类所创建的对象，Teacher的对象调用add()泛型方法时，传入的参数的数据类型为Teacher，那么本次调用中，add方法的所有类型变量T都变为Teacher来供其使用，Student同理。
4、通配符上下限
通配符就是 “?” ，可以在“使用泛型”的时候代表一切类型； E T K V 是在定义泛型的时候使用。
通配符上下限：
泛型上限: ? extends Car: ? 能接收的必须是Car或者其子类 。
泛型下限： ? super Car ： ? 能接收的必须是Car或者其父类。
5、泛型的擦除问题和注意事项
泛型是工作在编译阶段的，一旦程序编译成class文件，class文件中就不存在泛型了，这就是泛型擦除。
泛型不支持基本数据类型，只能支持对象类型（引用数据类型）。
标签：Java,内部,成员,class,学习,泛型,new,public From： https://blog.csdn.net/weixin_69134024/article/details/141789929