十五、OOP之理解《各种内部类》

看完了面向对象。看完了封装，继承接下来介绍一下内部类和权限修饰符

一、内部类

1、顾名思义，定义在内部的类，可以定义在方法中，也可以定义在类中，方法外

2、根据定义的位置不同：

(1) 成员内部类：
① 普通的成员内部类
② 私有的成员内部类
③ 静态的成员内部类

(2) 局部内部类
了解了分类，下面进行详细介绍

（1）成员内部类

1、定义在成员位置上的类
2、格式：

class内部类名{

 内部类的成员

} 

3、成员内部类的说明：

(1) 内部类可以访问外部类中的所有成员，包括私有成员

(2) 外部类中访问内部类中的成员，必须创建内部类对象
4、内部类创建对象的格式：

(1) 外部类名.内部类名 对象名 = new 外部类名().new 内部类名()

public class Demo01 {
    public static void main(String[] args) {
        //第一方式，直接创建内部类对象，访问内部类中的内容
        Body b = new Body();
        Body.Heart bh = b.new Heart();
        bh.show();
//        Body.Heart bg = new Body().new Heart();
        //第二种方式，可以创建外部类对象，通过外部类对象提供的方法，去访问内部类对象
        b.test();
    }
}
//定义在类的内部的类
class Body {//定义一个金龙的身体
    private double height = 149.99;
    // Heart在Body类中，首先是一个成员，想要访问这个成员，需要先创建外部类对象
    // 创建完外部类对象之后，可以访问这个这个成员，想要访问内部类中的成员，要创建内部类对象
    // 想要获取金龙的心脏，需要先拿到身体，剖开身体，才能拿到心脏
    //成员的位置上定义一个类
    class Heart {  //成员内部类====在这里！！！！！
        int beats = 200;//每分钟
        public void show() {
            System.out.println(height + "~~~~~" + beats + "DuangDuangDuang");
           print(); //可以相互调用
        }
    }
    //内部类外
    //可以定义一个方法  然后去创建内部类对象，访问属性
    public void test(){//外部类中此时都是成员，成员直接可以直接相互访问
        //但是要访问的成员又是一个类，想要拿到该类中的一些内容，需要创建对象
        Heart  h = new Heart();
        System.out.println(h.beats);
        h.show();
    }
    public void print(){
        System.out.println("准备干饭");
    }
}

（2）私有的成员内部类

1、加上private

2、访问方式：

(1) 在外部类以外，不能访问内部类中定义的私有成员

(2) 在外部类定义公共的方法，让外界调用公共的方法，间接的访问内部类中的私有成员.

(3)适用情景：
如果一个内部类只希望被外部类中的方法操作，那么可以使用private声明内部类。也就是说，此时的内部类只有外部类可控制
就像是，我的心脏只能由我的身体控制，其他人无法直接访问它

public class Demo02 {
    public static void main(String[] args) {
        Body b = new Body();
        System.out.println(b.getHeight());
        b.gaYaoZi();       
    }
}
//金龙的身体
class Body{
    private double height = 159.9;
    private class YaoZi{  //私有的成员内部类====在这里！！！！！
        //定义一个腰子的年龄
        int age = 80;
        public void show(){
            System.out.println(height + "缺钱的时候别来找我，我已经不行了" + age);
        }
    }
    //访问私有的成员需要提供公共的访问方式
    public double getHeight(){
        return height;
    }
    //私有的成员：成员变量   成员方法  私有成员内部类
    //私有的成员只能在本类中被直接访问
    //现在想要访问私有成员内部类中的age
    //需要创建对象，提供公共的方法
    public void gaYaoZi(){
        //相当于一个公共的访问方式
        YaoZi y = new YaoZi();
        //所以一般私有内部类，要求提供一个公共的访问方式，完成该类型的访问
        System.out.println(y.age);
        y.show();
    }
}

（3）静态的成员内部类

1、很简单加上static 就变成静态了

2、访问特点：

(1) 是外部类的静态成员，直接通过类名访问，而不需要创建对象

(2) 静态内部类的非静态成员，需要等所在的内部类对象创建之后，才能被调用

(3) 是否需要创建对象，取决于要访问的成员是否是静态

public class Demo03 {
    public static void main(String[] args) {
        System.out.println(Body.Gan.age);
//        System.out.println(Body.Gan.color);
        //因为可以直接拿到Gan这个类型，  类名.静态成员名
        //该成员又是一个类，所以创建该成员的对象
        //此时就可以访问该类中的内容
        Body.Gan gan = new Body.Gan();
        System.out.println(gan.color);
        gan.show();
    }
}
//金龙的身体
class Body {
    private double height = 169.99;
    static class Gan{ //静态的成员内部类====在这里！！！！！
        String color = "Green";
        static int age = 2;
        public void show(){
            //想要访问非静态的内容，需要创建对象，通过对象来访问
            Body b = new Body();
            System.out.println(b.height + color + "别喝了，再喝头顶就可能绿的发光了");
        }
    }
    //在外部类中，访问内部类
    public void test(){
        System.out.println(Gan.age);
        //想要访问颜色
        //想要访问一个类的内部的非静态成员，不是取决于这个类是否是静态
        //而是取决于这个成员是否是静态。不是就需要创建对象
        Gan g = new Gan();
        System.out.println(g.color);
    }
}

（4）局部内部类

1、定义在方法内部的类

2、局部内部类的访问方式：

(1) 方法内的局部变量，外界不能访问

(2) 同样，方法内的局部内部类，也不能在方法外被访问

3、解决方式：

(1) 在方法里，就完成该局部内部类的使用，创建局部内部类对象，调用对象相关的方法

(2) 外界调用局部内部类所在的方法，创建局部内部类对象，间接的访问局部内部类的成员

4、好处(重点)：

将一个类的生命周期，限制在了一个方法内

public class Demo04 {
    public static void main(String[] args) {
    }
    //金龙在呼吸
    public static void breath(){
        //肺的年龄
        int fei = 50;
        class Fei{  //方法里面的类！！！=>局部内部类
            //作用域只在当前方法内
            String color = "black";
            public void show(){
                System.out.println(fei + "~~~~~~~~" + color + "抽的太少了，来的刺激的，能一下过去的");
            }
        }
        //方法中的类必须在方法内使用，出了方法不能访问
        //好处就是将一个类的生命周期限制在一个方法内
        Fei f = new Fei();
        System.out.println(f.color);
        f.show();
    }
}