Java从入门到精通（五）· 内部类，枚举，泛型
Java从入门到精通（五）· 内部类，枚举，泛型
一 内部类
1.概述
简单来说，如果一个类定义在另一个类的内部，这个类就是内部类。
使用场景：当一个类的内部，包含了一个完整的事务，且这个事务没有单独设计的必要时，就可以把这个事务设计成内部类。
2.成员内部类
成员内部类就是类中的一个普通成员，类似普通的成员变量，或成员方法。
public class Outer {
private String name;
public class Inner{
public void getName(){
//内部类可以直接访问外部类的成员变量
System.out.println(name);
System.out.println("内部类可以直接访问外部类的成员变量");
}
}
}
成员内部类创建对象时，需要先创建外部类的对象。因为成员内部类包含在外部类里。
Outer.Inner inner=new Outer().new Inner();
inner.getName();
注意：从JDK16开始，内部类中才可以创建静态成员
3.静态内部类
静态内部类，即有static修饰的内部类，属于外部类自己持有。
@Data
public class Outer {
private String name;
private Inner inner;
public static class Inner{
public void getName(){
Outer outer=new Outer();
System.out.println(outer.getName());
System.out.println("静态内部类中访问外部类对象，需要创建对象");
}
}
}
以下是静态内部类创建对象的语法：
Outer outer=new Outer();
Outer.Inner inner=new Outer.Inner();
outer.setInner(inner);
注意：静态内部类可以直接访问外部类的静态成员，但是无法直接访问外部类的实例成员
4.匿名内部类
匿名内部类是一种特殊的局部内部类，所谓匿名是指程序员不需要为这个类声明类名。
new 类或接口(参数值...){
类体（一般是方法重写）
}
以下为匿名内部类示例：
创建一个接口，声明两个方法
public interface C {
String getName();
void showInfo();
}
在调用接口时实现接口中的方法
public static void main(String[] args) {
C c=new C() {
@Override
public String getName() {
return "shawn";
}
@Override
public void showInfo() {
System.out.println("这是匿名内部类");
}
};
c.getName();
c.showInfo();
}
以下是匿名内部类编译后的class文件，可以看出，它继承了接口C，实现了C中的两个方法
匿名类的核心功能是简化代码。当匿名类中只有一个函数需要实现时，可以省略多余代码。利用lambda表达式达到匿名类的效果。
test(new D() {
@Override
public void showInfo() {
System.out.println("这是简化前的代码");
}
});
test(() -> System.out.println("这是简化后的代码"));
二 枚举（Enum）
1.枚举概述
枚举是一种特殊的类，可以理解为，枚举在本质上是一种类。
枚举其实就是将某个类的几个常用对象都罗列出来，方便后期在项目中使用。
注意：枚举罗列出来的是该枚举的对象。
public enum AEnum {
成员1,成员2,
//.其他成员
}
枚举中的其他成员，包含构造器，成员方法，成员变量
- 枚举类的构造器都是私有的（默认且只能私有），因此枚举类对外不能创建对象
- 枚举都是最终类，不可以被继承
- 枚举类中，从第二行开始，可以定义类的其他各种成员
- 编译器为枚举类新增了几个方法，并且枚举都是集成自
java.lang.Enum类的。
抽象枚举罗列对象：
1.创建抽象方法
2.使用枚举对象的构造函数实现构造方法
public enum BEnum {
X(){
@Override
public void go() {
System.out.println("抽象枚举罗列对象-X对象");
}
},
Y(){
@Override
public void go() {
System.out.println("抽象枚举罗列对象-Y对象");
}
};
public abstract void go();
}
2.枚举的使用
一般情况下，枚举被用在列举常用类型的实例上。以下是一个简单示例：
public enum CEnum {
是(1),否(2),其他(3);
public Integer getValue() {
return value;
}
Integer value;
CEnum(Integer num){
this.value=num;
}
}
想要获取枚举对象的具体值，则可以使用以下写法：
Integer value = CEnum.是.getValue();
System.out.println(value);
以下是枚举的常见使用场景
public static void main(String[] args) {
check(CEnum.是);
}
static void check(CEnum c){
switch (c){
case 是:
System.out.println("OK");
case 否:
System.out.println("fail");
case 其他:
System.out.println("haha");
default:
System.out.println("找不到");
}
}
三 泛型
在定义类，接口，方法时，同时声明了一个类型变量，这种称之为泛型类，泛型接口，泛型方法，一般将他们统称为泛型。
声明语法：
[访问修饰符] [类/接口/方法]<E>
泛型的最基本的作用：在编译阶段约束了所能操作的数据类型，并自动进行检查，避免了强制类型转换以及其可能出现的问题。
泛型的本质：把具体的数据类型作为参数传递给类型变量
1.泛型类
以下是一个泛型类的简单示例，模拟了ArrayList存取元素的基本过程：
public class MyArrayList<E> {
private Object[] arr=new Object[10];
private Integer size=0;
//定义一个参数类型为泛型的方法
public Boolean add(E e){
if(size<arr.length){
arr[size++]=e;
return true;
}else{
return false;
}
}
//定义一个返回值为泛型的方法
public E getInfo(Integer index){
if(index>=0 && index<arr.length){
return (E) arr[index];
}else{
return null;
}
}
}
以下是含有两个泛型类型的泛型类：
public class MyClassTwo<E,K> {
public Integer get(E e,K k){
System.out.println("这里使用了两个泛型变量");
return 1;
}
}
以下是一个限制了泛型类型必须是某一个类或该类的子类的限定：
public class Teacher<E extends People> {
}
2.泛型接口
泛型接口与泛型类基本相似，实现该接口的类需要按照接口约定
public interface F<E> {
String getName(E e);
E getObj(Integer id);
}
3.泛型方法
有方法自己申明类型变量的方法，称之为泛型方法。
以下是泛型方法的基本语法及示例说明：
修饰符 <类型变量1，类型变量2,...> 返回值类型 方法名（参数列表...）{
}
public static <T> T getName(T t){
return t;
}
如果参数中传递了泛型类型，则可以使用通配符（？）来接收。
// ArrayList 是已经定义好的类型，我们在使用是可以使用？表示能接收一些类型的ArrayList集合
public static void getName2(ArrayList<?> name){
}
4.泛型的上下限
- 上限：? extends ClassName：能接受的类必须是 ClassName 或它的子类
- 下限：? superClassName：能接受的类必须是 ClassName 或它的父类
5.泛型擦除和基本数据类型的问题
- 泛型是工作在编译阶段的，一旦程序编译成class文件，class中就不存在泛型类型了。这叫做泛型擦除
- 泛型类型不支持基本数据类型，只支持引用类型，使用基本类型时需要换成对应的包装类