Java内部类与泛型详解：概念、用法及注意事项-优快云博客

public class Outer {
    private int age=99;
    public static String a;
   public class Inner{
       private String name;
       public static String schoolName;//JDK16才开始支持定义静态成员
       private int age=88;



       public void test(){
           System.out.println(age);
           System.out.println(a);

           int age = 66;
           System.out.println(age);
           System.out.println(this.age);//访问内部类对象
           System.out.println(Outer.this.age);//访问外部类对象
       }

       public String getName() {
           return name;
       }

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

import javax.swing.undo.CannotUndoException;

public class Test {
    public static void main(String[] args) {
        Outer.Inner in =new Outer().new Inner();
        in.test();
    }
}

静态内部类：

有static修饰的内部类，属于外部类自己持有

public class Outer{

//静态内部类

public static class Inner{

}

}

创建对象的格式：

外部类名.内部类名对象名= new 外部类.内部类（...);

Outer.Inner in=new Outer.Inner() ;

静态内部类中访问外部类成员的特点

可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员。

public class Outer {
    private int age;
    public static String SchoolName;
    public static class Inner{
        private String name;
        public static int a;

        public void test(){

        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
    //定义一个外部类静态方法
    public static void test(){
        System.out.println(SchoolName);
        //在这个外部类静态方法里可以直接访问外部类静态成员
        //System.out.println(age);不可以直接访问外部类实例成员变量
        //age是实例成员变量是对象的成员变量不能直接访问，必须要用外部类对象来访问它
    }
}

局部内部类：

（看看就好）

是定义在方法中、代码中、构造器等执行体中。

public class Test{

public static void main(String[]args){

        }

public static void go(){

class A(){

                }

abstract class B{

                }

interface C{

                }

        }

}

匿名内部类：

就是一种特殊的局部内部类；所谓匿名指的是程序员不需要为这个类声明名字。

new 类或接口（参数值...){

类体（一般是方法重写）；

}；

特点：匿名内部类本质就是一个子类，并会立即创建出一个子类对象。

作用：用于更方便的创建一个子类对象。

应用场景：匿名内部类通常作为一个参数传输给方法。

枚举

枚举是一种特殊类

格式

修饰符enum枚举类名{

名称1，名称2，...；

其他成员...

}

public enum A{

X,Y,Z;

...

}

注意

枚举类中的第一行，只能写一些合法的标识符（名称），多个名称用逗号隔开。
这些名称，本质是常量，每个常量都会记住枚举类的一个对象。

特点

枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量记住的都是枚举类的一个对象。
枚举类的构造器都是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象。
枚举都是最终类，不可以被继承。
枚举类中，从第二行开始，可以定义类的其他各种成员。
编译器为枚举类新增了几个方法，并且枚举类都是继承：java.lang.Enum类的，从enum类也会继承到一些方法。

抽象枚举：在枚举里定义了一个抽象方法，构建对象的时候要重写

可以使用枚举实现单例设计模式

枚举的常见应用场景：

public class Test {
    public static void main(String[] args) {
        check(Constant.BOY);
    }
    public static void check(Constant sex){
        switch(sex){
            case BOY :
                System.out.println("展示美女");
                break;
            case GIRL:
                System.out.println("展示帅哥");
                break;
        }
    }
}

public enum Constant {
    BOY,GIRL;
}

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

选择定义一个一个的常量来表示一组信息，并作为参数传输

参数值不受约束

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

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

泛型

认识泛型

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

public class ArrayList<E>{

...

}

//1.一个类型变量
public class ArrayList<E>{
    //……
}
 
 
//2.多个类型变量
public class ArrayList<E,T>{
    //……
}
 
 
//3.将泛型类限定
public class ArrayList<E extend A>{
    //这里的类型必须是A类或者是A的子类
    //……
}
 
 
 
 
public class A{
 
}
 
public class B extend A{
 
}

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

泛型的本质：把具体的数据类型作为参数传给类型变量。