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);
}
}
自动生成了带参数的构造方法，并调用了父类的同参数的构造方法
- 特性
- 匿名内部类由于没有名字，故无法定义构造方法,但编译后会生成构造方法根据传入的参数
- 匿名内部类编译后生成的.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的关系。所以，这并不符合常理。
- 解决命令冲突(例如抽象类的方法和接口中的方法同名)
- 方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏
内部类问题
1. 局部内部类访问局部变量，该变量必须声明为final类型 ，但如何又可以改变该变量
解决办法:
将该变量可以生命为数组类型
eg:
final int[] counter = new int[1];
这样可以使counter中的内容发生改变
