分为泛型类、泛型接口、泛型方法

//没有使用泛型 可以添加一切类型数据
ArrayList list1 = new ArrayList();
//使用了泛型 只能接受String类型的数据
//ArrayList<String> list2= new ArrayList<String>();
ArrayList<String> list2= new ArrayList<>();//jdk 1.7后后面可以不声明

泛型的原理

在声明泛型后，将<类型>传给了<E>，让这个只能接受和返回对应类型的数据。

泛型类

格式

//类型变量可以是任何字母 主要是表达一个可变参数
修饰符 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){
        //alt + enter 强制类型转换
        return (E) arr[index];
    }
}

泛型接口

（保存数据和根据索引查询数据用）

public interface Container<E>{
public void add(E item); // 添加一个E
E get(int index); // 根据索引获得某个E
E remove(int index);// 根据索引删除某个E
}

泛型方法

// 泛型方法可以在方法返回类型之前声明类型参数。
public class lister {
    public static void main(String[] args) {
        String[] Stringlist={"1","b","e"};
        Integer[] intlist={1,2,3};
        printArray(Stringlist);
        printArray(intlist);
    }
    public static <E> void printArray(E[] list){
        for(E e : list){
            System.out.print(e+" ");
        }
        System.out.println();
    }
}

使用泛型方法，可以建立数据通用的缓存池，并对不同类型的数据进行处理。

通配符

通配符用于处理类型不确定的情况，如处理具有不同类型参数的集合。

public void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

限制类型参数

通过使用 ？、extend 和 super 关键字，可以限制泛型类型参数的范围，以增强泛型安全性

通配符主要有三种类型：
无限制通配符（?）
上界通配符（A extends B）
保证获取的对象是B或者是B的子类，适用于读取数据的场景，保证至少是B类型
如：接受Number类型或其子类
下界通配符（A super B）
保证获取的对象是B或者是B的父类，适用于写入数据的场景，保证至少是B类型
如：写入Interger类型或其父类

// 上界通配符
public void printNumber(List<? extends Number> list){
    // 只接受存入Number类型及其子类的list集合。
}

// 下界通配符
public void addNumber(List<? super Integer> list){
    // 只接受写入Integer类型及其父类的list集合
}

总结

泛型的好处：
类型安全：在编译时进行类型检查，减少运行时类型错误。
消除强制类型转换：不需要显式的类型转换，提高代码可读性。
代码重用性：通过泛型，可以编写与类型无关的通用代码。

枚举（enum）是一种特殊的类（包括接口）,用以进行信息分类。

枚举类第一行必须罗列枚举对象的名字，在编译时会被编译成常量
枚举类的构造器都是私有的，枚举类不能对外构造对象

// 若A是一个枚举类
A a = new A();//会报错

枚举对象的调用方法

A a = A.X;
//a这是即为枚举对象X

枚举都是最终类，不能被继承
枚举类中，从第二行开始，可以定义其他成员

修饰符 enum 类名{
    X,Y,Z;//枚举对象的名称，以逗号分隔
    private String name;
    //getter && setter
}

枚举类提供一些额外的 api

A[] a2 = A.values();
A a3 = A.valueOf("Y");
//输出对象
System.out.println(a3.name());
//输出对象在枚举类的索引 下标从0开始
System.out.println(a3.ordinal());

抽象枚举

在枚举类中定义一个抽象方法, 枚举对象需要重写抽象方法。
构造器中如果有参数，则枚举对象中也需要有参数。

import java.sql.SQLOutput;

public enum B {
    X(){
        @Override
        public void go(){
            System.out.println("X created");
        }
    },
    Y("Mr. Y"){
        @Override
        public void go(){
            System.out.println("Y created");
            System.out.println(getName()+" is running~~");
        }
    };
    public abstract void go();

