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

2021-04-11 22:33:28 阅读：184 来源： 互联网

标签：内部对象成员 System day11 周六 println out 周日

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

成员内部类访问特点

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

/**
 * @description: 成员内部类的访问特点
 * @author: wuguidong@cskaoyan.onaliyun.com
 **/

/**
 * 【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(){}
    }
}

标签：内部,对象,成员,System,day11,周六,println,out,周日
来源： https://blog.csdn.net/xjadolphx/article/details/115607983

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

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