秦疆的Java课程笔记：76 面向对象 N中内部类-526互联

内部类就是在一个类的内部再定义一个类。比如，在A类中定义一个B类，那么B类相对于A类来说就是内部类；相反，A类相对于B类就是外部类。
秦疆老师声明，这小节主要是长长见识，实际编程作业中不推荐下列写法。

成员内部类

//先写一个有内部类的类=============================
public class Outer {  
    private int id = 114514;  
    public void out() {  
        System.out.println("这是外部类的方法");  
    }  
    public class inner {  
        public void in() {  
            System.out.println("这是内部类的方法");  
        }  
        //内部类可以获得外部类的私有属性、私有方法  
        public void getID() {  
            System.out.println(id);  
        }  
    }  
}
//测试类==========================================
import OOP.demo.Outer;  
public class Application {  
    public static void main(String[] args) {  
        Outer outer = new Outer();  
        outer.out();  
        //通过外部类实例化内部类  
        Outer.inner inner = outer.new inner();  
        inner.in();  
        inner.getID();  
    }  
}
====输出结果====
这是外部类的方法
这是内部类的方法
114514   //成功运行

静态内部类
将上述内部类添加static关键词，即是静态内部类

public class Outer {  
    private static int id = 114514;   //添加static修饰词
    public void out() {  
        System.out.println("这是外部类的方法");  
    }  
    public static class inner {   //添加static修饰词
        public void in() {  
            System.out.println("这是内部类的方法");  
        }  
        public void getID() {  
            System.out.println(id);  
        }  
    }  
}

这时getID()方法会报错，因为它调用了非静态的变量，所以也要给id加上静态修饰词。

局部内部类
方法中的内部类。

public class Outer {  
    public void method() {  
        class Inner {  
            public void in() {  
            }  
        }  
    }  
}

不常用，但看见了要知道是什么情况。

匿名内部类

public class Test {  
    public static void main(String[] args) {  
        //常规操作:  
        //Apple apple = new Apple();
		//apple.eat();
		//但匿名内部类不用将实例保存在变量中。  
        new Apple().eat();  
    }  
}  
class Apple{  
    public void eat() {  
        System.out.println("1");  
    }  
}

业务上有这样的玩法，即通过匿名内部类实现接口

public class Test {  
    public static void main(String[] args) {  
        new UserService() {  
            @Override  
            public void hello() {  
            }  
        };  
    }  
}  
interface UserService {  
    void hello();  
}

如果将之写成非匿名则是：

public class Test {  
    public static void main(String[] args) {  
        UserService userService =new UserService() {  
            @Override  
            public void hello() {  
            }  
        };  
    }  
}  
interface UserService {  
    void hello();  
}

这时IDEA会提示：匿名new UserService()可被替换为lambda。
如果使用IDEA的自动修改，则会变成：

public class Test {  
    public static void main(String[] args) {  
        UserService userService = () -> {  
        };  
    }  
}  
interface UserService {  
    void hello();  
}

看不懂没关系，因为这是之后要学的了。

关于这种写法：

public class A {  
}  
class B{  
}

这种不属于内部类，多个类是并行的。
可以有多个类，但是只能有一个public类。
可以在B类中写主程序方法，常用于随手测试代码的情况。