Java基础14-内部类&四种权限修饰符

内部类

package 进阶.demo09_内部类;

public class demo01_内部类 {
    public static void main(String[] args) {

        /*内部类分类：
        * 1. 成员内部类
        * 定义格式：
        * 修饰符 class 外部类名称 {
        *   修饰符 class 内部类名称 {
        *   //
        *  }
        * }
        * 注意：
        * 内部类访问外部类，没有限制；外部类访问内部类，需要借助内部类对象
        * 使用成员内部类，有两种方式：
        * a.间接：在外部类的方法中，使用内部类，main只是调用外部类的方法
        * b.直接：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
        *
        * 2. 局部内部类（包含匿名内部类）
        * */
    }
}

成员内部类

成员内部类的定义

package 进阶.demo09_内部类;

public class demo02_成员内部类 { // 外部类

    public class Inner {  // 内部类

        public void func() {
            System.out.println("内部类的方法");
            // 内部类访问外部类的`name`,正确
            System.out.println(name);
        }
    }

    private String name;

    public void method() {
        System.out.println("外部类的方法");
    }

    public String getName() {
        return name;
    }

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

成员内部类的使用

package 进阶.demo09_内部类;

public class demo03_成员内部类的使用 {
    public static void main(String[] args) {

        //间接： 通过外部类的对象，调用外部类的方法，然后间接调用内部类的方法
        demo02_成员内部类 demo = new demo02_成员内部类();
        demo.method();

        //直接：
        demo02_成员内部类.Inner inner = new demo02_成员内部类().new Inner();
        inner.func();
    }
}

局部内部类

局部内部类的定义

package 进阶.demo09_内部类;

public class demo04_局部内部类 {
    /*局部内部类：
    * 定义格式：
    * 修饰符 class 外部类名称 {
    *   修饰符 返回值类型 外部类方法名称（参数列表） {
    *       class 局部内部类名称 {
    *            //...
    *       }
    *   }
    * }
    *
    * 定义一个类时的权限修饰符规则：
    * 1. 外部类： public / (default)
    * 2. 成员内部类：public / protected / (default) / private
    * 3. 局部内部类：不能加修饰符
    * */

    public void methodOuter() {
        class Inner { // 局部内部类
            int num = 10;
            public void methodInner() {
                System.out.println(num);
            }
        }

        // 局部实现内部类
        Inner inner = new Inner();
        inner.methodInner();
    }


}

局部内部类的使用

package 进阶.demo09_内部类;

public class demo05_局部内部类的使用 {

    public static void main(String[] args) {

        demo04_局部内部类 outer = new demo04_局部内部类();
        outer.methodOuter();
    }
}

内部类同名处理规则

package 进阶.demo09_内部类;

public class demo06_内外部类同名处理规则 {

    int num = 10;  // 外部类的成员变量

    public class Inner {
        int num = 20;  // 内部类的成员变量

        public void func() {

            int num = 30;  // 内部方法的局部变量
            System.out.println(num); //  30
            System.out.println(this.num); // 20
//            System.out.println(super.num);  错误，内外部类不是继承关系
            System.out.println(demo06_内外部类同名处理规则.this.num); // 10

        }

    }
}

内部类的final关键字

package 进阶.demo09_内部类;

public class demo08_内部类的final关键字 {
    public static void main(String[] args) {
        /*
        * 局部内部类，如果希望访问所在方法的局部变量，则这个局部变量必须是有效的final
        * Java8+开始，只要局部变量不变，final关键字可以省略
        *   原因（生命周期）：
        * 1. new出来的对象在堆内存中
        * 2. 局部变量是跟着方法走的，存在于栈内存中，
        * 3. 方法运行结束之后，立刻出栈，局部变量就会立刻消失。
        * 4. new出来的对象会在堆内存中持续存在，直到被垃圾回收。
        * 5. 综上，生命周期不同，需要保证常量。
        * */


    }


    public void method() {
        int num = 10;
//        num = 20 ;添加该语句则内部类无法调用

        class Inner {
            public void methodInner() {
                System.out.println(num);
            }
        }
    }
}

匿名内部类

package 进阶.demo09_内部类;

/*
 * 如果接口的实现类（或者是父类的子类），只需要使用唯一的一次，此时可以
 * 省略掉该类的定义，而改用[匿名内部类]
 *
 * 匿名内部类的定义格式：
 * 接口名称 对象名 = new 接口名称() {
 *   // 覆盖重写接口中的抽象方法
 * }
 *
 * 使用匿名内部类的注意事项：
 * 1. `匿名内部类`在创建对象的时候，只能使用唯一的一次
 * 2. `匿名对象`实在调用方法的时候，只能使用唯一的一次
 * 3. 匿名内部类省略了[实现类/子类]，但是匿名对象省略了[对象名称]
 *
 * */
public class demo09_匿名内部类 {
    public static void main(String[] args) {
//        demo11_MyInterfaceImpl impl = new demo11_MyInterfaceImpl();
        demo10_MyInterface impl = new demo11_MyInterfaceImpl(); // 左父右子也可以实现，多态
        impl.method();


        // 使用匿名内部类：覆盖重写了接口的抽象方法，{}即为一个类，是匿名的
        demo10_MyInterface obj = new demo10_MyInterface() {
            @Override
            public void method() {
                System.out.println("使用了匿名内部类");
            }
        };

        obj.method();

    }
}

接口定义

package 进阶.demo09_内部类;

public interface demo10_MyInterface {
    void method(); // 抽象方法
}

实现类定义

package 进阶.demo09_内部类;

public class demo11_MyInterfaceImpl implements demo10_MyInterface{
    @Override
    public void method() {
        System.out.println("实现类覆盖重写了抽象方法");
    }
}

四种权限修饰符对比

package 进阶.demo08_四种权限修饰符;

public class demo01_四种权限修饰符 {
    public static void main(String[] args) {

        /*Java中的四种权限修饰符是否可以访问：
        *                     public   >   protected   >   (default)    >   private
        * 同一个类（自己）          1               1             1               1
        * 同一个包 （邻居）         1               1             1               0
        * 不同包子类 （儿子）        1               1             0               0
        * 不同包非子类 （陌生人）     1               0             0               0
        *
        * 注意：
        * default代表没有修饰符
        *
        *
        * */

    }
}