16. 面向对象进阶（2）

包

什么是包？

• 类似于文件夹，是用来管理不同类的。建包利于程序的管理和维护。
• 建包的语法格式（包名建议全英文小写，且名字有意义）

  package 公司域名倒写.技术名称

• 建包语句必须在第一行，一般IDEA工具会自动导包。

导包 

相同包下的类可以直接访问，不同包下的类必须导包后才能使用。

导包格式：

import 包名.类名;

权限修饰符

什么是权限修饰符？

• 权限修饰符：是用来限制成员能够被访问的范围。
• 权限修饰符可以修饰成员变量，方法，构造器，内部类。

修饰符的分类和具体作用范围

权限修饰符有四种：由小到大依次是 private -> 缺省 -> protected -> public。

 例子

    // 1.private 只能本类中访问
    private void show1() {
        System.out.println("private");
    }

    // 2.缺省：本类，同一个包下的类中。
    void show2() {
        System.out.println("缺省");
    }

    // 3.protected：本类，同一个包下的类中，其他包下的子类
    protected void show3() {
        System.out.println("protected");
    }

    // 4.任何地方都可以
    public void show4() {
        System.out.println("public");
    }

约定俗称的修饰符

成员变量一般私有

方法一般公开

如果成员只希望本类访问，使用private修饰

如果该成员只希望本类、同一个包下的其他类和子类访问，使用protected修饰

final

final的作用

final代表“最终”的意思，可以修饰方法，变量，类。

• 修饰方法：表示该方法是最终方法，不允许被重写。
• 修饰变量：表示该变量第一次赋值后，不能再次被赋值（只能被赋值一次）。
• 修饰类：表示该类是最终类，不能被继承。

final修饰变量的注意事项

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

常量

• 常量的修饰方法

  public static final

  使用常量修饰的成员变量，必须要有初始化值，且在程序执行过程中值不能改变。

• 常量的作用和好处：可以用作系统配置信息，提高可读性的同时，也利于维护。

• 常量的命名规范：英文字母全部大写，多个单词下划线连接起来。

常量的执行原理

在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真实的字面量。

这样做的好处是可以让程序执行效率更高。

枚举

枚举是Java中的一种特殊类型，枚举的作用是：为信息做标志和分类。

 ​​​​​​​

 枚举的特征

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

常量/枚举做信息标志和分类的差别

• 常量：虽然可实现可读性，但入参值不受约束，代码相对不严谨。
• 枚举：代码可读性好，入参约束严谨。

抽象类

抽象类、抽象方法概述

抽象类

• 抽象类其实就是一个“不完全的设计图”，父类要知道其子类要完成某些功能，但每个子类都不一样，因此父类只需要声明功能即可，剩下的实现方法由子类自己写。
• 抽象类的书写

  修饰符 abstract class 类名{
  
  }

抽象方法：

• 抽象方法指子类要完成的功能的方法和类型。
• 抽象方法没有方法体，只有方法签名，必须用abstract修饰。
• 抽象方法的书写

  修饰符 abstract 返回值类型 方法名称(形参列表);

例子

public abstract class Animal {
    public abstract void run();
}

public class Tiger extends Animal{
    @Override
    public void run() {
        System.out.println("老虎跑的快");
    }
}

public class Test {
    public static void main(String[] args) {
        Tiger t = new Tiger();
        t.run();
        /**
         * 结果：
         老虎跑的快
         */
    }
}

抽象类总结、注意事项 

• 抽象类用来被继承，抽象方法是交给子类重写实现的。
• 一个类如果继承了抽象类，这个类必须重写父类的所有抽象方法，否则这个类也必须是抽象类。

 

抽象类案例

/**
    抽象父类
 */
public abstract class Card {
    private String name;
    private double money;

    /**
        子类一定要支付的，但每个子类支付的情况不一样，所以父类把支付
        定义为抽象类方法，交给子类实现
     */

    public abstract void pay(double money);

    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;
    }
}

public class GoldCard extends Card{
    @Override
    public void pay(double money) {
        //优惠后的金额
        double rs = money * 0.8;
        double lastMoney = getMoney() - rs;
        System.out.println(getName() +"当前账户总金额为：" + getMoney() +
                ", 当前消费了：" + rs + ", 当前余额为：" + lastMoney);

        setMoney(lastMoney); //更新账户余额
    }
}

public class Test {
    public static void main(String[] args) {
        GoldCard c = new GoldCard();
        c.setMoney(10000); //父类的
        c.setName("张三");
        c.pay(300);
    }
}

抽象类特征、注意事项

 

抽象类应用知识：模板方法模式

接口

接口概述、特点

/**
    接口
    接口不能被创建对象
 */
public interface SportManInterface {
    // 接口中的成员：JDK1.8之前只有常量和抽象方法

    // 1. 常量
    // public static final 可以不写，接口默认会加上
    public static final String SCHOOL_NAME = "清华大学";

    // 2. 抽象方法
    // public abstract 可以不写，接口默认会加上
    public abstract void run();
    public abstract void eat();
}

接口的基本使用：被实现

public interface SportMan {
    void run();
    void competition();
}

public interface Law {
    void rule();
}

/**
    实现类
 */
public class PingPongMan implements Law, SportMan{
    private String name;

    public PingPongMan(String name) {
        this.name = name;
    }

    @Override
    public void rule() {
        System.out.println(name + "要守法");
    }

    @Override
    public void run() {
        System.out.println(name + "要跑步");
    }

    @Override
    public void competition() {
        System.out.println(name + "要比赛");
    }
}

public class Test {
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan("张三");
        p.run();
        p.competition();
        p.rule();
    }
}

接口与接口的关系：多继承

JDK8 之后新增接口方法

public interface SportManInter {
    /**
        默认方法（实例方法）
        接口不能创建对象，这个方法只能过继给实现类，由实现类的对象调用
     */
    default void run() {
        System.out.println("跑");
    }

    class PinPongMan implements SportManInter {}

    class Test {
        public static void main(String[] args) {
            PinPongMan p = new PinPongMan();
            p.run();
        }
    }
}

public interface SportManInter {
    /**
        静态方法
        接口的静态方法，必须接口名自己调用
     */
    static void inAddr() {
        System.out.println("静态方法");
    }
}

class PingPong implements SportManInter {
}

class Test {
    public static void main(String[] args) {
        SportManInter.inAddr();
    }
}

public interface SportManInter {
    /**
        私有方法（实例方法）
        必须在接口内部才能被访问
     */
    private void go() {
        System.out.println("私有方法");
    }

    default void run() {
        go();
    }
}

class PingPong implements SportManInter {
}

class Test {
    public static void main(String[] args) {
        PingPong p = new PingPong();
        p.run();
    }
}

使用接口的注意事项