1.包

• 什么是包
  • 包是用来分别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护
  • 建包的语法格式：package 公司域名倒写.技术名称。【建议全英文小写，且具备意义】
  • 建包语句必须在第一行，一般IDEA工具会帮助创建
• 导包
  • 相同包下的类可以直接访问，不同包下的类必须导包，才可以使用！【导报格式：import 包名.类名】
  • 加入一个类中需要用到不同类，而这两个类的名称是一样的，那么默认只能导入一个类，另一个类需要带包名访问

2.权限修饰符

• 权限修饰符

  • 是用来控制一个成员能够被访问的范围
  • 可以修饰成员变量，方法，构造器，内部类，不同权限修饰符的成员能够被访问的范围将受到限制

• 权限修饰符的分类和具体作用范围：

  • 权限修饰符：有四种作用范围由小到大（private -> 缺省 -> protected -> public）

• 学完后具备能力
  • 能够识别别人定义的成员的访问范围
  • 自己定义成员（方法，成员变量，构造器等）一般满足以下要求
    • 成员变量一般私有
    • 方法一般公开
    • 如果该成员只希望本类访问，使用private修饰
    • 如果该成员只希望本类，同一个包下的其他类和子类访问，使用protected修饰

3.final

• 作用
  • final关键字是最终的意思，可以修饰（类、方法、变量）
  • 修饰类：表示该类是最终类，不能被继承
  • 修饰方法：表明该方法是最终方法，不能被重写
  • 修饰变量：表示该变量第一次赋值后，不能再次被赋值（有且只能被赋值一次）
• final 修饰变量的注意
  • final修饰的变量是基本类型，那么变量存储的数据值不能发生改变
  • final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的

3.1、常量概述和基本作用

• 常量

  • 常量是使用了 public static final 修饰的成员变量，必须有初始值，而且执行的过程中其值不能被改变
  • 常量名的命名规范：英文单词全部大写，多个单词用下划线连接

• 常量做信息配置的原理、有时
  • 在编译阶段会进行”宏替换“：吧使用常量的地方全部替换成真实的字面量。
  • 维护系统容易，可读性更好

3.2、常量做信息标志和分类

看视频回顾 p107

4.枚举

4.1、枚举的概述

• 枚举是Java中的一种特殊类型
• 枚举的作用：是为了做信息的标志和信息的分类”
• 格式：

【使用黑窗口命令运行javap命令后】

• 枚举的特征
  • 枚举类都是继承了枚举类型：java.lang.Enum
  • 枚举都是最终类，不可以被继承
  • 构造器都是私有的，枚举对不能创建对象
  • 枚举类的第一行默认都是罗列枚举对象的名称的
  • 枚举类相当于是多例模式

【更多需要看视频回顾】

5.抽象类

5.1、抽象类

• 在java中abstract是抽象的意思，可以修饰类、成员方法
• abstract修饰类，这个类就是抽象类，修饰方法，就称为抽象方法

【注意事项】

• 抽象方法只有方法名，不能写方法体
• 一个类中如果定义了抽象方法，这个类必须声明成抽象类，否则报错

【抽象的使用场景】

• 抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承
• 当父类知道子类一定要完成某些行为，但每个子类该行为的实现又不同，于是该父类就吧该行为定义成抽象方法的形式，具体实现交给子类去完成。此时这个类就可以声明成抽象类

5.2、案例

【需求】

• 某加油站推出了 2 种支付卡，一种是预存 10000 的金卡，后续加油享受八折优惠，另一种是预存 5000 的银卡，后续加油享受八五折的优惠。
• 分别实现 2 种卡片进入收银系统后的逻辑，卡片需要包含主人【名称，余额，支付功能】

【代码】

• Card（抽象类）

public abstract class Card {
    private String name;
    private double money;

    public abstract void pay(double money);

    public Card(String name, double money) {
        this.name = name;
        this.money = money;
    }

    public Card() {
    }

    public String getName() {
        return name;
    }

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

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

• WhiteCard（白金卡，继承抽象实现具体方法）

public class WhiteCard extends Card{
    @Override
    public void pay(double money) {
        System.out.println("您当前消费："+money);
        System.out.println("您卡片当前余额为："+this.getMoney());
        System.out.println("您实际支付为："+money*0.8);
        this.setMoney(this.getMoney()-money*0.8);
    }
}

• SilverCard（同上）

public class SilverCard extends Card{
    @Override
    public void pay(double money) {
        System.out.println("您当前消费："+money);
        System.out.println("您卡片当前余额为："+this.getMoney());
        System.out.println("您实际支付为："+money*0.85);
        this.setMoney(this.getMoney()-money*0.85);
    }
}

• Test

public class Test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        WhiteCard whiteCard = new WhiteCard();
        whiteCard.setName("马浩楠");
        whiteCard.setMoney(10000);
        whiteCard.pay(500);

