面向对象三大特性的理解?

发表于 | 分类于 |
字数统计: 789 | 阅读时长 ≈ 3

[TOC]

封装

将数据和基于数据的操作封装在一起，数据被保护在抽象数据类型的内部，只保留一些对外的接口使其与外部发生联系。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Person {
   private String name;
   private int gender;
   private int age;
   public String getName() {
   return name;
}
public String getGender() {
   return gender == 0 ? "man" : "woman";
}
public void work() {
   if (18 <= age && age <= 50) {
    System.out.println(name + " is working very hard!");
    } else {
    System.out.println(name + " can't work any more!");
   }
  }
}

继承

继承实现了 IS-A 关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非
private 的属性和方法。
继承应该遵循里氏替换原则，子类对象必须能够替换掉所有父类对象。
Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为 向上转型 。

1
Animal animal = new Cat();

多态

多态分为编译时多态和运行时多态：

  • 编译时多态主要指方法的重载

  • 运行时多态指的是 对象引用所指向的具体类型在运行期间才确定

运行时多态有三个条件：
1.继承
2.重写
3.向上转型

下面的代码中，乐器类（Instrument）有两个子类：Wind 和 Percussion，它们都覆盖了父类的 play() 方法，并且
在 main() 方法中使用父类 Instrument 来引用 Wind 和 Percussion 对象。在 Instrument 引用调用 play() 方法时，
会执行实际引用对象所在类的 play() 方法，而不是 Instrument 类的方法。

1
2
3
4
5
public class Instrument {
  public void play() {
  System.out.println("Instument is playing...");
 }
}
1
2
3
4
5
public class Wind extends Instrument {
  public void play() {
  System.out.println("Wind is playing...");
 }
}
1
2
3
4
5
public class Percussion extends Instrument {
  public void play() {
  System.out.println("Percussion is playing...");
 }
}
1
2
3
4
5
6
7
8
9
10
public class Music {
   public static void main(String[] args) {
   List<Instrument> instruments = new ArrayList<>();
   instruments.add(new Wind());
   instruments.add(new Percussion());
   for(Instrument instrument : instruments) {
   instrument.play();
   }
  }
}
1
2
Wind is playing...
Percussion is playing...

重写与重载

重写（Override）
存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
为了满足里式替换原则，重写有以下三个限制：
1.子类方法的访问权限必须大于等于父类方法；
2.子类方法的返回类型必须是父类方法返回类型或为其子类型。
3.子类方法抛出的异常类型必须是父类抛出异常类型或为其子类型。
使用 @Override 注解，可以让编译器帮忙检查是否满足上面的三个限制条件。使用 @Override 注解，可以让编译器帮忙检查是否满足上面的三个限制条件。

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

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