Day09-2.内部类 、包 、权限修饰符

1 内部类

1. 概念：在方法中或者类中定义的类型
   在方法A中，定义一个类型B，类型B就是一个内部类
   在类A中，定义一个类型B，类型B也是一个内部类
2. 分类：
   局部内部类
   成员内部类
          普通的成员内部类
          私有的成员内部类
          静态的成员内部类

1.1 普通的成员内部类

1. 直接在类中定义一个不加任何修饰符修饰的类型
2. 特点：
   （1）在其他类中访问内部类的成员，需要先创建外部类的对象，再创建内部类的对象
   外部类名.内部类名 对象名 = new 外部类().new 内部类();
   （2）内部类可以直接访问外部类中的成员，包括私有
   （3）外部类中想要访问内部类的成员，需要创建内部类的对象

代码

package demos4;

public class Demo01 {
    public static void main(String[] args) {

        //在其他类中，需要创建外部类对象和内部类对象来访问内部类成员
        Body.Heart bh = new Body().new Heart();
        System.out.println(bh.getBeats());
        bh.print();

        new Body().show();
    }
}
class Body{
    private String name = "张三";

    //在类中定义一个类型，没有加任何修饰符：普通的成员内部类
    class Heart{
        private int beats = 90;
        public void setBeats(int beats){
            this.beats = beats;
        }
        public int getBeats(){
            return beats;
        }
        //在内部类中，可以直接访问外部类的成员
        public void print(){
            System.out.println("姓名为：" + name + "心跳的次数为：" + beats);
        }
    }
    public void show(){
        System.out.println("Body类的方法");
        //在外部类中，需要创建内部类对象访问内部类成员
        Heart h = new Heart();
        System.out.println(h.getBeats());
    }

}

1.2 私有的成员内部类

1. 在类中方法外定义的通过private 修饰的类型
2. 特点：
   （1）该类型要私有修饰
   （2）在私有内部类中，可以直接访问外部类的成员
   （3）在其他类中，不能直接创建内部类的对象，需要使用外部类提供的公共方式间接访问

代码
package demos4;

import demos01.B;

public class Demo02 {
    public static void main(String[] args) {

        //不能直接访问私有内部类
//        Body2.Shen bs = new Body2().new Shen();
        Body2 b = new Body2();
        //只能使用外部类提供的公共访问方式，间接访问
        b.zouShen();
    }
}
class Body2{
    String name = "张三";
    //定义一个私有的成员内部类
    private class Shen{
        int age = 30;
        //在私有的成员内部类中，可以直接访问外部类成员
        public void show(){
            System.out.println("姓名为：" + name + ",肾脏的年龄为：" + age +",兄弟，该走心的时候别TM来找我");
        }
    }
    //在外部类中，给私有的内部类提供一个公共访问方式
    public void zouShen(){
        Shen s = new Shen();
        System.out.println(s.age);
        s.show();
    }
}

1.3 静态的成员内部类

1. 概念：在类中方法外定义的通过static修饰的类型
2. 特点：
   （1）在类中可以定义静态内部类，使用static修饰
   （2）在静态内部类中，不能直接访问外部类的非静态成员
   （3）如果想在静态内部类中访问外部类的非静态成员，可以创建外部类的对象访问
   （4）在静态内部类中，可以直接访问外部类的静态成员
   （5）在其他类中，想要访问静态内部类的成员；不需要创建外部类的对象，只需要创 建内部类的对象即可。
   （6）一个类型是否需要创建对象，是跟类是否是静态有关？还是跟要访问的成员是否是静态有关？
          答案：一个类型是否需要创建对象，跟类是否是静态无关，跟要访问成员是否是静态有关，如果要访问的内容是静态的，就不需要创建本类对象，如果要访问的内容是非静态的，就需要创建本类对象。

代码

package demos4;

public class Demo03 {
    public static void main(String[] args) {

        Body3 b = new Body3();
        System.out.println(b.name);
        System.out.println(Body3.age);
        //在其他类中，访问静态内部类的非静态成员，不需要创建外部类对象，只需要创建内部类对象
        Body3.Fei bf = new Body3.Fei();
        bf.show();
    }
}
class Body3{
    String name = "张三";
    static int age = 23;
    //在类中定义一个静态内部类
    static class Fei{
        String color = "黑色";
        //在静态内部类中，不能直接访问外部类非静态成员，需要使用对象访问
        //可以直接访问外部类静态成员
        public void show(){
            System.out.println("姓名为：" + new Body3().name + "，年龄为：" + age + ",肺脏的颜色为：" + color
                    + ",大哥，少抽点吧，我都成什么色儿，还抽呢");
        }
    }
    //在外部类中，访问静态内部类的非静态成员，需要创建对象
    public void print(){
        Fei f = new Fei();
        f.show();
    }
}

1.4 局部内部类

1. 概念：在方法中定义一个类型
2. 特点：
   （1）在方法中可以定义类型，但是这个类型不能私有，也不能静态
   （2）在局部内部类中，可以直接访问方法中定义的局部变量
   （3）一旦出了该方法，就不能使用局部内部类
   （4）如果需要访问局部内部类的成员，只能在该方法中创建对象，访问

代码

package demos4;

public class Demo04 {
    public static void main(String[] args) {
        show();
    }

    public static void show(){
         String name = "张三";
         //局部内部类
         class Gan{
             String color = "黑色";
             public void print(){
                 System.out.println("姓名为：" + name + ",肝脏的颜色为：" + color);
             }
         }
         Gan g = new Gan();
         g.print();
    }
}

2 包

1. 概述：在磁盘上包就是一层层文件夹
2. 好处：
   （1）可以分类存放类文件，方便去存储代码，编辑代码
   （2）在不同的包中，可以定义相同的类名
3. 使用定义在包中的类：
   （1）如果在同一个包中，使用某一个类型，直接使用即可
   因为虚拟机默认去当前包中寻找有没有该类的定义，如果有就能直接使用
   （2）如果在不同的包中，使用某一个类型，不能直接使用
            将类型定义的包中之后，这个类的全类名发生改变：
                 全类名：包名+类名
            要使用这个类的全类名，来访问该类型
       问题：如果使用其他包中的类型，每次都要使用全类名，比较麻烦
                 可以使用导包的方式将该类全类名导入到当前文件中，后续再使用的时候直接使用名字即可，不需要再使用全类名
4. 如何定义包名：
   定义的文件夹名字唯一即可：域名倒着写
5. 一般将类型定义在某一个包中之后，需要在当前文件中第一行声明所在的包
   在第一行，使用关键字：package 声明类型所在的包即可

3 权限修饰符

分类	特点
private	只能在本类中被直接访问
protected	可以在本类中被直接访问；可以在本包的其他类中被直接访问；可以在子类中被直接访问
public	可以在本类中被直接访问；可以在本包的其他类中被直接访问；可以在子类中被直接访问；可以在其他包的无关类中被直接访问
什么都不写（默认修饰）	可以在本类中被直接访问；可以在本包的其他类被直接访问