        SilverCard silverCard = new SilverCard();
        silverCard.setName("张林燕");
        silverCard.setMoney(5000);
        silverCard.pay(1000);
    }
}

5.3、抽象类的特征、注意事项

• 特征和注意事项
  • 类有的成员（成员变量、方法、构造器）抽象类都具备
  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
  • 一个类继承了抽象类必须重写完成抽象类的全部抽象方法，否则这个类也必须定义成抽象类
  • 不能用abstract修饰变量、代码块、构造器
  • 重要的特征：得到了抽象方法，失去了创建对象的能力
• final 和 abstract 是什么关系（面试问）
  • 互斥关系
  • abstract 定义的抽象类作为模板让子类继承，final 定义的类不能被继承
  • 抽象方法定义通过功能让子类实现，final 定义的方法不能被重写

5.4、抽象类的应用只是：模板方法模式

• 什么时候使用模板方法模式
  • 场景：当系统种出现同一个功能多出在开发，而该功能种大部分代码是一样的，只有其中部分可能不同的时候
• 模板方法模式实现步骤
  1. 定义一个抽象类
  2. 定义 2 个方法，一个是模板方法：吧相同代码放里面去，不同代码定义成抽象方法
  3. 子类继承抽象类，重写抽象方法

【案例需求】：

• 现在有两类学生，一类是中学生，一类是小学生，他们都要写《我的妈妈》这篇作文。
• 要求每种类型的学生，标题第一段和最后一段，内容必须一样。正文部分自己发挥
• 请选择最优的面向对象方案进行设计

【代码】：

• Student（抽象类）

public abstract class Student {
    public final void write(){
        System.out.println("===《我的母亲》===");
        System.out.println("你的母亲是怎么样的：");
        //正文
        System.out.println(mainContent());
        System.out.println("我的母亲简直太好了！");
    }
    public abstract String mainContent();
}

• StudentChild（小学生类）

public class StudentChild extends Student{
    @Override
    public String mainContent() {
        return "very good！";
    }
}

• StudentMiddle

public class StudentMiddle extends Student{
    @Override
    public String mainContent() {
        return "无法言语表达的好！";
    }
}

• Test

public class Test {
    public static void main(String[] args) {
        StudentChild studentChild = new StudentChild();
        studentChild.write();
        StudentMiddle studentMiddle = new StudentMiddle();
        studentMiddle.write();
    }
}

【模板方法我们是建议使用 final 修饰的，这样更专业，原因是：】

• 模板方法是给子类直接使用的，不是让子类重写的，子类一旦重写了模板方法，则模板方法就失效了，因此，加上 final 修饰后可以防止子类重写模板方法，更加的专业

6.接口

6.1、接口概述、特点

• 接口的格式如下：

//接口用关键字 interfact 来定义
public interfact 接口名{
    //常量
    //抽象方法
}

• JDK8 之前接口种只能是抽象方法和常量，没有其他成分
• 接口不能实例化
• 接口中的成员都是 public 修饰的，写不写都一样，因为规范的目的是为了公开化

【接口：是一种规范，类似现实生活中的 “插座”】

6.2、接口的基本使用

• 接口的用法

  • 接口是用来被类实现（implements）的，实现接口的类被称为实现类，实现类可以理解成所谓的子类

  • 修饰符 class 实现类 implements 接口1,接口2,接口3,...{
        //implements 实现关键字
    }
    

  • 从上面可以看出，接口可以被类单实现，也可以被多实现

• 接口实现的注意事项

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

6.3、补充：接口与接口的多继承

• 类和类的关系：单继承
• 类和接口的关系：多实现
• 接口与接口关系：多继承，一个接口可以同时继承多个接口
• 作用：规范合并，整合多个接口为同一个接口，便于子类实现

6.4、补充：JDK8 开始接口新增的方法

• 第一种：默认方法
  • 类似之前写的普通实例方法：必须用 default 修饰
  • 默认会 public 修饰。需要接口的实现类对象来调用

default void run(){
    System.out.println("开始跑");
}

• 第二种：静态方法
  • 默认会 public 修饰，必须 static 修饰
  • 注意：接口的静态方法必须用本身的接口名来调用

static void inAddr(){
    System.out.println("学习Java中！");
}

• 第三种：私有方法
  • 就是私有的实例方法，必须使用 private 修饰，从JDK1.9才开始有
  • 只能在本类中被其他的默认方法或私有方法访问

private void go(){
    System.out.println("准备");
}

【注意】：JDK8 新增的 3 种方法我们自己在开发种很少使用，通常是 java 源代码设计到的，我们需要理解、识别语法、明白调用关系即可

6.5、接口的注意事项

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