【Java语言基础】6.2 Java面向对象进阶

Java面向对象进阶

1. 语法

1.1 包

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

1.2 权限修饰符

• 权限修饰符：是用来控制一个成员能够被访问的范围。
• 可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围将受到限制。
• 权限修饰符：有四种作用范围由小到大（peivate -> 缺省 -> protected -> public）

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

1.3 final

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

1.4 常量

• 常量是使用了punlic static final修饰的成员变量，必须有初始值，而且执行的过程中其值不能被改变。
• 常量的作用和好处：可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性。
• 常量命名规范：英文单词全部大写，多个单词下划线连接起来。
  public static final LOGIN_NAME = "admin";
• 在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真实的字面量。
• 这样做的好处是让使用常量的程序的执行性能与直接使用字面量是一样的。
• 常量也可以做信息标志和分类。

1.5 枚举

• 枚举是Java中的一种特殊类型。
• 枚举的作用：是为了做信息的标志和分类。
• 枚举的格式：x
  修饰符 enum 枚举名称{
第一行都是罗列枚举类实例的名称。
}

// Season.java 文件
public enum Season {
    SPRING, SUMMER, AUTUMN, WINTER;
}

// Season.class 文件
Compiled from "Season.java"
public final class com.xusanmu.d_enum.Season extends java.lang.Enum<com.xusanmu.d_enum.Season> {
  public static final com.xusanmu.d_enum.Season SPRING;
  public static final com.xusanmu.d_enum.Season SUMMER;
  public static final com.xusanmu.d_enum.Season AUTUMN;
  public static final com.xusanmu.d_enum.Season WINTER;
  public static com.xusanmu.d_enum.Season[] values();
  public static com.xusanmu.d_enum.Season valueOf(java.lang.String);
  static {};
}

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

2. 抽象类

• 在Java中abstract是抽象的意思，可以修饰类、成员方法。
• abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。
• 抽象方法只有方法签名，不能声明方法体。
• 一个类中如果定义了抽象方法，这个类必须声明成抽象类，否则报错。
• 抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承。
• 当父类知道子类一定要完成某些行为，但是每个子类该行为的实现又不同，于是该父类就把该行为定义成抽象方法的形式，具体实现交给子类去完成。此时这个类就可以声明成抽象类。

/**
 * 抽象类
 */
public abstract class Animal {
    private String name;

    /**
     * 抽象方法
     */
    public abstract void run();

    public String getName() {
        return name;
    }

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

/**
 * 子类
 */
public class Dog extends Animal{

    @Override
    public void run() {
        System.out.println("小狗在奔跑..");
    }
}

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.run(); // 小狗在奔跑..
    }
}

• 类有的成员（成员变量、方法、构造器）抽象类都具备。
• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
• 一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
• 不能用abstract修饰变量、代码块、构造器。
• 抽象类得到了抽象方法，失去了创建对象的能力。
• 模板方法模式：
  • 使用场景：当系统中出现同一个功能多处在开发，而该功能中大部分代码是一样的，只有其中部分可能不同的时候。
  • 把功能定义成一个所谓的模板方法，放在抽象类中，模板方法中只定义通用且能确定的代码。
  • 模板方法中不能决定的功能定义成抽象方法让具体子类去实现。

3. 接口

• 接口用关键字interface来定义。
• JDK8之前接口中只能是抽象方法和常量，没有其他成分。
• 接口体现的是一种规范思想。
• 接口是用来被类实现(implement)的，实现接口的类称为实现类。实现类可以理解成所谓的子类。

/**
 * 接口
 */
public interface SportMan {
    void run();
    void competition();
}

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

    public PingPongMan(String name) {
        this.name = 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 man = new PingPongMan("李四");
        man.run(); // 李四通过跑步训练
        man.competition(); // 李四参加比赛
    }
}

类和类的关系：单继承
类和接口的关系：多实现
接口和接口的关系：多继承，一个接口可以同时继承多个接口。

• 接口多继承可以合并规范，整合多个接口为同一个接口，便于子类实现。
• 接口的注意事项：
  • 接口不能创建对象。
  • 一个类实现多个接口，多个接口中有同样的静态方法不冲突。
  • 一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
  • 一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。
  • 一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。