【Java概念】内部类(12)

package cn.hncu.program.innerClass;


/**
 * 项目名:内部类 :InnerClass
 *       内部接口:InnerInterface
 * 时间 :2017-9-13 下午8:36:33
 */
/*
 *【如何定义内部类?】:
 *1.内部类定义在外部类普通成员方法的位置。 
 *2.内部类和普通类定义是一样的,只是内部类是定义在类中的类。
 *
 *3.非静态内部类无法定义static的变量和方法;静态内部类可以定义static的变量和方法。
 */

/*
 * 【内部类的四种级别】:
 * 类级:成员式,有static修饰
 * 对象级:成员式,普通,无static修饰
 * 本地内部类:局部式,在方法内部定义
 * 匿名内部类:局部式,在方法内部定义
 * 
 * 【局部内部类只能访问外部方法中的final变量 】:
 * 原因:
 *    虽然局部内部类在方法的内部,但实际编译的时候,内部类编译成,Outer.Inner,
 * 这说明内部类所处的位置和外部类中的方法处在同一个等级上,外部类中的方法中的变量或
 * 参数只是方法的局部变量,这些变量或参数的作用域只在这个方法内部有效。
 *    因为编译的时候内部类和方法在同一级别上,所以方法中的变量或参数只有final,内部类
 * 才可以引用。----常量池。
 */
class Outer{/*外部类*/
    private int size = 8;//外部类成员
    private int count = 10;
    public void doSth(){
        /*
         * 【外部类访问内部类】:
         */
        System.out.println(new Inner2().size);
        new Inner2().doSth();
        System.out.println(new Inner3().size);
    }

    public class Inner{/*内部类*/
        private int size = 6;//内部类成员
        public void doSth(){
            System.out.println("inner...");
        }
    }
    public class  Inner2{
        /*private static count = 10;//非静态内部类无法定义静态成员:变量和方法
        public static void aa(){
        }
        */
        private int size = 7;//内部类成员
        /*
         * 【内部类与外部类,内部类与内部类之间的访问形式】:
         * 1.非静态内部类调用,访问外部类的变量,以及内部类成员变量。
         * 2.内部类访问外部类的成员。
         */
        public void doSth(){
            //首先访问当前内部类Inner2的成员变量:
            System.out.println("Inner2>size = "+size);
            System.out.println("Inner2>this.size = "+this.size);
            //访问同级别内部类Inner的成员变量:
            System.out.println("Inner>size = "+new Inner().size);
            //访问外部类Outer的成员变量:
            System.out.println("Outer>size = "+Outer.this.size);

            //【非静态内部类访问静态内部类成员】:
            System.out.println("Inner3>size = "+new Inner3().size);
        }
    }

    /*
     * 【静态内部类】:
     */
    public static class Inner3{
        private int size = 10;
        private int count =1 ;//静态内部类可以定义static成员:变量和方法
        public void aa(){
        }
        public  void doSth(){
            //1.静态内部类访问外部类成员变量:
            System.out.println(new Outer().size);
            //2.静态内部类访问非静态内部类成员:
            System.out.println(new Outer().new Inner2().size);
            //3.静态内部类访问本类成员;
            System.out.println(size);
        }

    }

    /* 测试如何使用内部类:
     * 
     * 【如何使用内部类?    】:
     * 1.可以把非静态内部类理解成外部类的一个非静态成员,就像一个非静态方法一样。
     * 2.创建外部类实例。
     * 3.调用非静态内部类的构造方法: 要通过 outer.new ---外部类对象.new内部类 。
     */
    public void t1(){
        //(1)创建外部类实例:                   
        Outer outer = new Outer();
        //(2)调用内部类成员方法:
         outer.doSth();
    }

    /*
     * 测试内部类与外部类,内部类与内部类之间如何访问:
     * 
     * 【内部类、外部类之间如何访问?】:
     * 
     */
    public void t2(){
        //1.创建非静态内部类实例。
        Outer.Inner2 inner2 = new Outer().new Inner2();
        //2.doSth
        inner2.doSth();
    }
    public void t3(){
        //1.创建静态内部类实例。
        Inner3 inner3 = new Inner3();
        //2.doSth
        inner3.doSth();
    }


}


/*
 * 匿名内部类----局部内部类:
 * cryptonym:匿名
 */
class Cryptonym{
    public Cryptonym() {

        /*
         * 【写匿名内部类(接口的实现类)---new 接口 】:
         */
        final int size = 100;//----局部变量,既不是类级,也不是对象级
        MyInterface inter = new MyInterface() {
            @Override
            public void run() {
                System.out.println("run.....");
                //局部内部类只能访问外部类变量的final变量  /外部类方法中的final变量
                System.out.println("cryptonym>inter>size = "+size);
            }
        };

        /*
         * 【匿名内部类方法非final变量】:
         * 1.如果一个局部内部类非要去访问外面方法中的非final局部变量,那么可以通过传参实现
         */
        MyInterface2 inter2 = new MyInterface2() {
            @Override
            public void fun(int n) {
                System.out.println("n = "+n);
            }
        };


        /*
         * 【局部内部类(抽象类的实现类):new抽象类】:
         * 
         */
        A a = new A() {
            public void run() {
                System.out.println("A...run....");
            }
            public void bb(){
                System.out.println("B...bb...");
            }
        };
        a.run();
        //a.bb();//编译出错:编译时多态:先到A类中及其父类中找bb方法:

        /*
         * 【局部内部类(普通类的实现类):】
         */
        new Thread(){
            @Override
            public void run() {
                System.out.println("Thread...run...");
            }
        }.start();
    }
}
interface MyInterface{
    public abstract void run();
}
interface MyInterface2{
    public abstract void fun(int  n);
}

abstract class A{
    public abstract void run();
}

public class InnerClass{
    public static void main(String[] args) {
        //测试如何使用内部类:
        new Outer().t1();
        //测试内部类、外部类之间如何访问:
        new Outer().t2();
        //测试静态内部类、外部类之间如何访问:
        new Outer().t3();

        //测试如何使用匿名内部类:
        Cryptonym crypt = new Cryptonym();
    }
}



  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值