一个事物的内部包含另一个事物。一个类里面包含另一个类，这个类叫内部类，包含它的叫它外部类。
例如：身体和心脏的关系；汽车和引擎的关系。
心脏、引擎只有在身体和汽车中才有用。内部类也一样。
分类：
1.成员内部类；
2.局部内部类（包括匿名内部类）；
1.成员内部类
/*
修饰符 class 外部类名称{
修饰符 class 内部类名称{
......
}
......
}
*/
public class Outer {
private String name;
public class Inter{
public void InterMethod(){
System.out.println("内部方法");
System.out.println("姓名:" + name); // 成员内部类可以访问外部类属性
}
}
public void fun1(){
Inter in = new Inter();
in.InterMethod();
}
}
编译后，这个类的class文件保存在磁盘里
内部类的使用方式
在外部类中可以直接通过 new 对象的方式使用。
在其他类中访问：
1.间接方式：在外部类的方法中使用内部类，而在其他类中使用就 new 外部类调用这个方法；
/** * 其他类使用内部类 */ public class OuterDemo1 { public static void main(String[] args) { Outer out = new Outer(); out.fun1(); } }
2.直接方式，直接创建出内部类
公式: 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称()；
public class OuterDemo2 { public static void main(String[] args) { Outer.Inter in = new Outer().new Inter(); in.InterMethod(); } }
问题:在外部类、内部类、内部类方法体出现相同名称属性，如何输出相应的值呢？
解决:
public class OuterDemo3 {
private String name ="外";
class Inter{
private String name = "内";
public void interMethod(){
String name = "方法";
System.out.println(name); // 输出: 方法，就近原则
System.out.println(this.name); // 输出: 内
System.out.println(OuterDemo3.this.name); // 输出: 外
}
}
}
2.局部内部类
在方法体内定义一个类，出了这个方法，就无法使用这个类（所以其他类无法使用【局部内部类】）
普及：
权限修饰符的使用规则:
public > protected > (default) > private
1.外部类：能使用 public / (defautl) 修饰
2.成员内部类： publi / protected / (default) / private
3.局部内部类：什么都不写
public class Test {
public void fun(){
final int num = 100;
class Fun{
private void fun2(){
System.out.println(num);
}
}
Fun fun = new Fun();
fun.fun2();
}
}
问题：为什么访问所在方法的局部变量，必须要有final修饰？
原因（本质是生命周期问题）：
1.内部类 new 出来的对象在堆内存中；
2.局部变量跟着方法，在栈内存中；
3.方法运行完，立刻出栈，局部变量隔着消失；
4.但 new 出来的对象，会在堆内存持续存在，知道垃圾回收；
5.所以，要将该内存复制到常量池才能保存继续使用。
3.匿名内部类（重要）
往常，我们要使用接口方法，得先定义该接口的实现类 -> 重写该接口的所有抽象方法 -> new 实现类使用。
而如果接口的实现类只是用唯一的一次，那么这种情况就可以省略该实现类的定义，而改为使用 【匿名内部类】
接口
public interface MyInteface { void method(); }
使用【匿名内部类】
/**
* 格式：
* 接口名称 对象名 = new 接口名称(){
* // 覆盖重写所有抽象方法
* };
*/
public class AnonymityTest2 {
public static void main(String[] args) {
MyInteface my = new MyInteface(){
@Override
public void method() {
System.out.println("匿名内部类方法");
}
};
my.method();
}
}
很多人一开始可能会有误解：不是【匿名内部类】吗？ MyInteface my = new MyInteface()}...} 这不是有名字么？
先看，对于" new MyInteface(){...};" 的解析：
1）new 代表对象创建的动作；
2）接口名称 【匿名内部类】要实现的接口；
3）{...} 这才是【匿名内部类】的内容，里面重写着接口的所有抽象方法
它光秃秃的，的确没名没姓的。
而 MyInteface my = new MyInteface()}...} 中的 my 是对象名，它是供你调用匿名类方法的对象。
ps:匿名内部类、匿名对象
1、【匿名内部类】表示，在创建对相爱那个是，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那还是单独定义实现类更方便。
public class AnonymityTest2 {
public static void main(String[] args) {
MyInteface my1 = new MyInteface(){
@Override
public void method() {
System.out.println("匿名内部类方法");
}
};
my1.method();
MyInteface my2 = new MyInteface(){
@Override
public void method() {
System.out.println("匿名内部类方法");
}
};
my2.method();
}
}
2.【匿名对象】表示，在调用方法时，只能调用唯一一次。
如果希望同一对象，调用多次方，那么还是给对象起个名把。
new MyInteface(){
@Override
public void method1() {
System.out.println("匿名内部类方法1");
}
@Override
public void method2() {
System.out.println("匿名内部类方法2");
}
}.method1();
new MyInteface(){
@Override
public void method1() {
System.out.println("匿名内部类方法1");
}
@Override
public void method2() {
System.out.println("匿名内部类方法2");
}
}.method2();
3. 【匿名内部类】是省略了 <实现类 / 子类>
【匿名对象】是省略了 <对象名称>
两者不是一回事。
public class AnonymityTest {
public static void main(String[] args) {
fun1();
}
private static void fun1() {
// 对于 Thread 来说，这就是【匿名对象】
// 对于 Runnable 来说，这就是【匿名内部类】
new Thread( new Runnable(){
@Override
public void run() {
}
}).start();
}
}