java内部类精讲

以你之姓@ 2024-04-03 10:23 87阅读 0赞

#### 文章目录 ####

*  内部类的分类
 *   *  概念
     *  成员内部类
     *   *  栗子
     *  静态内部类
     *   *  栗子
     *  局部内部类
     *   *  栗子
     *  匿名内部类
     *   *  栗子

## 内部类的分类 ##

![在这里插入图片描述][b45d8b5c39b1432fbd5c1a48939fbdb5.png]

### 概念 ###

*  在一个类的内部再定义一个完整的类。
 *  特点
    
     *  编译之后，可生成独立的字节码文件。
     *  内部类可直接访问外部类的私有成员，而不破坏封装。  
        ![在这里插入图片描述][b7bcc4ec19c1414b8930189a8a1ba08d.png]

### 成员内部类 ###

*  ***在类的内部，定义与实例变量、实例方法同级别的类***。
 *  ***外部类的一个实例部分，创建内部类对象时，必须依赖外部对象***。

//创建外部类对象
            Outer outer=new Outer();
            //创建内部类对象
            Inner inner=outer.new Inner();

*  ***当外部类、内部类存在重名属性时，会优先访问内部类属性***。
 *  ***成员内部类不能定义静态成员。但可以定义静态常量【+final】***

#### 栗子 ####

package 内部类.成员内部类;
    
    /**
     * @author 缘友一世
     * date 2022/10/8-18:16
     */
    //外部类
    public class Outer {
        
        //实例变量
        private String name="酸梅汤小王子";
        private int age=12;
        //内部类
         class Inner {
        
            private String name="内卷小王子";
            //无法定义静态变量，但可以定义静态常量
            private static final String college="河大";
            private String address="开封";
            private String phone="华为";
    
            //方法
            public void show() {
        
                //使用外部类的类名和this关键字进行区分属性
                //打印外部类中的属性
                System.out.println(Outer.this.name);
                System.out.println(Outer.this.age);
                //打印内部类中的属性
                System.out.println(this.address);
                System.out.println(this.phone);
                //调用内部类的静态属性
                System.out.println(this.college);
                System.out.println(Inner.college);
            }
        }
    }

package 内部类.成员内部类;
    
    import 内部类.成员内部类.Outer.Inner;
    
    /**
     * @author 缘友一世
     * date 2022/10/8-18:23
     */
    //注意要添加内部类的导入；否则会遇到'内部类.成员内部类.Outer' 不是封闭类
    public class TestOuter {
        
        public static void main(String[] args) {
        
            //创建外部类对象
            Outer outer=new Outer();
            //创建内部类对象
            Inner inner=outer.new Inner();
            inner.show();
    
            System.out.println("===========");
            //一步到位
            Inner inner1 = new Outer().new Inner();
            inner1.show();
        }
    }

*  结果如下  
    ![在这里插入图片描述][07cab462c4e9492d956ee2039da91f81.png]

### 静态内部类 ###

*  不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
 *  只能直接访问外部类的静态成员（实例成员需实例化外部类对象）。

Outer.Inner inner=new Outer.Inner();
    Outer.Inner.show()；

#### 栗子 ####

*  请认真琢磨例子，必要可以自己动手敲敲看。

package 内部类.静态内部类;
    
    /**
     * @author 缘友一世
     * date 2022/10/8-18:57
     */
    public class Outer {
        
        //实例变量
        private String name="酸梅汤小王子";
        private int age=12;
        //静态内部类：和外部类相同
        static class Inner {
        
            private String name="内卷小王子";
            private static int count=666;
            private String address="开封";
            private String phone="华为";
    
            //方法
            public void show() {
        
                //先创建外部类的对象,在调用外部类的属性
                Outer outer=new Outer();
                //打印外部类中的属性
                System.out.println(outer.name);
                System.out.println(outer.age);
                //调用静态内部类中的属性
                System.out.println(address);
                System.out.println(phone);
                //调用静态内部类的静态属性 类名.静态属性
                System.out.println(Inner.count);
            }
        }
    }

package 内部类.静态内部类;
    
    /**
     * @author 缘友一世
     * date 2022/10/8-19:06
     */
    public class TestStaticOuter {
        
        public static void main(String[] args) {
        
            //直接创建静态内部类对象
            Outer.Inner inner = new Outer.Inner();
            //调用方法
            inner.show();
        }
    }

