关于内部类的一些Demo要点

内部类的种类

package com.dasenlin.innerclas;
/**
 * 内部类的一些示例
 * @author Administrator
 *
 */
public class DasenlinInnerClass {
    //静态内部类 //类似于静态变量
    private static class StaticNestedClass{

    }
    //普通内部类（成员内部类）
    private  class FieldInnerClass{

    }
    Runnable able =new Runnable(){//两个作用：定义了匿名内部类的类体;创建了匿名内部类的实例；
        @Override
        public void run() {
        }           
    };//一般不会放在这里；

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

        }
        //匿名内部类
        Runnable able =new Runnable(){//两个作用：定义了匿名内部类的类体;创建了匿名内部类的实例；
            @Override
            public void run() {
            }           
        };
    }

}

静态内部类

package com.dasenlin.innerclas;

import com.dasenlin.innerclas.Outer02.StatInnerClass;

/**
 * 测试静态内部类的一些方法
 * @author Administrator
 *
 */
public class StaticInnerClass {

    public static void main(String[] args) {
    //  Outer02.StatInnerClass sic =new Outer02.StatInnerClass();
        StatInnerClass sicl =new StatInnerClass();//也可以直接调用；
    }
}
class Outer02{
    int c = 5;
    static int d = 10;
    //静态内部类
    /*private*/ static class StatInnerClass{
        int a =3;
        static int b=5;

        public void test(){
            System.out.println(a);
            System.out.println(b);
            System.out.println(d);
            //System.out.println(c);//静态内部类不能调用外部类的非静态成员；
        }
    }
}

方法内部类

package com.dasenlin.innerclas;
/**
 * 方法内部类
 * @author Administrator
 *
 */
public class MethodInnerClass {

    public void test(){
        int a=3;
        class Inner{
            int b=10;
            //static int c=20;//方法内部类只能定义非静态成员
            void tt(){
                System.out.println(b);
                //System.out.println(a);//方法内部类中不能引用所在方法的普通局部变量，除非是常量。
                //方发的生命周期和方法内部类对象的生命周期不一致！
            }
        }
    }
}

内部类与外部类的调用关系

package com.dasenlin.innerclas;
/**
 * 内部类与外部类关系的调用
 * @author Administrator
 *
 */
public class OuterClas03 {

    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 ttt(){
        InnerClass ic = new InnerClass();
    }
    //在一个非静态类成员内部类不能有静态成员，但是申明一个常量就可以。
    class InnerClass{

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

匿名内部类的调用方式

package com.dasenlin.innerclas;
/**
 * 匿名内部类的一些方法
 * @author Administrator
 *
 */
public class Demo05 {
    public static void main(String[] args) {
        Outer05 out =new Outer05();
        out.test();
    }
}
class Outer05{
    //参数式调用
    public void test02(Car c){
        c.run();
    }
    public void test(){
        //匿名内部类，由于本内部类定义在方法中，也是方法内部类
        Runnable runnable = new Runnable(){
            @Override
            public void run() {

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

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