内部类分类介绍JAVA224-225

来源：http://www.bjsxt.com/
一、S03E224_01内部类分类介绍_静态内部类详解、成员内部类详解

1、内部类介绍

package com.test.nestedclass;
/**
 * 测试内部类的基本定义方式
 */
public class Demo01 {
    //静态内部类
    private static class StaticNestedClass{
    }

    //普通内部类(成员内部类)
    private class FieldInnerClass{
    }

    void sayHello(){
        //方法内部类(局部内部类)
        class LocalClass{
        }

        //匿名内部类。放到方法外面也可以，只是类型不一样了(不同位置不同类型)。
        Runnable runnable = new Runnable() {//两个作用：定义了匿名内部类的类体；创建了匿名内部类的一个实例！
            @Override
            public void run() {
            }
        };
    }
}

2、静态内部类

package com.test.nestedclass;

import com.test.nestedclass.Outer02.StaticInnerClass;
/**
 * 测试静态内部类的详细用法
 */
public class Demo02{
    public static void main(String[] args) {
        //这样写比较明显，看得出外部类
        Outer02.StaticInnerClass osic = new Outer02.StaticInnerClass();

        //在不相关类(Demo02)中，可直接创建静态内部类的对象(不需要通过所在外部类(Outer02))
//      StaticInnerClass osic2 = new StaticInnerClass();//import com.test.nestedclass.Outer02.StaticInnerClass;
    }
}

class Outer02 {
    int c = 5;
    static int d = 10;

    void t1(){
        StaticInnerClass sic = new StaticInnerClass();
    }
    //静态内部类
    /*private*/ static class StaticInnerClass {
        int a = 3;
        static int b = 5;//可包含静态成员、非静态成员

        public void test(){
            System.out.println(d);
//          System.out.println(c);//静态内部类中不能调用外部类的普通成员！只能调用静态成员！
        }
    }
}

3、成员内部类(普通内部类)

package com.test.nestedclass;
/**
 * 测试成员内部类的详细用法
 */
public class Demo03 {
    public static void main(String[] args) {
        Outer03 out = new Outer03();
        Outer03.InnerClass ic = out.new InnerClass();//先有外部类对象，才可创建内部类对象
        ic.test();
    }
}

class Outer03{
    private int a = 3;
    int b = 10;

    public void t1(){
        InnerClass ic = new InnerClass();//方法内可直接创建内部类对象
    }
    //成员内部类，相当于外部类的成员变量，可访问外部类的所有成员
    class InnerClass{
        int c = 1;
        //成员内部类不能有静态成员，除非声明为final，并且只能是编译器可以确定值的常量表达式
        final static int d = 80;
//      final static Date d2 = new Date();

        //如果成员内部类可以有静态成员，如下：
//      static InnerClass ab = new InnerClass();
        //则Outer03.InnerClass.ab可以直接获取内部类对象，这时成员内部类对象就完全脱离了外部类的控制！与设计成员内部类的初衷完全不一致！

        void test(){
            System.out.println(a);
            //方法内
            System.out.println("内部类对象：" + this);//成员内部类对象的创建。必须先有外部类对象！
            System.out.println("外部类对象：" + Outer03.this);//引用了外部类的对象！
        }
    }
}

二、S03E225_01方法内部类_final修饰局部变量问题、匿名内部类(继承式和接口式和参数式)

1、方法内部类(局部内部类)

package com.test.nestedclass;
/**
 * 测试方法内部类(局部内部类)
 */
public class Demo04 {
    public static void main(String[] args) {
    }
}

class Outer04{

    public void test(){
        /*final*/ int a = 3;

        class Inner{
            int b = 10;
//      static int c = 20;//方法内部类中只能定义非静态成员

            void t1(){
                System.out.println(b);
//              System.out.println(a);
                //方法内部类中不能引用所在方法的普通局部变量，除非是常量。原因如下：
                //方法的生命周期和方法内部类对象的生命周期不一致！方法执行完，内部类对象可能仍然存在！
            }
        }
    }
}

2、匿名内部类

package com.test.nestedclass;
/**
 * 测试匿名内部类
 */
public class Demo05 {
    public static void main(String[] args) {
        Outer05 outer = new Outer05();
        outer.test();
    }
}

class Outer05{
    public void test02(Car car){
        car.run();
    }

    public void test(){
        final int a = 3;
        //匿名内部类(接口式)，由于本内部类定义在方法中，也是方法内部类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
            }
        };

        //匿名内部类，继承式
        Car car = new Car(){
            @Override
            public void run() {
                System.out.println("子类的车跑！");
                System.out.println(a);
            }
        };
        car.run();

        test02(new Car(){
            @Override
            public void run() {
                System.out.println("参数式匿名内部类，车在跑！");
            }
        });
    }
}

class Car{
    public void run(){ 
        System.out.println("汽车跑！");
    }
}