java中的内部类

一：成员内部类的定义

       可以将一个类的定义放在里另一个类的内部，这就是内部类。广义上我们将内部类分为四种：成员内部类、静态内部类、局部（方法）内部类、匿名内部类。

 

二：使用内部类

（1）成员内部类

图（1），新建外部类，使用成员内部类

 团（2）其他类使用成员内部类

 图2运行结果：

 成员内部类总结：

1. 内部类的内部不能有静态信息。
2. 外部类如何访问内部类信息，必须new之后打点访问。

 （2）静态内部类

package *******.test.inner.staticInner;

/**
 * 静态内部类
 * 外部类
 */
public class Outer {

    private int outerAttribute  = 1;

    /**
     * 外部类和内部类类命名重复
     */
    private int commonAttribute =  2;

    private static int staticOuterAttribute = 3;

    static {
        System.out.println("外部类的静态代码快被执行了！");
    }

    private void outerMethod(){
        System.out.println("外部类的普通方法被执行=========");
    }

    private  static  void staticOuterMethod(){
        System.out.println("外部类的静态方法被执行=======");
    }

    /**
     * 静态内部类
     */
    public static class Inner{

        /**
         * 内部类成员变量
         */
        private int innerAttribute = 10;

        /**
         * 重复变量
         */
        private int commonAttribute = 20;

        private static  int staticInnerAttribute = 30;

        static{
            System.out.println("内部类的静态代码快被执行了！");
        }

        /**
         * 成员方法
         */
        public void innerShow() {
            System.out.println("innerAttribute:" + innerAttribute);
            System.out.println("内部的commonAttribute:" + commonAttribute);
            System.out.println("staticOuterAttribute:"+staticOuterAttribute);
            staticOuterMethod();
        }

        /**
         * 静态方法
         */
        public static void innerStaticShow() {
            //被调用时会先加载Outer类
            staticOuterMethod();
//            outerMethod();内部类方法只能访问外部为static修饰的方法
            System.out.println("staticOuterAttribute"+staticOuterAttribute);
        }
    }
    /**
     * 外部类的内部如何和内部类打交道
     */
    public static void callInner() {
        System.out.println(Inner.staticInnerAttribute);
        Inner.innerStaticShow();
    }


}

package ********.test.inner.staticInner;

public class Other {

    public static void main(String[] args) {
        //访问静态内部类的静态方法，Inner类被加载,此时外部类未被加载，独立存在，不依赖于外围类。
        Outer.Inner.innerStaticShow();
        //访问静态内部类的成员方法
        Outer.Inner oi = new Outer.Inner();
        oi.innerShow();
    }

}

 输出结果：

内部类的静态代码快被执行了！
外部类的静态代码快被执行了！
外部类的静态方法被执行=======
staticOuterAttribute3
innerAttribute:10
内部的commonAttribute:20
staticOuterAttribute:3
外部类的静态方法被执行=======

局部内部类总结：

1. 静态内部类的方法只能访问外部类的static关联的信息。
2. 利用 外部类.内部类 引用=new 外部类.内部类(); 然后利用引用.成员信息(属性、方法)调用。

 （3）局部内部类

package ***********.test.inner.part;


/**
 * 局部内部类
 * 外部类
 */
public class Outer {

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerMethodCreate(1000);
    }

    /**
     * 外部类属性
     */
    private int outerAttribute = 1;
    /**
     * 同名属性
     */
    private int commonAttribute = 2;

    /**
     * 外部类静态属性
     */
    private static int  outerStaticAttribute = 3;
    static {
        System.out.println("外部类的静态代码块执行了。。。。。。。。。");
    }

    public void outerMethod(){
        System.out.println("外部类普通方法，outerMethod===========================");
    }

    public static void outerMethodStatic(){
        System.out.println("外部类静态方法，outerMethodStatic====================");
    }

    public void outerMethodCreate( int value){
        /**
         * 女性
         */
        boolean sex = false;

        /**
         * 内部类
         * 1：类前不能有修饰符
         */

        class Inner{

            /**
             * 内部类属性
             */
            private int innerAttribute = 10;

            /**
             * 重名属性
             */
            private int commonAttribute = 20;


            public void innerShow(){
                System.out.println("innerAttribute： " + innerAttribute);
                System.out.println("是否男性： " + sex);
                System.out.println("参数value: " +value);
                //调用外部类的信息
                System.out.println("outerAttribute:" + outerAttribute);
                System.out.println("内部的commonVariable:" + commonAttribute);
                System.out.println("外部的commonVariable:" + Outer.this.commonAttribute);
                System.out.println("outerStaticVariable:" + outerStaticAttribute);
                outerMethod();
                outerMethodStatic();
            }

        }

        /**
         * 局部内部类只能在方法内部使用
         */
        Inner inner = new Inner();
        inner.innerShow();
    }

}

 输出结果：

外部类的静态代码块执行了。。。。。。。。。
innerAttribute： 10
是否男性： false
参数value: 1000
outerAttribute:1
内部的commonVariable:20
外部的commonVariable:2
outerStaticVariable:3
外部类普通方法，outerMethod===========================
外部类静态方法，outerMethodStatic====================

 总结：

1. 仅在此方法内使用。
2. 可以随意的访问外部类的任何信息。
3. 内部类和外部类的同名属性不会覆盖

修改如下图：

 已被赋值且始终未改变的变量（有且仅有赋值一次）,引用指向不能改变

 

  （3）匿名内部类

           因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

           但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

 1：不适用内部类实现

package ***********.test.inner;

public class Anonymous {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

abstract class  Person{
    public abstract void eat();
}
class Child extends Person{

    @Override
    public void eat() {
        System.out.println("eat something");
    }
}

2：方式一，使用抽象类

package ************.test.inner;

public class AnonymousAbstract {
    public static void main(String[] args) {
        Person1 p = new Person1() {
            @Override
            public void eat() {
                System.out.println("eat =======================");
            }
        };
        p.eat();
    }
}

abstract class Person1{
    public abstract void eat();
}

3：方式二：使用接口实现

interface Person {
    public void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现