Java基础——面向对象的特性

目录

1. 封装

访问权限

2. 继承

2.2 抽象类和接口

2.2.1 抽象类

2.2.2 接口

2.2.3 抽象类和接口比较

2.2.4 使用场景选择

2.3 super

2.4 重写与重载

2.4.1  重写（Override）

2.4.2. 重载（Overload）

3. 多态

3.1 三个必要条件

3.2 多态的好处

3.3 经典例题

---

面向对象三大特性： 封装、继承、多态

1. 封装

访问权限

Java 中一共有四种访问权限控制，其权限控制的大小情况是这样的：public > protected > default(包访问权限) > private

访问权限	本类	本包的类	子类	非子类的外包类
public	是	是	是	是
protected	是	是	是	否
default	是	是	否	否
private	是	否	否	否

1、public： 所修饰的类、变量、方法，在内外包均具有访问权限；
2、protected： 这种权限是为继承而设计的，protected所修饰的成员，对所有子类是可访问的，但只对同包的类是可访问的，对外包的非子类是不可以访问；
3、包访问权限（default）： 只对同包的类具有访问的权限，外包的所有类都不能访问；
4、private： 私有的权限，只对本类的方法可以使用；

注意： 要区分开 protected 权限、包访问权限，正确使用它们；

• 当某个成员能被所有的子类继承，但不能被外包的非子类访问，就是用protected；
• 当某个成员的访问权限只对同包的类开放，包括不能让外包的类继承这个成员，就用包访问权限；

可以对类或类中的成员（字段以及方法）加上访问修饰符。

• 类可见 表示其它类可以用这个类创建实例对象。
• 成员可见 表示其它类可以用这个类的实例对象访问到该成员；
• protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。

信息隐藏或封装原则：设计良好的模块会隐藏所有的实现细节，模块之间只通过它们的 API 进行通信。

如果子类的方法重写了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。（？）

字段通常都是private：使用get和set方法，可以控制对字段的修改行为。如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。

java基础(七) java四种访问权限

 学习6大设计原则、23种设计模式

2. 继承

2.2 抽象类和接口

2.2.1 抽象类

抽象类和抽象方法都使用 abstract 关键字进行声明。如果一个类中包含抽象方法，那么这个类必须声明为抽象类。

 

抽象类和普通类最大的区别是，抽象类不能被实例化，需要继承抽象类才能实例化其子类。

抽象类的成员访问权限任意。

抽象类不一定非要有抽象方法

 

抽象方法只声明返回的数据类型、方法名称和所需的参数，没有方法体，也就是说抽象方法只需要声明而不需要实现。

如果子类没有实现抽象方法，那么子类仍然必须是抽象类。

2.2.2 接口

接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。从 Java 8 开始，接口也可以拥有默认的方法实现（default），这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。

接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。

接口的字段默认都是 static 和 final 的。

2.2.3 抽象类和接口比较

• 从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
• 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
• 接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
• 接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。

2.2.4 使用场景选择

使用接口的场景：

• 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
• 需要使用多重继承。

使用抽象类的场景：

• 需要在几个相关的类中共享代码。
• 需要能控制继承来的成员的访问权限，而不是都为 public。
• 需要继承非静态和非常量字段。

在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低。

说一下Java中抽象类和接口存在的意义与价值

2.3 super

• 访问父类的构造函数：可以使用 super() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。应该注意到，子类一定会调用父类的构造函数来完成初始化工作，一般是调用父类的默认构造函数，如果子类需要调用父类其它构造函数，那么就可以使用 super 函数。
• 访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。（与this是对应的）

2.4 重写与重载

2.4.1  重写（Override）

子类继承父类时，重写父类的方法。

为了满足里式替换原则，重写有以下三个限制：

• 子类方法的访问权限必须大于等于父类方法；
• 子类方法的返回类型必须是父类方法返回类型或为其子类型。
• 子类方法抛出的异常类型必须是父类抛出异常类型或为其子类型。

使用 @Override 注解，可以让编译器帮忙检查是否满足上面的三个限制条件。[注意在实现接口时，用的注解也是@Override，但这不是重写]

下面的示例中，SubClass 为 SuperClass 的子类，SubClass 重写了 SuperClass 的 func() 方法。其中：

• 子类方法访问权限为 public，大于父类的 protected。
• 子类的返回类型为 ArrayList，是父类返回类型 List 的子类。
• 子类抛出的异常类型为 Exception，是父类抛出异常 Throwable 的子类。
• 子类重写方法使用 @Override 注解，从而让编译器自动检查是否满足限制条件。

class SuperClass {
    protected List<Integer> func() throws Throwable {
        return new ArrayList<>();
    }
}

class SubClass extends SuperClass {
    @Override
    public ArrayList<Integer> func() throws Exception {
        return new ArrayList<>();
    }
}

在调用一个方法时，先从本类中查找看是否有对应的方法，如果没有查找到再到父类中查看，看是否有继承来的方法。否则就要对参数进行转型，转成父类之后看是否有对应的方法。总的来说，方法调用的优先级为：

• this.func(this)
• super.func(this)
• this.func(super)
• super.func(super)

/*
    A
    |
    B
    |
    C
    |
    D
 */


class A {

    public void show(A obj) {
        System.out.println("A.show(A)");
    }

    public void show(C obj) {
        System.out.println("A.show(C)");
    }
}

class B extends A {

    @Override
    public void show(A obj) {
        System.out.println("B.show(A)");
    }
}

class C extends B {
}

class D extends C {
}
public static void main(String[] args) {

    A a = new A();
    B b = new B();
    C c = new C();
    D d = new D();

    // 在 A 中存在 show(A obj)，直接调用
    a.show(a); // A.show(A)
    // 在 A 中不存在 show(B obj)，将 B 转型成其父类 A
    a.show(b); // A.show(A)
    // 在 B 中存在从 A 继承来的 show(C obj)，直接调用
    b.show(c); // A.show(C)
    // 在 B 中不存在 show(D obj)，但是存在从 A 继承来的 show(C obj)，将 D 转型成其父类 C
    b.show(d); // A.show(C)

    // 引用的还是 B 对象，所以 ba 和 b 的调用结果一样
    A ba = new B();
    ba.show(c); // A.show(C)
    ba.show(d); // A.show(C)
}

2.4.2. 重载（Overload）

存在于同一个类中，指一个方法与已经存在的方法名称上相同

参数类型、参数个数、顺序至少有一个不同； 返回值可以不同，但不能只有返回值不同；

3. 多态

Java多态性理解，好处及精典实例

3.1 三个必要条件

• 要有继承；
• 要有重写；
• 父类引用指向子类对象。

3.2 多态的好处

1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。
4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。
5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

3.3 经典例题

在调用一个方法时，先从本类中查找看是否有对应的方法，如果没有查找到再到父类中查看，看是否有继承来的方法。否则就要对参数进行转型，转成父类之后看是否有对应的方法。总的来说，方法调用的优先级为：

• this.func(this)
• super.func(this)
• this.func(super)
• super.func(super)