java内部类详解(Android常用)

1，成员内部类：直接在类中定义的类
2、方法内部类：在一个类中的方法内定义一个类
（1）方法内部类只能定义在改内部类的方法内实例化，不可以在此方法外对其实例化
（2）方法内部类对象不能使用该内部类所在方法的非final局部变量
3、静态内部类，在类定义一个静态修饰的内部类
与其他静态变量一样，没有外部的对象时，也能访问它，静态嵌套类仅能访问外部类的静态变量和方法
4、匿名内部类就是没有名字的内部类。三种情况：
（1）、继承式的匿名内部类
（2）、接口式的匿名内部类
（3）、参数式的匿名内部类

注意


/**
 * @program: shejizhe
 * @description:
 * @author: liust
 * @create: 2018-04-15 21:02
 * 1，成员内部类：直接在类中定义的类
 * 2、方法内部类：在一个类中的方法内定义一个类
 * （1）方法内部类只能定义在改内部类的方法内实例化，不可以在此方法外对其实例化
 * （2）方法内部类对象不能使用该内部类所在方法的非final局部变量
 * 3、静态内部类，在类定义一个静态修饰的内部类
 * 与其他静态变量一样，没有外部的对象时，也能访问它，
 * 静态嵌套类仅能访问外部类的静态变量和方法
 * 4、匿名内部类就是没有名字的内部类。三种情况：
 * （1）、继承式的匿名内部类
 * （2）、接口式的匿名内部类
 * （3）、参数式的匿名内部类
 **/
public class test {
    public static void main(String[] args) {
        Outer outer = new Outer();
     /*   //通常情况下不会这样实现内部类
        Outer.Inner inner = outer.new Inner();
        inner.print();*/
        outer.innerPrint();
        outer.show();
        //静态内部类中
        Outer.Inner3 inner3 = new Outer.Inner3();
        inner3.print();
        //继承式内部类
        outer.print1();
        //接口匿名内部类
        outer.print2();
        //参数式匿名内部类
        outer.print3(new Eat() {
            @Override
            public void eat() {
                System.out.println("参数式匿名内部类");
            }
        });
    }

}

class Outer {
    private String name = "小李";

    //通常这样提供方法提供内部类的使用
    public void innerPrint() {
        Inner inner = new Inner();
        inner.print();
    }

    //成员内部类
    class Inner {
        public void print() {
            System.out.println("inner");
        }
    }

    //方法内部类,不能再外部调用，只能使用final 变量
    public void show() {

        class Inner2 {
            public void print() {
                System.out.println("inner2" + name);
            }
        }
        Inner2 inner2 = new Inner2();
        inner2.print();
    }

    //静态内部类
    static class Inner3 {
        public void print() {
            System.out.println("inner3静态内部类");
        }
    }

    //匿名内部类
    //继承式匿名内部类
    public void print1() {
        Cat cat = new Cat() {
            @Override
            public void eat() {
                System.out.println("Cat:继承式匿名内部类");
            }
        };
        cat.eat();
    }
    //接口式匿名内部类
    public void print2() {
      Eat eat=new Eat() {
          @Override
          public void eat() {
              System.out.println("EAT:接口式匿名内部类");
          }
      };
      eat.eat();
    }
    //参数式匿名内部类
    public void print3( Eat eat) {

        eat.eat();
    }
}
interface Eat{
    public void eat();
}
abstract class Cat {
    public abstract void eat();
}

结果

怎么去选择使用

最后编辑于：2018.04.16 12:33:03