Java内部类 Java内部类

Java内部类分类 1. 成员内部类
相当于成员，和成员定义位置相同

public class Test { public static void main(String[] args) { //第一种方式： Outter outter = new Outter(); Outter.Inner inner = outter.new Inner(); //必须通过Outter对象来创建 inner.showInfo(); //第二种方式： Outter.Inner inner1 = outter.getInnerInstance(); inner1.showInfo(); } }class Outter { private int count = 10; private int outterCount = 10; private Inner inner = null; public Outter() {}public Inner getInnerInstance() { if (inner == null) inner = new Inner(); System.out.println(inner.count); return inner; }class Inner { private int count = 20; public Inner() {}public void showInfo() { System.out.println(count); System.out.println(outterCount); } } }

成员内部类由于包含外部类实例，故可访问外部类成员和方法即使是私有
当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员,需要Outter.this.xxx
外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问,可以访问私有变量和方法
成员内部类是外部类成员，故要创建成员内部类的对象，前提是必须存在一个外部类的对象。有如下两种创建方式：

//第一种方式： Outter outter = new Outter(); Outter.Inner inner = outter.new Inner(); //必须通过Outter对象来创建 //第二种方式： Outter.Inner inner1 = outter.getInnerInstance();

外部类只能被public和包访问两种权限修饰，但成员内部类拥有成员的修饰符特性，有4种 public,private,protected,默认

2. 局部内部类
相当于局部变量，定义位置和局部变量位置相同，定义在作用域(方法或者代码块内)

class Outter { public void method() { final int count = 20; class LocalInner { public void method() { System.out.println(count); } } new LocalInner().method(); }}

和局部变量一样不能使用任何的访问修饰符。
会生成两个.class文件，一个是Outter.class ，另一个是Outter$LocalInner.class。
局部内部类只能访问方法中声明的final类型的变量。
我们是无法在外部去创建局部内部类的实例对象的，因为局部内部类是定义在方法中的，而方法是需要所在类的对象去调用。

局部内部类在实际开发中用的并不多，不是很常见的，了解一下就好了。
3. 静态内部类

class Outter { private static int a = 20; public Outter() {}static class Inner { public Inner() { System.out.println(a); } } }

静态内部类就是一个普通类，只是位置在另一个类的内部，并不持有外围类的引用
只能访问外部类的静态成员变量或者静态方法
会生成两个.class文件，一个是外部的类Outter.class ，另一个是 Outter$Inner.class

4. 匿名内部类

本质：匿名内部类会隐式的继承一个类或者实现一个接口，或者说，匿名内部类是一个继承了该类或者实现了该接口的子类匿名对象。
格式:

new 类名/接口/抽象类(){}例如：new Interface(){}

实例：

public class Test { public static void main(String[] args) { // 匿名内部类1 如果Air是类，则根据参数使用对应构造方法 Air air = new Air("rocket") { @Override void fly() { System.out.println("fly"); } }; air.fly(); // 匿名内部类2 该匿名类使用类的默认构造方法也就是空构造方法 Fly fly = new Fly() { @Override public void fly() { System.out.println("fly"); } }; fly.fly(); } }abstract class Air { public Air(String s) { System.out.println(s); }abstract void fly(); }interface Fly { void fly(); }

输出

rocket fly fly

编译代码后匿名内部类1会生成Test$1.class, 反编译该字节码得到

static class Test$1 extends Air {void fly() { System.out.println("fly"); }Test$1(String s) { super(s); } }

【Java内部类】自动生成了带参数的构造方法，并调用了父类的同参数的构造方法

特性

匿名内部类由于没有名字，故无法定义构造方法,但编译后会生成构造方法根据传入的参数
匿名内部类编译后生成的.class文件的命名方式是”外部类名称$编号.class”，编号为1，2，3…n，编号为x的文件对应的就是第x个匿名类
匿名内部类

为什么需要内部类

可以弥补没有多继承的缺陷

public class Test { public static void main(String[] args) { Swan swan = new Swan(); swan.fly(); swan.swim(); } }abstract class FlyingAnimal { abstract void fly(); }abstract class SwimmingAnimal { abstract void swim(); }class Swan extends FlyingAnimal {@Override void fly() { System.out.println("Swan.fly()"); }void swim() { this.getSwimming().swim(); }SwimmingAnimal getSwimming() { return new SwimmingAnimal() {@Override void swim() { System.out.println("Swan.swim()"); }}; } }

Swan继承了FlyingAnimal，无法再继承SwimmingAnimal，此时可通过如上匿名内部类方式解决问题
但是，这种设计方式，有明显的缺陷。因为，Swan类本身只继承了FlyingAnimal类，所以它和FlyingAnimal是is - a的关系，它和SwimmingAnimal并没有继承关系，所以并不是is-a的关系，其实更像一种has - a的关系。所以，这并不符合常理。