Java面向对象（内部类）（枚举）（泛型）

痛定思痛。 2024-03-23 22:53 95阅读 0赞

#### 内部类 ####

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

一个类定义在另一个类的内部，就叫做内部类；

当一个类的内部，包含一个完整的事物，且这个事务不必单独设计，就可以把这个事务设计为内部类；

Public class Car{
        
        //内部类
        Public class Engine{
    
        }
    
    }

内部类的四种形式：

**成员内部类； 静态内部类； 局部内部类；匿名内部类**

##### 成员内部类 #####

定义在成员位置的类，叫做成员内部类；

public class Outner {
        private String name = "科比";
        private int age = 43;
    
        //访问内部类的成员变量及方法
        public static void main(String[] args) {
            //创建内部类的对象
            Inner inner = new Outner().new Inner();
            inner.test();
        }
    
        //成员内部类
        public class Inner{
            private String name = "詹姆斯";
            private int age = 38;
            public void test(){
                //访问内部类的成员变量
                System.out.println(name);
                System.out.println(age);
                //访问内部类的成员变量
                System.out.println(Outner.this.name);
                System.out.println(Outner.this.age);
            }
    
    
        }
    }

创建内部类的对象：**new 外部类（）.new 内部类（）；**

在内部类中调用外部类的成员变量： **外部类.this.外部类的成员变量；**

#####  #####

##### 静态内部类 #####

在内部类中用static修饰的内部类叫做静态内部类；

public class Outner {
        static String name = "科比";
        private int age = 43;
        public static void main(String[] args) {
            //创建内部类的对象
            new Outner.Inner().test();
        }
    
       static class Inner{
            public void test(){
                //访问外部类的静态方法，非静态方法访问不到；
                System.out.println(Outner.name);
                
    //            System.out.println(Outner.this.age); 报错
           }
        }
    }

**静态内部类只能调用外部类的静态变量；**

**创建内部类对象：new 外部类.内部类（）；**

##### 局部内部类 #####

局部内部类是定义在方法中的类，和局部变量一样，只能在方法中有效。所以局部内部类的局限性很强，一般在开发中是不会使用的。

public class Outer{
        public void test(){
            //局部内部类
            class Inner{
                public void show(){
                    System.out.println("Inner...show");
                }
            }
            
            //局部内部类只能在方法中创建对象，并使用
            Inner in = new Inner();
            in.show();
        }
    }

局部内部类只能在方法中创建对象，局限性比较强，所以开发中一般不会使用；

##### 匿名内部类 #####

匿名内部类是一种特殊的局部内部类，因为不需要声明名字，所以叫做匿名内部类；

new 父类/接口（参数值）{
     
      @override
        重写父类或者接口的方法
    
    }

**匿名内部类时间上是一个没有名字的子类对象，或者接口实现类的无名对象**

public class Dome01 {
        public static void main(String[] args) {
            //匿名内部类的实现
            new Animal(){//符合多态思想的：编译看左，运行看右思想；
                @Override
                public void cry() {
                    System.out.println("狗叫旺旺旺");
                }
            }.cry();//匿名对象直接调用Animal的cry方法
            
        }
    }
    
    //创建一个动物的抽象类
    abstract class Animal{
       public abstract void cry();
    }

需要注意的是，匿名内部类在编写代码时没有名字，编译后系统会为自动为匿名内部类生产字节码，字节码的名称会以`外部类$1.class`的方法命名

![7f42188e141c46e2b1a6c3c9917648e8.png][]

**匿名内部类的作用：简化了创建子类对象、实现类对象的书写格式。**

#### 匿名内部类的应用场景 ####

只有在调用方法时，当方法的参数是一个接口或抽象类时，为了简化书写代码，而直接传递匿名内部类给方法。

public class Dome01 {
        public static void main(String[] args) {
            //匿名内部类对象1
            new Swimming(){
                @Override
                public void swim() {
                    System.out.println("狗游泳飞快");
                }
            }.swim();
            
            //匿名内部类对象2
            new Swimming(){
                @Override
                public void swim() {
                    System.out.println("猫不会游泳");
                }
            }.swim();
        }
    
        public void go(Swimming s){//将接口Swimming作为形参
            System.out.println("开始比赛");
            s.swim();
            System.out.println("结束比赛");
    
        }
    
    }
    interface Swimming{//接口
        public void swim();
    }

