内部类（java）

内部类的概念与分类

• 如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一 个类。
• 例如:
  身体和心脏的关系。又如:汽车和发动机的关系。
• 分类:

成员内部类
局部内部类(包含匿名内部类) |

成员内部类的定义与使用

• 成员内部类的定义格式:

修饰符 class 外部类名称{
  修饰符 class 内部类名称{
    // …
  }
  // …
}

• 注意:
  内用外，随意访问;外用内，需要内部类对象。
• 代码示例：

public class Body { //外部类

    public class Heart {    //成员内部类
        //内部类的方法
        public void beat() {
            System.out.println("心脏跳动，砰砰砰");
            System.out.println("我叫" + name);    //正确写法
        }
    }

    //外部类的成员变量
    private String name;

    //外部类的方法
    public void methodBody() {
        System.out.println("外部类的方法");
        new Heart().beat();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

• 如何使用成员内部类?有两种方式:

间接方式:在外部类的方法当中，使用内部类;然后main只是调用外部类的方法。
直接方式：公式:
类名称对象名= new 类名称();
【外部类名称. 内部类名称对象名= new外部类名称(). new内部类名称();】

• 代码示例：
  主函数：

public class InnerClass {
    public static void main(String[] args) {
        Body body = new Body(); //外部类的对象
        //通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
        body.methodBody();

        //按照公式写：
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

内部类的同名变量访问

• 如果出现了重名现象，那么格式是:

外部类名称. this.外部类成员变量名

• 代码示例：

类：

public class Outer {
    int num = 10;   //外部类的成员变量

    public class Inner {
        int num = 20;   //内部类的成员变量

        public void methodInner() {
            int num = 30;   //内部类方法的局部变量

            System.out.println(num);    //局部变量.就近原则
            System.out.println(this.num);   // 内部类的成员变量
            System.out.println(Outer.this.num); //外部类的成员变量
        }
    }
}

主函数：

public class InnerClass {
    public static void main(String[] args) {
        Body body = new Body(); //外部类的对象
        //通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
        body.methodBody();

        //按照公式写：
        Body.Heart heart = new Body().new Heart();
        heart.beat();
        
        Outer.Inner inner = new Outer().new Inner();
        inner.methodInner();
    }
}

局部内部类

定义

• 如果一个类是定义在一个方法内部的， 那么这就是一个局部内部类。
• “局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
• 定义格式:

修饰符 class 外部类名称 {
  修饰符 返回值类型 外部类方法名称(参数列表) {
    class局部内部类名称{
      // …
    }
  }
}

• 代码示例：

类：

public class Outer {
	public void methodOuter() {
		class Inner { //局部内部类
			int num = 10;
			public void methodInner() {
				System. out. print1n(num); // 10 
			}
		}
		Inner inner = new Inner();
inner methodInner();
}

主函数：

public class InnerClass {
    public static void main(String[] args) {
        Body body = new Body(); //外部类的对象
        //通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
        body.methodBody();

        //按照公式写：
        Body.Heart heart = new Body().new Heart();
        heart.beat();
        
        Outer.Inner inner = new Outer().new Inner();
        inner.methodInner();
    }
}

final问题

• 局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是**【有效final的】**
• 备注：
  从java 8+开始，只要局部变量事实不变，那么final关键字可以省略。
• 原因：
  1、new出来的对象在堆内存当中。
  2、局部变量是跟着方法走的，在栈内存当中。
  3、方法运行结束之后，立刻出栈，局部变量就会立刻消失。
  4、但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
• 代码示例：

public class MyOuter {
    public void methodOuter() {
        int num = 10;   //所在方法的局部变量

        class MyInner {
            public void methodInner() {
                System.out.println(num);
            }
        }
    }
}

匿名内部类

定义

• 如果接口的实现类（或者是父类的子类）只需要使用唯一的一次
• 那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。
• 匿名内部类的定义格式:

接名称 对象名 = new 接口名称() {
  //覆盖重写所有抽象方法
};

• 代码示例：

抽象接口：

public interface MyInterface {
    void method();  //抽象方法
}

匿名内部类

public class Main01 {
    public static void main(String[] args) {
        //试用匿名内部类
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法！");
            }
        };
        obj.method();
    }
}

注意事项：

• 对格式"new 接口名称(）{…}"进行解析:
  1、new代表创建对象的动作
  2、接口名称就是匿名内部类需要实现哪个接口
  3、{…}这才是匿名内部类的内容
• 另外还要注意几点问题:
  1、匿名内部类，在【创建对象】的时候，只能使用唯——次。
  如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
  2、匿名对象，在【调用方法】的时候，只能调用唯——次。
  如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
  3、匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
• 强调：匿名内部类和匿名对象不是一回事!!!