    B() {
        System.out.println("enum class B created");
    }
    B(String name){
        this.name = name;
    }
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

枚举的应用场景

用来表示一组信息，然后作为参数进行传输
选择定义一个一个的常量来展示一组信息，并作为参数传输

参数值不受约束
选择定义枚举表示一组信息，并作为参数传输

代码可读性好，参数值得到了约束，对使用者更友好，建议使用。

示例：

public class Test {
    public static void main(String[] args) {
        check(sex.BOY);
        //信息标记 分类
    }
    public static void check(sex sex_){
        switch(sex_){
            case BOY:
                System.out.println("boi");
                break;
            case GIRL:
                System.out.println("gro");
                break;
        }
    }
}

枚举 与 常量 没有相互淘汰，在实际开发中根据需求使用。

其中除了，和正常类没有什么区别（可以创建各种成员）

1.成员内部类(可以访问外部类的成员）

public class outer{
    public class inner{
        //创建对象时需要先创建外部类对象
    }
}
//创建方法
outer.inner in = new outer().new inner();
//访问该类的成员变量时，可以加this。
this.num;
//访问外部类的成员变量时，可以加类名this。
outer.this.num;

2.静态内部类（用static修饰的内部类）

public class outer{
    public static class inner{

    }
}
//创建对象的格式： 内部类.外部类 变量名 = new 内部类.外部类()
//在静态内部类中可以直接访问外部类的静态成员，但不能访问实例成员

3.局部内部类

4.匿名内部类（是一种特殊的局部内部类,无类名）

匿名内部类在创建对象时，会编译成一个子类，然后立即创建一个子类对象出来

public class outer{
    animal top = new animal(){
        @Override
        void run() {
            System.out.println();
        }
    };
    insert under = new insert(){
        @Override
        public void jump() {
            
        }
    };
    public class animal{
        void run(){

        };
    }
    interface insert{
        void jump();
    }
}

final修饰的类为最终类，不能被继承。
修饰的方法为最终方法，不能被重写。
修饰的变量为最终变量，仅可在声明时进行一次赋值。

public final class a{}
//不可被继承
public final void run(){}
//不可被重写
public final double discount = 0.7;
//不可重新赋值

用static final修饰的变量为常量，不能被修改。
代码可读性更好，更易于维护。
程序编译后，常量会被宏替换成字面量 -> 使用中常量和字面量的效率是一样的。

抽象类（abstract）

抽象类可以有所有类能够包含的成员（变量、方法、构造器）
抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
抽象类中有abstract修饰的方法为抽象方法，不能写方法体（仅有方法名，继承抽象方法的类必须重写抽象方法，否则该类也为抽象类）

设计抽象类能更好的实现行为多态。

public abstract class book{
    private String name;
    private int page;
    public abstract void COUNT_WORD();
//getter setter 忽略
}

public class Educated extends book(){
     public void COUNT_WORD(){
        System.out.println("3760450 words included");
     }
     //必须重写抽象方法。
}

接口(interface and implements)

用interface关键字可以定义出一种特殊的结构 接口：

public interface circle{
     /*public static final*/int pi = 3.1415926;//默认为常量
     /*public abstract*/void COUNT_LENGTH();//默认为抽象方法
     //不能有构造器和代码块{}；
}

接口中的变量默认是常量，方法默认是抽象方法，不能有构造器。用接口不能创建对象。

类可以用接口实现(implement)一些接口内的功能，实现接口的类称为 实现类。
一个类可以实现多个接口，弥补了子类只能继承一个类的不足。支持面向接口编程。

public class house implements door,light{
     int light_switch=0;
     public void open(){
       System.out.println("Door opened!");
     }
     public void close(){
       System.out.println("Door closed!");
     }
     public void switch_(){
       light_switch = (light_switch==0? 1 :);
}
public interface door{
   void open();
   void close();
}
public interface light{

   void switch_();
}

使用接口能灵活切换各种实现。

接口在jdk8后新增的三种方法：

默认方法：用default修饰，默认用public修饰（需要被频繁调用），需要带方法体，是实例方法，可以用实现类创建的对象调用。
私有方法：从jdk9开始支持！用private修饰，需要带方法体，是实例方法，可以用默认方法访问私有方法，或在其他私有方法中访问私有方法。
静态方法：用static修饰，默认用public修饰需要带方法体，仅接口内部可调用。

使用新增方法，不用将每个调用接口的类都重写一遍方法，仅调用即可，降低扩展与维护成本。

接口的多继承：一个接口可以继承多个接口

public interface a{}
public interface b{}
public interface c{}

public interface d extends a,b,c{}
//d能够合并abc接口的所有功能，简单高效。

使用接口的注意事项：

1. 一个类 / 接口继承多个接口时，若不同接口存在方法签名（方法名和返回值）冲突，则不能进行继承。
2. 如果一个类继承了父类实现了接口，父类和接口存在相同的方法，会优先使用父类的方法。
3. 如果一个类实现的多个接口有重名的默认方法，可以在类中直接重写方法。

student a = new student();
go(a);
teacher b = new teacher();
go(b);
public static void go(people c){}

people p1 = new teacher()
问题是多态不能调用子类独有功能，需要进行强制类型转换 :

student s1 = （student）p1

但运行时可能出现异常，父类对象不能转为子类对象（ClassCastException）。

可以使用instanceof关键字,判断当前对象，是的话返回true

p1 instanceof student
//属于的话返回true
//不属于的话返回false

需要调用子类独有功能时，在类型转换前需要用instanceof关键字判断类型，分别处理。

public static void go(people c){
     if(c instanceof student){
         student a1 = (student)c;
         a1.test();
     }
     else{
         teacher b1 = (teacher)c;
         b1.teach();
     }
}

object类是所有类的祖宗

子类可以进行方法重写（override），静态（static）和私有（private）方法不能被重写，方法名，返回值类型和参数列表需要一样，权限修饰符需要更大或者与父类方法一致。

Object类中toString方法：
功能：返回对象的地址
直接输出对象时会调用toString方法返回地址。
重写tostring方法返回对象的内容是开发中的常见业务内容。

子类访问其他成员的特点：就近访问（局部方法中 > 本类中 > 父类中），可以使用this关键字访问当前对象下的成员，super关键字可以访问父类对象下的成员。

子类构造器会先访问和调用父类的无参构造器，再构造自己。任何构造器都默认存在一个无参super()。
可以在构造器第一行用super(参数)传入，避免调用无参super()，导致子类构造器报错
super()应用场景：
可以在子类的有参构造器中直接调用，把参数传入父类的构造器帮助当前对象成员赋值。

可以在构造器中用this(参数)调用兄弟构造器,this()和super()都只能放在构造器第一行，不能一起使用。