【JAVA】包、权限修饰符、final关键字、常量、枚举、抽象类、接口

1 包

• 包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护。建包语句必须在第一行
• 建包的语法格式：package 公司域名倒写.项目名称。包名建议全部小写
• 相同包下的类可以直接访问，不同包下的类必须导包，才可以使用。假如一个类中需要用到两个类名称一样的类，那么默认只能导入一个类，另一个类需要带包名访问
• 导包格式：import 包名.类名

2 权限修饰符

• 权限修饰符：用来控制一个成员能够被访问的范围
• 可以修饰成员变量、方法、构造器、内部类，不同权限修饰符修饰的成员能够被访问的范围将受到相应的限制
• 权限修饰符的范围：private<缺省<protected<public

修饰符	同一个类中	同一个包中的其它类	不同包下的子类	不同包下的无关类
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√

定义成员（方法、成员变量、构造器等）一般满足如下要求：

• 成员变量一般私有
• 方法一般公开
• 如果该成员只希望本类访问，用private访问
• 如果该成员只希望本类的同一个包下的其他类和子类访问，使用protected修饰

3 final关键字

• final关键字是最终的意思，可以修饰方法、变量、类

final修饰方法	表明该方法是最终方法，不能被重写
final修饰变量	表明该变量第一次赋值后，不能再次被赋值（有且仅能被赋值一次）
final修饰类	表明该类是最终类，不能被继承

• final修饰的变量是基本类型：那么变量存储的数据值不能发生改变
• final修饰的变量是引用数据类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的（但是数值可以变化）

4 常量

• 常量是使用了public static final修饰的成员变量，，而且执行的过程中其值不能被改变
• 常量的作用和好处：可以做系统的配置信息，方便程序维护，同时也能提高可读性

// 常量命名规范：英文字母全部大写，多个单词下划线相连
public static final String PASS_WORD = "123";

常量的执行原理：

• 在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真实的字面量
• 好处：让使用常量的程序的执行性能与直接使用字面量是一样的

选择常量做信息标志和分类：代码可读性好，实现了软编码形式

5 枚举

• 枚举类都是继承了枚举类型：java.lang.Enum
• 枚举都是最终类，不可以被继承
• 枚举类的构造器都是私有的，枚举对外不能创建对象。

public static void main(String[] args) {
        Season s1 = Season.AUTUMN;
        Season s2 = Season.WINTER;
        // ！！！！但是不能创建对象
        //Season s = new Season();
    }

// 枚举的第一行默认都是罗列枚举对象的名称
enum Season{
    SPRING, SUMMER, AUTUMN, WINTER;
}

编译后： 

public final class Season extends java.lang.Enum<Season>{
    public static final Season SPRING = new Season();
    public static final Season SUMMER = new Season();
    public static final Season AUTUMN = new Season();
    public static final Season WINTER = new Season();
    public static Season[] values();
    public static Season valueOf(java.lang.String);
}

6 抽象类

在Java中abstract是抽象的意思，如果一个类中的某个方法的具体实现不能确定，就可以申明为abstract修饰的抽象方法（不能写方法体），这个类必须用abstract修饰，被称为抽象类。

// 抽象类
public abstract class Animal{
    // 抽象方法
    public abstract void run();
}

• 抽象类作用：可以被子类继承，让子类来实现方法的具体功能，充当模板，同时也可以提高代码复用
• 样式：只有方法签名，没有方法体，使用abstract修饰
• 一个类如果继承了抽象类，必须重写完抽象类中的全部抽象方法，如果不能，则这个类也得改为抽象类

• 得到了抽象方法，但是抽象类不能创建对象（因为若可以创建对象了，就可以用里面方法，但是又没有方法体）
• 类的成员（成员变量、方法、构造器）抽象类都具备
• 不能用abstract修饰变量、代码块、构造器

7 接口

• 接口只能定义常量和抽象方法，接口不能实例化（就是不能在别的地方new该接口）

public interface Student{
    // 常量
    // public static final String NAME = "ABC";
    // 会默认加上public static final
    // 下面和上面一样
    String NAME = "ABC";

    // 2 抽象方法
    // 默认加上public abstract
    //public abstract void score();
    void score();
}

• 接口时用来被类实现(implements)的，实现接口的类被称为实现类。实现类可以理解为子类

修饰符 class 实现类 implements 接口1，接口2，....{

}

• 一个类实现接口，必须重写完接口的全部抽象方法，否则这个类需要定义为抽象类

类和类	单继承
类和接口	多实现
接口和接口	多继承，一个接口可以同时继承多个接口

jdk8之后的新增功能：默认方法，静态方法

jdk9新增功能：私有方法（必须在接口内部才能访问）

public interface PeopleInter{
    // 必须default修饰，默认用public权限
    // 1 默认方法，接口不能创建对象，这个方法只能给实现类，由实现类的对象调用
    default void score(){
        System.out.println("100分")
        // 3 的私有方法，可以在这调用
        graduation();
    }
    
    // 2 静态方法，必须使用static修饰，默认public权限
    // 必须接口名调用，不能实现类调用
    public static void queryScore(){
        System.out.println("查询科目分数为满分")
    }

    // 3 私有方法，接口内部才能访问
    private void graduation(){
        System.out.println("恭喜您毕业啦")
    }
}


// ------------------------------------

class Student implements PeopleInter{
}

// ====================================

class Test{
    public static void main(String[] args){
        Student s = new Student();
        s.score();
        // 静态方法，接口名调用
        PeopleInter.queryScore();
    }
}

注意事项

1. 接口不能创建对象
2. 一个类实现多个接口，多个接口中有同样的静态方法不冲突，因为静态方法只能接口名调用
3. 一个类继承了父类，同时又实现了接口，父类和接口中又重名的方法，默认用父类的
4. 一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可
5. 一个接口继承多个接口，没有问题，但是若多个接口中存在规范冲突，则不能多继承