学习java的第二十三天，内部类（成员内部类、静态内部类、局部内部类）的学习

一、内部类

• 什么是内部类：

概念：在一个类的内部再定义一个完整的类！
特点：

1. 编译之后可生成独立的字节码文件！
2. 内部类可以直接访问外部类的私有成员，而不破坏封装！
3. 可为外部类提供必要的内部功能组件！

• 内部类的分类：成员内部类、静态内部类、局部内部类、匿名内部类

1、成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类！
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象！
• 当外部类、内部类存在重名属性时，会优先访问内部类属性
• 成员内部类不能定义静态成员！

首先创建一个外部类以及内部类

package com.ClassTest.InnerClass;
//外部类
public class demo01 {

    private String name = "小红";
    private String age = "20";

        //内部类
    class Inner{
        private String address= "广西";
        private String phone = "123456";
        private String name = "小菲";  //这里会优先调用
        //方法
            public  void  show(){

                System.out.println(name); //输出小菲
                System.out.println(age);  //输出20
                System.out.println(address);  //输出广西
                System.out.println(phone);   //输出123456
            }

        }
}

然后再创建一个输出类，用来实例化对象的！

package com.ClassTest.InnerClass;

public class Test {
    public static void main(String[] args) {
            //首先创建外部类对象
        demo01 dee = new demo01();
        //然后通过外部类对象在实例化内部类
        demo01.Inner dee2 = dee.new Inner();
        dee2.show();

        //new一个对象，，并且实例化一个对象  这里是快捷方法
        demo01.Inner de = new demo01().new Inner();
        de.show();
    }
}

然后得出以下结果：

2、静态内部类

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

首先跟上面的成员内部类一样，先创建一个外部类再创建一个静态内部类！

package com.ClassTest.StaticClass;
//外部类
public class demo01 {

    private String name = "堂哥";
    private int age = 18;
    String aa = "55";
        //静态内部类：和外部类相同
    static class Inner{
        private String address="北京";
        private String phone = "111111";

        public void show(){
            //调用外部类的属性
            //1.先创建外部类对象
            demo01 demo01 = new demo01();
            //2.调用外部类对象
            System.out.println(demo01.name);
            System.out.println(demo01.age);
            //调用静态方法的属性和方法
            System.out.println(address);
            System.out.println(phone);

        }
    }
}

然后再创建一个测试类，用来输出上面的静态内部类

package com.ClassTest.StaticClass;

public class Test {
    public static void main(String[] args) {
        //直接创建静态内部类对象！
        demo01.Inner inner = new demo01.Inner();
        //调用方法！
        inner.show();

    }
}

以下是输出结果

总结：静态内部类跟成员内部类不一样，创建对象时不需要依赖外部类对象！

3、局部内部类

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

package com.ClassTest.localClass;
//外部类
public class demo01 {
   private String name = "张三";

   //外部类方法
    public void show(){   //show方法
        //定义局部变量
        String address= "深圳";
        //局部内部类：注意不能添加任何的修饰符！
        class Inner{
            //局部内部类的属性
            private String phone = "1111111111111";
            private String emai = "115454@qq.com";

            //局部内部类的方法
            public void show2(){
                //访问外部类的属性
                System.out.println(demo01.this.name);
                //访问内部类的属性
                System.out.println(this.emai);
                System.out.println(this.phone);

            }

        }
        //如果想访问局部内部类的方法，就必须创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }

}

测试类

package com.ClassTest.localClass;

public class Test {

    public static void main(String[] args) {
        demo01 demo01 = new demo01();
        demo01.show();

    }
}

结果

---

注：文章仅做个人学习日记，不做学习建议，学习来源：千峰教育