内部类应用场景
描述事物A时，发现需要在事物A内部，封装一个能访问A属性等数据的事物B来只服务于事物A。
即如果一个类附属于另一个类且只应用于这个类，则可以用内部类，比如Android的Adapter里的ViewHolder。
使用内部类的优势
可以把内部类隐藏在外部类内，不允许同一个包中的其他类访问该类。
内部类定义于外部类的成员变量位置，因此内部类可以使用任意访问控制符，如 public 、 protected 、 private 等，同时也可以访问外部类任意数据。
内部类隐式的持有了一个外部类的引用，所能用外部类全部属性，要想打破引用就要用静态内部类。
可以实现多重继承。
成员内部类
public static void main(String[] args) {
Outer.Inner inner = new Outer().new Inner();
inner.test();
}
class Outer {
public int i = 1;
class Inner {
public int i = 2;
public void test() {
System.out.println("避免就近原则，调用外部类同名变量" + Outer.this.i);
}
}
}
静态内部类
public static void main(String[] args) {
Outer.Inner inner = new Outer.Inner();//注意调用方式
inner.test();
}
class Outer {
public static int i = 1;
static class Inner {
public void test() {
System.out.println("静态内部类只能引用外部类的静态成员" + i);
}
}
}
局部内部类
class Outer {
public void test() {
class Inner {
public void innerTest() {
System.out.println("InnerTest" );
}
}
Inner inner = new Inner();
inner.innerTest();
}
}
//调用内部类方式
Outer outer = new Outer();
outer.test();
局部内部类访问局部变量问题
class Outer {
int num = 3;
public void test() {
//JDK低于1.8
//final int x = 9;
//JDK1.8
int x = 9;
class Inner {
public void show() {
System.out.println("Inner...." + x);
}
}
Inner inner = new Inner();
inner.show();
}
}
如果你的JDK为1.8以下，想访问就要把局部变量声明成final，而1.8后的JDK不需要(JDK1.8帮你隐藏了，实际还是存在final)。
至于为什么访问就要把局部变量声明成fianl？
因为局部变量的生命周期是一旦出作用域就马上被释放，然而这时new Inner这个对象还在等待Java垃圾回收机制来回收并没有马上释放消失，相应的它内部访问局部变量也没有消失。
如此给人的感觉就是这个局部变量的生命周期延长了，这就违背Java的设计原则了。
所以Sun想了解决方案，如果一个局部内部类访问一个局部变量的时候，那就让该局部内部类访问该局部变量的复制品。
如此什么复制品？
完全一样的才是复制品。
为了保证值完全一样不能随意变换，所以这个变量要声明成final。
匿名内部类
没有类名的类就称作匿名内部类，只是没有类名，类的其他成员都具备。
匿名内部类的好处
简化书写，能尽快的释放空间（作为实参传值，出作用域就释放）。
继承方式的匿名内部类
abstract class Demo {
public abstract void read();
}
public class Run {
public static void main(String[] args) {
//注意这里创建的是继承Demo类的子类对象
new Demo() {
@Override
public void read() {
System.out.println("Read");
}
}.read();
}
}
如果想通过匿名内部类实现调用多个方法，需要将返回值设为基类
abstract class Demo {
public abstract Demo read();
public abstract Demo write();
}
public class Run {
public static void main(String[] args) {
// 注意这里是继承Demo类的对象
new Demo() {
@Override
public Demo read() {
System.out.println("Read");
return this;
}
@Override
public Demo write() {
System.out.println("Write");
return this;
}
}.read().write();
}
}
如果匿名内部类中定义了其特有的方法，想都不要想调用，不明白的去看我写的多态篇找原因。
实现方式的匿名内部类
//接口
interface Demo {
void read();
}
//测试类
class Test {
public void test() {
//注意：这是匿名的接口实现类对象，不是接口new。
new Demo() {
@Override
public void read() {
System.out.println("read");
}
}.read();
}
}
public class Run {
public static void main(String[] args) {
Test test = new Test();
test.test();
}
}
在实际开发中匿名内部类一般用于实参
假设有一个函数的形参需要传一个接口类的实参，这个实参仅在用时调用。
如果专门去写一个实现类是不是太low，那么这时候就可以用上匿名内部类。
interface Demo {
void read();
}
public class Run {
public static void main(String[] args) {
test(new Demo() {
@Override
public void read() {
System.out.println("Read");
}
});
}
public static void test(Demo demo) {
demo.read();
}
}
