面向对象-内部类

如果一个事物的内部包含另一个事物，那么这就是一个内部包含另一个类

• 例如：汽车和发动机

分类：

• 1.成员内部类

• 2.局部内部类，(包含匿名内部类)

• 注意：内用外，随意访问；外用内，需要内部对象

如何使用成员内部类？两种方式：

• 1.间接方式：在外部类的方法中，使用内部类，main方法调用外部类方法

• 2.直接方式： 通过对象访问
  公式：

外部类名称.内部类名称  对象名 = new 外部类名称().new 内部类名称();`

//定义一个类，其中有内部类
public class Body {
    private String name;
    //内部类
    public class Heart {
        public void beat() {//内部类成员方法
            System.out.println("内部类方法");
            //访问外部类成员变量
            System.out.println("我叫" + name);
        }
    }
    public void method(){
            System.out.println("外部类方法");
            //创建内部类对象，使用其中方法
            new Heart().beat();
    }


public class Demo01 {
    public static void main(String[] args) {
        //间接访问，创建外部类对象，掉调用方法，来实现间接访问
        Body body = new Body();
        body.method();

        //直接访问，直接创建内部类对象
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

变量重名现象：
那么格式是：外部类名称 . this . 外部类成员变量名

public class Outer { 
    //外部类成员变量
    int num = 10;
    public class Inner{
        //内部类成员变量
        int num = 20;
        public void method(){
            //局部变量
            int num = 30;
            System.out.println(num);//30
            System.out.println(this.num);//20
            System.out.println(Outer.this.num);//10
        }
    }
}

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

修饰符 类名称{
      修饰符 返回值类型 方法名称(){
               class 局部类名称{
                   //...
               }
       }
 }

定义一个类的时候，权限修饰符规则：

• 1.外部类：public / (default)
• 2.成员内部类：public protected (default) private
• 3.局部内部类：什么都不写

局部内部类如果希望访问局部成员变量
那么这个变量就必须是有效final的
备注：从java8开始，只要局部变量事实不变，那么final关键字可以省略
原因：

• 内存位置不一样
• new出来的都在堆内存中，局部变量跟着方法走，在栈内存中，
• 方法运行结束后，就弹栈了，局部变量就因此而消失，
• 但是new出来的对象会在堆内存中持续存在，直到垃圾回收

public class Outer {
    //成员方法
    public void method(){
        //局部内部类访问局部变量，
        /* final */int num = 10;
        class Inner{//局部内部类
            public void show(){
                System.out.println(num);//访问局部变量
            }
        }
        //在方法中创建局部内部类对象，访问其中方法
        Inner inner = new Inner();
        inner.show();
    }
}

匿名内部类：
如果接口的实现类(或者是父类的子类)只需要使用唯一的一次
那么这种情况就可以省略掉该类的定义，直接使用匿名内部类

匿名内部类定义格式：

  接口名称 对象名 = new 接口名称(){
        //覆写所有抽象方法
  }
  对格式“new 接口名称(){...}”解析
 1.new 代表创建对象的动作
 2.接口名称 就是匿名内部类需要实现的那个接口
 3.{......} 这才是匿名内部类的内容

另外还要注意几点问题：

• 1.匿名内部类，在创建对象的时候，只能使用唯一一次
  如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了

• 2.匿名对象，在调用方法的时候，只能调用唯一一次
  如果希望同一个对象，调用多次方法，那么必须给对象起个名字

• 3.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
  强调：匿名内部类和匿名对象不是一回事！

//一个接口
public interface MyInterface {
    接口中的抽象方法
    public abstract void method();
    public abstract void show();
}

public class Demo {
    public static void main(String[] args) {
        //这个匿名内部类的对象名叫obj
        MyInterface obj = new MyInterface() {
            public void method(){
                System.out.println("匿名内部类实现了方法");
            }
            public void show(){
                System.out.println("匿名内部类其他方法");
            }
        };//.method 匿名对象只能调用唯一一次方法，如果有多个方法，需要起名字
        
        //对象调用方法
        obj.method();
        obj.show();
    }
}