#### 枚举 ####

枚举是一种特殊的类，它的格式：

Public enum A{
        X,Y,Z
    
    }

其中XYZ叫做枚举项，它属于枚举的一个对象。想要获得枚举对象只需要用枚举名调用；

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

public class Test{
        public static void main(String[] args){
            //获取枚举A类的，枚举项
            A a1 = A.X;
            A a2 = A.Y;
            A a3 = A.Z;
        }
    }

通过反编译的形式来验证（需要用到反编译的命令，这里不能直接将字节码拖进idea反编译）

![7a2d082c1d4b42c4bc0e2ffe3c4c4a08.png][]

枚举类A是用class定义的，说明枚举确实是一个类，而且X，Y，Z都是A类的对象；而且每一个枚举项都是被`public static final`修饰，所以可以类名调用，而且不能更改。

#### 枚举类的应用场景 ####

**枚举一般表示一组信息，然后作为参数进行传输。**

我们来看一个案例。比如我们现在有这么一个应用，用户进入应用时，需要让用户选择是女生、还是男生，然后系统会根据用户选择的是男生，还是女生推荐不同的信息给用户观看。

![0aee6424ae5a49fab5f3b68febc65ed3.png][]

public class Dome01 {
        public static void main(String[] args) {
            get(GENDER.BOY);
            get(GENDER.GIRL);
        }
        public static void get(GENDER gender){
            if (gender == GENDER.BOY){
                System.out.println("男生观看");
            }else {
                System.out.println("女生观看");
            }
        }
    
    }
    enum GENDER{
        BOY,GIRL
    }

最终再总结一下枚举的应用场景：**枚举一般表示几个固定的值，然后作为参数进行传输**

##### 枚举设计单例设计模式 #####

单例设计模型也可以使用枚举进行设计，

public class dome01 {
        public static void main(String[] args) {
            Singleton instance1 = Singleton.INSTANCE;
            Singleton instance2 = Singleton.INSTANCE;
            System.out.println(instance2 == instance1);//判断两个对象的地址值，确定只能创建一个对象
        }
    }
    enum Singleton{
        INSTANCE;
        public void method(){
            System.out.println("我是一个单例");
        }
    
    }

#### 泛型 ####

##### 认识泛型 #####

所谓泛型就是在定义类、接口、方法的时候同时声明一个或者多个类型变量<E>，称为泛型类，泛型接口，泛型方法。

![d68b2bdcb29146bf93c07a41f0300427.png][]

*  **泛型的好处：在编译阶段可以避免出现一些非法的数据。**
 *  **泛型的本质：把具体的数据类型传递给类型变量。**

##### 自定义泛型 #####

//这里的<T,W>其实指的就是类型变量，可以是一个，也可以是多个。
    public class 类名<T,W>{
        
    }

##### ArrayList的底层实现 #####

//定义一个泛型类，用来表示一个容器
    //容器中存储的数据，它的类型用<E>先代替用着，等调用者来确认<E>的具体类型。
    public class MyArrayList<E>{
        private Object[] array = new Object[10];
        //定一个索引，方便对数组进行操作
        private int index;
        
        //添加元素
        public void add(E e){
            array[index]=e;
            index++;
        }
        
        //获取元素
        public E get(int index){
            return (E)array[index];
        }
    }

测试类，来测试自定义的泛型类MyArrayList是否能够正常使用

public class Test{
        public static void main(String[] args){
            //1.确定MyArrayList集合中，元素类型为String类型
            MyArrayList<String> list = new MyArrayList<>();
            //此时添加元素时，只能添加String类型
            list.add("张三");
            list.add("李四");
            
             //2.确定MyArrayList集合中，元素类型为Integer类型
            MyArrayList<Integer> list1 = new MyArrayList<>();
            //此时添加元素时，只能添加String类型
            list.add(100);
            list.add(200);
            
        }
    }

[7f42188e141c46e2b1a6c3c9917648e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0308b4a098f64a8796616f31d399490b.png
[7a2d082c1d4b42c4bc0e2ffe3c4c4a08.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/17b5448c6bce4991a29daf1cb716cb1d.png
[0aee6424ae5a49fab5f3b68febc65ed3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/eba91360869540c3b431a3cfa11bd1c0.png
[d68b2bdcb29146bf93c07a41f0300427.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/e154cc6c9e8547c18c9b1cee925313db.png