6.7内部类:概念，分类，定义，使用，变量访问

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类：
例如：
身体和心脏的关系

• 分类：
  1.成员内部类
  2.局部内部类（包含匿名内部类）

成员内部类的定义格式：
修饰符class类名称{
  修饰符 class 类名称{
       //...
    }
  //...
}

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

---

如何使用内部类？两种方式：
1.间接方式：在外部类的方法当中，使用内部类；然后main值是调用外部类的方法。
2.直接方式：公式。外.内
【外部类名称.内部类名称 对象名 = new 外部类名称（）.new 内部类名称（）；】

package InnerClass;

public class Body {//外部类
    public class Heart {
        //内部类方法
        public void beat() {
            System.out.println("心脏跳动");
            System.out.println("我叫：" + name);
        }
     }
        //外部类的成员变量
        private String name;

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

        //外部类的方法
        public String getName() {
            return name;
        }

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

package InnerClass;

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

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

---

如果出现了重名现象，那么格式是：外部类名称.this.内部类成员变量名

package InnerClass;

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);//外部类的成员变量
        }
    }
}

package InnerClass;

public class Demo02InnerClass {
    public static void main(String[] args) {
        Outer.Inner obj = new Outer().new Inner();
        obj.methodInner();
    }
}

---

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

修饰符 class 外部类名称{
修饰符 返回值类型 外部类的方法名称（参数列表）{
class 局部内部类名称{
//...
}
}
}

---

小结类的权限修饰符
public > protected > (default) >private
定义一个类的时候，权限修饰符规则：

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

package InnerClass;

public class OuterDemo03 {
    public void methodOuter(){
        class Inner{
            int num = 10;
            public  void methodInner(){
                System.out.println(num);
            }
        }
        Inner inner = new Inner();
        inner.methodInner();
    }
}

package InnerClass;

public class Demo03jbInnerClass {
    public static void main(String[] args) {
        OuterDemo03 obj = new OuterDemo03();
        obj.methodOuter();
    }
}

---

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

package InnerClass.final_;

public class MyOuter {
    public void methodOuter(){
        int num = 10;//所在方法的局部变量
        class  MyInner{
            public  void methodInner(){
                System.out.println(num);
            }
        }
    }
}