JavaSe面向对象13：N种内部类（笔记）

视频学习地址

点我跳转ψ(｀∇´)ψ

前言

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对于B类来说就是外部类了。

什么是内部类

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

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

成员内部类

    public static void main(String[] args) {
        Outer outer = new Outer();          //实例化外部类
        outer.out();

        Outer.Inner inner = outer.new Inner();    //实例化内部类  通过外部类来实例化内部类
        inner.in();
        inner.getID();  //可以获得外部类的私有属性
    }

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        public void getID(){
            System.out.println(id);
        }
    }
}

• 在类的内部定义，与实例变量、实例方法同级别的类
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
• 当外部类、内部类存在重名属性时，会优先访问内部类属性，如果要访问外部类属性要这样写：外部类名.this.外部属性
• 成员内部类不能定义静态成员，但是可以定义静态常量

静态内部类

演示：

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }
}

实例：

public class Application{
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();  //这里的Outer没有加括号，只表示一个包含关系
        inner.show();
    }
}

public class Outer{
    private int age = 10;
    private String name = "夕阳团";

    static class Inner{
        private int age = 18;
        private String name = "枭灵酱";
        //静态成员
        private static int count = 100;

        //静态内部类的方法
        public void show(){
            //静态内部类调用外部类需要将外部类实例化
            Outer outer = new Outer();
            System.out.println(outer.age);
            System.out.println(outer.name);

            //调用内部类的属性，直接写属性名就好了
            System.out.println(age);
            System.out.println(name);
        }
    }
}

• 静态内部类就是在成员内部类前面加上static的修饰符
• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
• 它的级别和外部类相同
• 正常的类是不可以用static进行修饰，只有内部类才可以

局部内部类

//外部类
public class Outer{
    private String name = "夕阳团";
    private int age = 18;

    public void show(){
        //定义局部变量
        String address = "九江";

        //局部内部类：局部内部类前面不能加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String phone = "1999999999";
            private String email = "tencent@qq.com";

            //类中的方法中的内部类中的方法
            public void show2() {
                //可以直接访问外部类的属性但最好是带上Outer.this
                System.out.println(Outer.this.name);
                System.out.println(Outer.this.age);
                //访问内部类的属性
                System.out.println(phone);
                System.out.println(email);
                //访问局部变量：在JDK1.7中要求变量必须加上final修饰符
                System.out.println(address);
            }
        }
        //创建局部内部类对象（不实例化调用show会输出空内容）
        Inner inner = new Inner();
        inner.show2();
    }
}

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

匿名内部类

public class Test {
    public static void main(String[] args) {
        //Apple apple = new Apple();    不用apple去实例化Apple

        new Apple().eat();  //不用将实例保存到变量中,直接调用eat()方法

        //匿名类
        new User(){
            @Override
            public void say() {
                System.out.println("hello");
            }
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("吃了一个苹果");
    }
}

interface User{
    void say();
}