*  结果如下  
    ![在这里插入图片描述][5a5c4547eb7845ebb7aa5a4e64ac1339.png]

### 局部内部类 ###

*  ***定义在外部类方法中，作用范围和创建对象范围仅限于当前方法***
 *  ***局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final***。

#### 栗子 ####

package 内部类.局部内部类;
    
    /**
     * @author 缘友一世
     * date 2022/10/8-19:08
     */
    public class LocalOuter {
        
        private String name="华兴";
        private int age=22;
        public void show() {
        
            //定义局部变量
            String address="开封";
    
            //局部内部类：注意不能加任何访问修饰符
            class Inner {
        
                //局部内部类的属性
                private String phone="5201314";
                //非静态类不能定义静态变量，但是可以定义静态常量
                private final static String college="河大";
                public void show2() {
        
                    //访问外部类的属性
                    System.out.println(LocalOuter.this.name);
                    System.out.println(LocalOuter.this.age);
                    //访问内部类的属性
                    System.out.println(this.phone);
                    System.out.println(this.college);
                    //访问局部变量
                    // jdk1.7要求：变量必须是常量final
                    //jdk1.8会自动添加final
                    System.out.println(address);
    
                }
            }
            //创建局部内部类对象
            Inner inner = new Inner();
            inner.show2();
        }
    }

package 内部类.局部内部类;
    
    /**
     * @author 缘友一世
     * date 2022/10/8-19:14
     */
    public class LocalOuterTest {
        
        public static void main(String[] args) {
        
            LocalOuter localOuter = new LocalOuter();
            localOuter.show();
        }
    }

*  结果如下  
    ![在这里插入图片描述][9f1a8df6ebea4c9c83537405090082bd.png]

### 匿名内部类 ###

*  没有类名的局部内部类（一切特征都与局部内部类相同）。
 *  必须继承一个父类或者实现一个接口。
 *  定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
 *  优点：减少代码量
 *  缺点：可读性较差

#### 栗子 ####

*  接口

/**
     * @author 缘友一世
     * date 2022/10/8-19:24
     */
    public interface Usb {
        
        void service();
    }

*  Mouse实现接口

public class Mouse implements Usb{
        
        @Override
        public void service() {
        
            System.out.println("连接电脑成功！");
        }
    }

*  测试文件

package 内部类.匿名内部类;
    
    /**
     * @author 缘友一世
     * date 2022/10/8-19:26
     */
    public class TestNameless {
        
        public static void main(String[] args) {
        
    	    Mouse mouse = new Mouse();
    	        mouse.service();
    	        //局部内部类
    	        class Fan implements Usb {
        
    	
    	            @Override
    	            public void service() {
        
    	                System.out.println("风扇连接电脑成功！");
    	            }
    	        }
            //使用局部内部类创建对象
            Fan fan = new Fan();
            fan.service();
            //使用匿名内部类优化（相当于创建了一个局部内部类）
            Usb usb=new Usb() {
        
                @Override
                public void service() {
        
                    System.out.println("键盘连接电脑成功！");
                }
            };
            usb.service();
        }
    }

*  结果如下  
    ![在这里插入图片描述][e8f0c080bf56431fa8a74cfdc8887673.png]

> 匿名内部类的实质：是局部内部类  
> 通过编译文件看一看  
> ![在这里插入图片描述][f209700faab64ca998e951c04c78f0a9.png]

[b45d8b5c39b1432fbd5c1a48939fbdb5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/64ee4af3d000417db257e089adc58fbd.png
[b7bcc4ec19c1414b8930189a8a1ba08d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/e827ab37363f4bd0ac0780c65ac28a4e.png
[07cab462c4e9492d956ee2039da91f81.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/7562b84b58154051904165ecb5109aaa.png
[5a5c4547eb7845ebb7aa5a4e64ac1339.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/1f3c62e478064752b20d1ca026e10783.png
[9f1a8df6ebea4c9c83537405090082bd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/f7fb0e4354c043b492fb70fcc4c79108.png
[e8f0c080bf56431fa8a74cfdc8887673.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/05502364e63e4aafbf37a9c9ba2fdca9.png
[f209700faab64ca998e951c04c78f0a9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/8aad3e96c734470ca359f20468481861.png