【Java学习】内部类&泛型

一、内部类

内部类是类中的五大成分之一（成员变量、方法、构造器、代码块、内部类）；

如果一个类定义在另一个类的内部，这个类就是内部类；

场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。

内部类分为四种

成员内部类：位于一个类里面成员位置的类

静态内部类：使用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文件中就不存在泛型了，这就是泛型擦除。

泛型不支持基本数据类型，只能支持对象类型（引用数据类型）。