匿名内部类（重点），枚举，泛型，

一，匿名内部类

1，本质是一个子类，并会立即创建出一个子类对象

作用：可以更方便的创建出一个子类对象

2，写法：

new 类或接口（参数值---）{

类体（一般是方法重写）

}；如：

Animal a=new Animal(){
            @Override
            public void cry() {
                System.out.println("猫喵喵喵的叫---");
            }
        };
         a.cry();

3.应用场景

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

public class Test2 {
    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("狗🏊‍飞快~~~~");
            }
        });
    }

    // 设计一个方法，可以接收swimming接口的一切实现类对象进来参加游泳比赛。
    public static void go(Swimming s){
        System.out.println("开始-----------------------");
        s.swim();
    }
}

// 猫和狗都要参加游泳比赛
interface Swimming{
    void swim();
}

二，枚举

1，是一种特殊类

2，格式

修饰符 enum 枚举类名{

名称1，名称2，······；

其他成员···

}

3，特点：

。枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量记住的都是枚举类的一个对象

。枚举类的构造器都是私有的，不能对外创建对象

。枚举类提供了一些额外的API

。枚举都是最终类，不可以被继承

4，使用枚举类实现单例设计模式

public enum C{

X；      //单例

}

5，枚举的应用场景：做信息标志和分类

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

三，泛型（非常重要）

定义类，接口，方法时，同时声明了一个或者多个类型变量（如<E>）,称为泛型类，泛型接口，泛型方法，他们统称为泛型

import java.util.ArrayList;

public class Test1 {
    public static void main(String[] args) {
        // 目标：认识泛型
        ArrayList list = new ArrayList();
        list.add("java1");
        list.add("java2");
        list.add("java3");
        // list.add(new Cat());

        for (int i = 0; i < list.size(); i++) {
            String e = (String) list.get(i);
            System.out.println(e);
        }

        System.out.println("-----------------------------------");
//        ArrayList<String> list1 = new ArrayList<String>();
        ArrayList<String> list1 = new ArrayList<>(); // JDK 1.7开始，后面的数据类型可以不声明
        list1.add("java1");
        list1.add("java2");
        list1.add("java3");
        // list1.add(new Cat());

        for (int i = 0; i < list1.size(); i++) {
            String e = list1.get(i);
            System.out.println(e);
        }

    }
}

class Cat{}

1，作用：泛型提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力！这样可以避免强制类型转换，及其可能出现的异常

2，泛型的本质：

把具体数据类型作为参数传给类型变量

注意类型变量建议用大写的英文字母，常用E,T,K,V,,,,,,

泛型类：

修饰符 class 类名<类型变量，类型变量···>{

}

 泛型类
public class MyArrayList<E> {
    private Object[] arr = new Object[10];
    private int size; // 记录当前位置的

    public boolean add(E e){
        arr[size++] = e;
        return true;
    }

    public E get(int index){
        return (E) arr[index];
    }
}

泛型接口：

修饰符 interface 接口名<类型变量，类型变量，···>{

}

// 泛型接口
public interface Data<T> {
//public interface Data<T extends Animal> {
    void add(T t);
    ArrayList<T> getByName(String name);
}

泛型方法：

修饰符<类型变量，类型变量，···>返回值类型  方法名（形参列表）{

}

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

 // ? 通配符，在使用泛型的时候可以代表一切类型   ? extends Car(上限即能接收的必须是car或car的子类)   ? super Car(下限即能接收的的只能是car或car的父类)
    public static void go(ArrayList<? extends Car> cars){

    }

注意事项：

1，泛型是工作在编译阶段的，一旦程序编译成class文件，class文件中就不存在泛型了，这就是泛型擦除

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

//        ArrayList<int> list1 = new ArrayList<>();
//        ArrayList<double> list2 = new ArrayList<>();
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(12);

        ArrayList<Double> list2 = new ArrayList<>();
        list2.add(23.3);