成员内部类、静态内部类、局部内部类、匿名内部类

内部类

内部类可以直接访问外部类的成员

public class Outer {
int num = 10;
class Inner {
public void show() {
System.out.println("num=" + num);
}
}

public static void main(String[] args) {
Outer.Inner inner = new Outer().new Inner();
inner.show();
}
}

运行结果



外部类访问内部类的成员，需要创建内部类的对象

public class Outer1 {
Inner inner = new Inner();

public void show() {
int num = inner.num = 20;
System.out.println("num=" + num);
}

class Inner {
int num;
}

public static void main(String[] args) {
Outer1 outer = new Outer1();
outer.show();
}

}

运行结果

静态内部类

内部类中有静态方法，那么这个内部类就是静态内部类

静态内部类不需要外部类对象

public class Outer3 {
static int num = 10;
static class Inner {
public static void show() {
System.out.println("num=" + num);
}
}
public static void main(String[] args) {
Outer3.Inner inner = new Outer3.Inner();
inner.show();
}
}

运行结果



静态内部类不能访问外部类的非静态属性和方法

成员内部类

如何new对象

外部类.内部类 对象名=new 外部类（）.new 内部类

public class Outer {
int num = 10;
class Inner {
public void show() {
System.out.println("num=" + num);
}
}

public static void main(String[] args) {
//Outer.Inner inner = new Outer().new Inner();
//相当于  Outer outer=new Outer();
// Outer.Inner inner=outer.new Inner();
Outer.Inner inner = new Outer().new Inner();
inner.show();
}
}

运行结果



使用成员内部类会造成内存泄漏，内存越用越少。因为你在释放外部类对象的时候，内部类持有外部类对象的引用，GC不能回收

局部内部类

在外部类的方法中定义一个内部类，叫做局部内部类

public class Outer4 {
private String name;
private int age;

public void show() {
class Inner {
public void showInner(String name, int age) {
System.out.println(name + "今年" + age + "岁");
}
}
Inner inner = new Inner();
inner.showInner("小明", 15);
}

public static void main(String[] args) {
Outer4 outer = new Outer4();
outer.show();
}

}

运行结果



局部内部类访问方法中的变量，变量需定义成final修饰的，在内部类中访问局部变量，而定义的这个局部变量在之后还会使用，如果不定义成final修饰的，变量会随着方法的结束从栈内存中消失，就会导致局部内部类不能访问局部局部变量。

Inner类

public abstract class Inner {
public abstract void show();
}

Outer类

public class Outer {
public Inner showInner(){
final int i=10;
Inner inner=new Inner() {
@Override
public void show() {
System.out.println("i="+i);
}
};
return inner;
}
public static void main(String[] args) {
Outer outer=new Outer();
Inner inner=outer.showInner();
inner.show();
}
}

运行结果

匿名内部类

匿名内部类只使用一次

Animal类

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

测试类

public class Test {

class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫在吃老鼠");
}
}
public static void main(String[] args) {
new Animal() {
@Override
public void eat() {
System.out.println("猫在吃鱼");
}
}.eat();
}
}

运行结果