java内部类（普通内部类、方法内部类、静态内部类、匿名内部类）

java内部类通常分为普通内部类、方法内部类、静态内部类、匿名内部类，这里分别讲解。

一、普通内部类：(内部类是外部类的一个成员但是也是一个类)
(不能定义静态内容只能定义静态常量且常量要赋字面值)
1、外部类成员访问内部类的成员：创建内部类实例

public class TestInner {
            public static void main(String[] args) {
                new Outer().method();
            }
        }
        class Outer{
            String name;
            int age;
            public void method() {
                System.out.println("外部内成员方法");
                Inner inner = new Inner();
                System.out.println("输出内部类num="+inner.num);
            }
            class Inner{
                int num = 10;
            }
        }

    2、其他类访问内部类：
        a.创建内部类对象：创建时要求必须保证外部类对象存在  
        b.外部类.内部类 变量名= new 外部类().new 内部类();
        Outer.Inner inner = new Outer().new Inner();
     3、内部类访问外部类成员：
          a.要是内部类中成员名字和外部内成员名字相同，直接使用就是就近原则，
            如果需要使用外部类成员，用外部类名.this.成员变量名
            例如：

                class Outer{
                    int num = 10;
                    class Inner{
                      int num = 20;
                      System.out.println(Outer.this.num);//这就是调用外部类的同名成员
                    }
                }

二、方法内部类
1.见名知其意，这个内部类是在方法中的，所以这个类是局部变量，具有局部变量的特性，局部变量不能用static关键字修饰：

    class Outer2{
    int age;
    String name;
    public void method(){//static不能修饰局部变量。
        class Inner{//首次这个类是这个方法里面的，只能是一个局部变量。
           int num = 9;
        }
    }
}

2、外界类不能访问方法内部类，换句话说，成员方法中的内容是不能被访问的，方法中的内容需要访问方法内部类，也是创建
  对象的方式访问。
3、方法内部类可以缩减内存开销，因为局部变量生命周期短。

三、静态内部类
1、静态内部类需明确的是它是一个外部类的静态成员，同时是一个类。
2、外部类成员访问静态内部类时：
a.访问静态内部类的非静态成员，创建实例对象
b.访问静态内部类的静态成员，直接通过类名.

    class Outer3{

    public void method() {
        System.out.println(Inner.num);//非静态
        System.err.println(new Inner().temp);//静态
    }
    static class Inner{
        static int num = 20;
        int temp = 40;
    }
}

3、静态内部类访问外部类的成员
  a.非静态成员，创建外部类实例对象访问
  b.静态成员，直接用
  c.提示：成员变量和成员方法一样，方法自行验证。

    class Outer3{
    static int num1 = 10;
    int num2 = 20;
    static class Inner{
        public void inMethod() {
            System.out.println(num1);
            System.out.println(new Outer3().num2);
        }
    }
}

4、外界类访问静态内部类中的内容
  a.访问静态内部类的静态内容
     外部类名.内部类名.静态成员名
  b.访问非静态内部类的非静态内容（创建一个静态内部类实例）
     外部类名.内部类名().静态成员名

public class Test {
    public static void main(String[] args) {
        System.out.println(Outer3.Inner.temp2);
        System.out.println(new Outer3.Inner().temp1);
    }
}
class Outer3{
    static class Inner{
        int temp1 = 21;
        static int temp2 = 11;
    }
}

四、匿名内部类
1、可以用来创建接口的实现类对象或抽象类的子类对象
而这些对象只需要被使用一次，用匿名内部类实现，使
用完就可以被回收，减少内存压力。
2、使用方法：
new 接口/抽象类(){
重写所有的抽象方法;
};
3、不使用匿名内部类和使用匿名内部类的代码区别
a.不使用匿名内部类代码：

    public class Test{
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.run();
    }
}
interface Animal{
    public void run();
}
class Dog implements Animal{

    @Override
    public void run() {
        System.out.println("狗会跑步！！！");
    }
}

b.使用匿名内部类代码：

  public class Test{
    public static void main(String[] args) {
        Animal animal = new Animal() {
            @Override
            public void run() {
                System.out.println("狗会跑步！！！");
            }
        };
        animal.run();
    }
}
interface Animal{
    public void run();
}

java内部类（普通内部类、方法内部类、静态内部类、匿名内部类）

猜你喜欢