day11周六上午课周日休息_内部类

整理了长风老师在Day11的内部类章节的随堂代码

成员内部类访问特点

package com.cskaoyan.javase.oop3.innerclazz6.member2.basic2;

/**
 * @description: 成员内部类的访问特点
 * @author: 长风老师
 **/

/**
 * 【0.】前提:
 *   1.成员内部类和外围类的访问：
 *     不受访问权限限制,即便是私有的,它们也可以互相访问
 *   2.对象依赖于外围类对象：
 *     (1)this传参表示成员内部类自身对象
 *     (2)先有外围类对象。
 *     (3)外围类this传参,表示外围类对象自身
 *     (4)外围类成员方法中,没有成员内部类对象：
 *     外围类对象不依赖成员内部类对象,如果想有,需要手动创建
 *
 * 【1.】成员内部类的访问特点
 * -----成员内部类内部访问外围类
 *      1.不限访问权限
 *      2.同名：
 *       普通成员变量
 *          (1)不区分：优先选择内部类自身的成员
 *          (2)this.成员：表示内部类自身的成员
 *          (3)外围类类名.this加成员：表示外围类的成员,以示区分
 *       静态的成员变量
 *           没有。成员内部类中没有静态的成员变量
 *       全局常量
 *           类名区分
 *
 * 【2.】外围类访问成员内部类成员特点
 *-------外围类成员方法中
 *       访问内部类的成员
 *              (1)对象：先创建外围类对象，再创建内部类对象，用对象访问
 *              (2)类名：访问成员内部类的全局常量时,可以直接用类名,无需创建对象
 *              (3)同名：
 *                    对象名点：出来的是内部类
 *                    全局常量：类名区分
 *
 *-------外围类静态方法中
 *       访问内部类成员
 *              (1)创建外围类对象再创建内部类对象。对象名点访问
 *              (2)同名：不同的对象名
 *
 * 【3.】外部类访问成员内部类成员
 *       (1)创建内部类对象：内部类构造方法private，则不能创建
 *             如果不是private，先创建外围类对象,再创建内部类对象
 *       (2)访问权限限制
 *       (3)静态方法还是成员方法：没有外围类对象,都需要创建外围类对象
 *
 * 【4.】成员内部类访问外部类成员（了解）
 *       (1)创建外部类对象
 *             不可创建：受访问权限限制。
 *             可以创建：访问成员也受权限限制
 *
 */
public class Demo {//外部类
    int a = 10;
    private int b = 20;
    public static void main(String[] args) {
        //(1)先创建外围类对象
        EnclosedClazz ec = new EnclosedClazz();
        //(2)再创建内部类对象。用外围类类名.内部类类名 指示该内部类属于谁
        EnclosedClazz.Inner inner0 = ec.new Inner();

        //(3)链式：上述步骤二合一
        EnclosedClazz.Inner inner = new EnclosedClazz().new Inner();
        //外围类名.内部类名 对象名 = new 外部类名().new 内部类名();

        //System.out.println(inner.a);//测试：外部类中访问内部类对象成员

        //ec.test1();//测试：外围类成员方法中，访问内部类成员
        //EnclosedClazz.testStatic();//测试：外部类调用外围类静态成员方法，访问内部类成员

        inner.testInner();

    }
}
class EnclosedClazz{ //外围类
    //定义外围类的成员
    int a = 10;
    private int b = 20;
    static int c = 30;
    private static final int D = 40;//static final，大部分人都是static在前面

    public void testEnclosedMember(){
        System.out.println("testEnclosedMember");
    }
    public static void testEnclosedStatic(){//静态
        System.out.println("testEnclosedStatic");
    }

    public void test1(){//测试：外围类中，访问内部类成员、方法
        //(1)对象。直接创建内部类对象
        Inner inner = new Inner();
        //用这个对象访问内部类成员
        System.out.println(inner.a);
        System.out.println(inner.b);//既然是对象，可以访问私有
        System.out.println(Inner.D);//类名. 是静态常量，也可对象点，一般类名点
        System.out.println(EnclosedClazz.D);//外围类自己同名静态成员常量D
        System.out.println("this指的是xxx" + this.a);//this指的是外围类的成员a
        System.out.println(b);      //不指定，默认访问外围类自己的同名成员变量

    }

    //外围类的静态成员方法
    //测试访问内部类成员
    public static void testStatic(){
        //(1)先创建外围类对象
        EnclosedClazz ec = new EnclosedClazz();
        //(2)再创建内部类对象
        Inner inner = ec.new Inner();

        //(3)链式：上述步骤二合一
        Inner inner0 = new EnclosedClazz().new Inner();
        System.out.println(inner0.a);//100
        System.out.println(inner0.b);//200
        System.out.println(inner0.D);//400
        System.out.println(EnclosedClazz.D);//40
        /*//静态方法没有this,所以不能直接访问本类中的成员变量
        System.out.println(this.a);//没有本类的对象，静态方法没有
        System.out.println(b);*///ctrl + shift + /

    }
    class Inner{ //内部类
        int a = 100;
        private int b = 200;
        private static final int D = 400;
        //定义一个成员方法来访问外围类成员
        //内部类访问外围类成员
        public void testInner(){
            //this指向当前内部类对象
            System.out.println("yyy" + this.a);//100
            System.out.println(EnclosedClazz.this.a);//肯定有外部类对象，外部类名.this指的是外部类对象
            System.out.println(b);//200
            System.out.println(Inner.D);//400
            System.out.println(EnclosedClazz.c);//30
            System.out.println(EnclosedClazz.D);//40

            testEnclosedMember();//测试：可以在内部类调用外部类方法
            EnclosedClazz.testEnclosedStatic();//测试：可以调用外部类静态方法
            //this.test2();
            //EnclosedClazz.this.test1();//测试：调用外部类test1方法

            //Demo d = new Demo();
            //System.out.println(d.a);
            //System.out.println(d.b);

        }

        public void test2(){}
    }
}