【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();
    }
}