Java面向对象

// Animal.java
 public class Animal {
     public String name;
          public Animal(String name) {
      this.name = name;
     }
          public void eat(String food) {
         System.out.println(this.name + "正在吃" + food);
     }
 } 
 
// Cat.java
 class Cat {
  public String name;
          public Cat(String name) {
      this.name = name;
     }
          public void eat(String food) {
         System.out.println(this.name + "正在吃" + food);
     }
 } 
 
// Bird.java
 class Bird {
  public String name;
          public Bird(String name) {
         this.name = name;
     }
          public void eat(String food) {
         System.out.println(this.name + "正在吃" + food);
     }
          public void fly() {
         System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
     }
 }

这个代码我们发现其中存在了大量的冗余代码.
仔细分析, 我们发现 Animal 和 Cat 以及 Bird 这几个类中存在一定的关联关系:
这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的. 这三个类都具备一个相同的 name 属性, 而且意义是完全一样的. 从逻辑上讲, Cat 和 Bird 都是一种 Animal (is - a 语义). 此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 来达到代码重用的效果.

此时, Animal 这样被继承的类, 我们称为父类 , 基类或超类, 对于像 Cat 和 Bird 这样的类, 我们称为子类, 派生类
和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果。

2.1 语法规则

基本语法

class 子类 extends 父类 {

}
使用 extends 指定父类.

Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).

子类会继承父类的所有 public 的字段和方法.

对于父类的 private 的字段和方法, 子类中是无法访问的.

子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用.

2.2 protected关键字

如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 "封装" 的初衷.

两全其美的办法就是 protected 关键字. 对于类的调用者来说, protected 修饰的字段和方法是不能访问的

对于类的子类和同一个包的其他类来说, protected 修饰的字段和方法是可以访问的

小结: Java 中对于字段和方法共有四种访问权限

private: 类内部能访问, 类外部不能访问

默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.

protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.

public : 类内部和类的调用者都能访问

3. 组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果.
组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段. 这是我们设计类的一种常用方式之一.
组合表示 has - a 语义
在刚才的例子中, 我们可以理解成一个学校中 "包含" 若干学生和教师.

继承表示 is - a 语义
在上面的 "动物和猫" 的例子中, 我们可以理解成一只猫也 "是" 一种动物.

4. 多态

4.1 向上转型

Bird bird = new Bird("圆圆");
这个代码也可以写成这个样子
Bird bird = new Bird("圆圆"); Animal bird2 = bird;

// 或者写成下面的方式 Animal bird2 = new Bird("圆圆");
此时 bird2 是一个父类 (Animal) 的引用, 指向一个子类 (Bird) 的实例. 这种写法称为向上转型.
向上转型这样的写法可以结合 is - a 语义来理解.

为啥叫 "向上转型"?

在面向对象程序设计中, 针对一些复杂的场景(很多类, 很复杂的继承关系), 程序猿会画一种 UML 图的方式来表示类之间的关系. 此时父类通常画在子类的上方. 所以我们就称为 "向上转型" , 表示往父类的方向转.

4.2 动态绑定

当子类和父类中出现同名方法的时候, 再去调用会出现什么情况呢?
对前面的代码稍加修改, 给 Bird 类也加上同名的 eat 方法, 并且在两个 eat 中分别加上不同的日志.

// Animal.java
 public class Animal {
     protected String name; 
 
    public Animal(String name) {
         this.name = name;
     } 
 
    public void eat(String food) {
         System.out.println("我是一只小动物");
         System.out.println(this.name + "正在吃" + food);
     }
} 
 
// Bird.java
 public class Bird extends Animal {
     public Bird(String name) {
         super(name);
     } 
 
    public void eat(String food) {
         System.out.println("我是一只小鸟");
         System.out.println(this.name + "正在吃" + food);
     }
 } 
 
// Test.java
 public class Test {
     public static void main(String[] args) {
         Animal animal1 = new Animal("圆圆");
         animal1.eat("谷子");
         Animal animal2 = new Bird("扁扁");
         animal2.eat("谷子");
     }
 } 
 
// 执行结果
 我是一只小动物
 圆圆正在吃谷子
 我是一只小鸟
 扁扁正在吃谷子

animal1 和 animal2 虽然都是 Animal 类型的引用, 但是 animal1 指向 Animal 类型的实例, animal2 指向 Bird 类型的实例.

针对 animal1 和 animal2 分别调用 eat 方法, 发现 animal1.eat() 实际调用了父类的方法, 而 animal2.eat() 实际调用了子类的方法.

因此, 在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为 动态绑定.

4.3 方法重写

针对刚才的 eat 方法来说:

子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为覆写/重写/覆盖(Override).

关于重写的注意事项：

1. 重写和重载完全不一样. 不要混淆

2. 普通方法可以重写, static 修饰的静态方法不能重写.

3. 重写中子类的方法的访问权限不能低于父类的方法访问权限.

4.3 理解多态

有了面的向上转型, 动态绑定, 方法重写之后, 我们就可以使用多态的形式来设计程序了.

当类的调用者在编写一个方法的时候, 参数类型为父类, 此时在该方法内部并不知道, 也不关注当前的引用指向的是哪个类型(哪个子类)的实例. 此时这个引用调用方法可能会有多种不同的表现, 这种行为就称为多态。

1) 类调用者对类的使用成本进一步降低.

封装是让类的调用者不需要知道类的实现细节.

多态能让类的调用者连这个类的类型是什么都不必知道, 只需要知道这个对象具有某个方法即可.

2) 能够降低代码的 "圈复杂度", 避免使用大量的 if - else

3) 可扩展能力更强.

如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.

迷途知返。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象

目录1. 包1.1 导入包中的类1.2静态导入1.3 将类放到包中1.4 包的访问权限控制1.5常见的系统包2. 继承2.1 语法规则2.2 protected关键字3. 组合4. 多态4.1 向上转型4.2 动态绑定4.3 方法重写4.3 理解多态1. 包包 (package) 是组织类的一...
复制链接

扫一扫