面对对象编程

包

继承

三级目录

组合

多态

抽象类

接口

包（package）：是组织类的一种方式。使用包的主要目的是保证类的唯一性
Java 中已经提供了很多现成的类供我们使用：
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
可以使用 java.util.Date 这种方式引入 java.util 这个包中的 Date 类，也可以使用import语句导入包。
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
需要使用 java.util 中的其他类, 可以使用 import java.util.*，更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况。
静态导入：使用 import static 可以导入包中的静态的方法和字段。
将类放到包中
基本规则：

• 在文件的最上方加上一个 package 语句指定该代码在哪个包中。
• 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 )。
• 包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码。
• 如果一个类没有 package 语句, 则该类被放到一个默认包中。
  包的访问权限控制
  private 中的成员只能被类的内部使用，如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用。
  常见的系统包：
• java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
• java.lang.reflect:java 反射编程包;
• java.net:进行网络编程开发包。
• java.sql:进行数据库开发的支持包。
• java.util:是java提供的工具程序包。(集合类等) 非常重要
• java.io:I/O编程开发包。
  继承：代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法)。
  有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联。
  // 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 这样的类, 我们称为 子类, 派生类，和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果。
基本语法：

使用 extends 指定父类.
Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承)。
子类会继承父类的所有 public 的字段和方法。
对于父类的 private 的字段和方法, 子类中是无法访问的。
子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用。
protected关键字：
对于类的调用者来说, protected 修饰的字段和方法是不能访问的。
对于类的 子类 和 同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的。
小结: Java 中对于字段和方法共有四种访问权限
private: 类内部能访问, 类外部不能访问。
默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问。
protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问。
public : 类内部和类的调用者都能访问。
final关键字：
修饰一个变量或者字段的时候, 表示 常量 (不能修改)。
final 关键字也能修饰类, 此时表示被修饰的类就不能被继承。
组合：是一种表达类之间关系的方式, 也是能够达到代码重用的效果。
注意：组合表示 has - a 语义 继承表示 is - a 语义
多态：
向上转型：
Bird bird = new Bird(“圆圆”);
Animal bird2 = bird;
// 或者写成下面的方式
Animal bird2 = new Bird(“圆圆”);
bird2 是一个父类 (Animal) 的引用, 指向一个子类 (Bird) 的实例. 这种写法称为 向上转型。
为啥叫 “向上转型”?
在面向对象程序设计中, 针对一些复杂的场景(很多类, 很复杂的继承关系), 程序猿会画一种 UML 图的方式来表示类之间的关系。此时父类通常画在子类的上方. 所以我们就称为 “向上转型” , 表示往父类的方向转。
向上转型发生的时机:
直接赋值 方法传参 方法返回
动态绑定：在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象。这个过程是程序运行时决定的(而不是编译期), 因此称为 动态绑定。
1.一定要发生向上转型（父类引用引用子类对象 ）。
2.父类和子类有同名的重写/覆写/覆盖方法。
3.最后通过父类的引用来调用子类和父类的这个同名的覆盖方法。此时就会发生动态绑定，或者叫做运行时绑定。
方法重写：子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为 覆写/重写/覆盖(Override)。
注意事项：

• 重写和重载完全不一样. 不要混淆(思考一下, 重载的规则是啥?)。
• 普通方法可以重写, static 修饰的静态方法不能重写。
• 重写中子类的方法的访问权限不能低于父类的方法访问权限。
• 重写的方法返回值类型不一定和父类的方法相同(但是建议最好写成相同, 特殊情况除外)。
• 理解多态：
  class Shape {
  public void draw() {
  // 啥都不用干
  }
  }
  class Cycle extends Shape {
  @Override
  public void draw() {
  System.out.println(“○”);
  }
  }
  class Rect extends Shape {
  @Override
  public void draw() {
  System.out.println(“□”);
  }
  }
  class Flower extends Shape {
  @Override
  public void draw() {
  System.out.println(“♣”);
  }
  }
  /我是分割线//
  // Test.java
  public class Test {
  public static void main(String[] args) {
  Shape shape1 = new Flower();
  Shape shape2 = new Cycle();
  Shape shape3 = new Rect();
  drawMap(shape1);
  drawMap(shape2);
  drawMap(shape3);
  }
  // 打印单个图形
  public static void drawShape(Shape shape) {
  shape.draw();
  }
  }
  在这个代码中, 分割线上方的代码是类的实现者编写的, 分割线下方的代码是类的调用者编写的。
  当类的调用者在编写 drawMap 这个方法的时候, 参数类型为 Shape (父类), 此时在该方法内部并不知道, 也不关注当前的 shape 引用指向的是哪个类型(哪个子类)的实例. 此时 shape 这个引用调用 draw 方法可能会有多种不同的表现(和 shape 对应的实例相关), 这种行为就称为多态。
  使用多态的好处：
  一、类调用者对类的使用成本进一步降低。
  1.封装是让类的调用者不需要知道类的实现细节。
  2.多态能让类的调用者连这个类的类型是什么都不必知道, 只需要知道这个对象具有某个方法即可。
  二、能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
  例如我们现在需要打印的不是一个形状了, 而是多个形状. 如果不基于多态, 实现代码如下:
  public static void drawShapes() {
  Rect rect = new Rect();
  Cycle cycle = new Cycle();
  Flower flower = new Flower();
  String[] shapes = {“cycle”, “rect”, “cycle”, “rect”, “flower”};

for (String shape : shapes) {
if (shape.equals(“cycle”)) {
cycle.draw();
} else if (shape.equals(“rect”)) {
rect.draw();
} else if (shape.equals(“flower”)) {
flower.draw();
}
}
}
如果使用使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单。
public static void drawShapes() {
// 我们创建了一个 Shape 对象的数组.
Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),
new Rect(), new Flower()};
for (Shape shape : shapes) {
shape.draw();
}
}
圈复杂度：一段代码中条件语句和循环语句出现的个数, 这个个数就称为 “圈复杂度”.。如果一个方法的圈复杂度太高, 就需要考虑重构。
三、可扩展能力更强
如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低
class Triangle extends Shape {
@Override
public void draw() {
System.out.println(“△”);
}
}
对于类的调用者来说(drawShapes方法), 只要创建一个新类的实例就可以了, 改动成本很低。
而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高。
向下转型：
向上转型是子类对象转成父类对象, 向下转型就是父类对象转成子类对象. 相比于向上转型来说, 向下转型没那么常见,但是也有一定的用途。
// 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);
}

public void fly() {
System.out.println(this.name + “正在飞”);
}
}


注意事项：
编译过程中, animal 的类型是 Animal, 此时编译器只知道这个类中有一个 eat 方法, 没有 fly 方法。
虽然 animal 实际引用的是一个 Bird 对象, 但是编译器是以 animal 的类型来查看有哪些方法的。
对于 Animal animal = new Bird(“圆圆”) 这样的代码,
1.编译器检查有哪些方法存在, 看的是 Animal 这个类型。
2.执行时究竟执行父类的方法还是子类的方法, 看的是 Bird 这个类型。
那么想实现刚才的效果, 就需要向下转型。

为了让向下转型更安全, 我们可以先判定一下看看 animal 本质上是不是一个 Bird 实例, 再来转换。

instanceof 可以判定一个引用是否是某个类的实例. 如果是, 则返回 true. 这时再进行向下转型就比较安全了。
super关键字：super 表示获取到父类实例的引用
1.使用了 super 来调用父类的构造器。
2.使用 super 来调用父类的普通方法。
抽象类：像这种没有实际工作的方法, 我们可以把它设计成一个 抽象方法(abstract method), 包含抽象方法的类我们称为 抽象类(abstract class)。
abstract class Shape {
abstract public void draw();
}
在 draw 方法前加上 abstract 关键字, 表示这是一个抽象方法. 同时抽象方法没有方法体(没有 { }, 不能执行具体代码)。
对于包含抽象方法的类, 必须加上 abstract 关键字表示这是一个抽象类。
注意事项：
1.抽象类不能直接实例化。
2.抽象方法不能是 private 的。
3.抽象类中可以包含其他的非抽象方法, 也可以包含字段. 这个非抽象方法和普通方法的规则都是一样的, 可以被重写,也可以被子类直接调用。
抽象类的作用：
抽象类存在的最大意义就是为了被继承。
抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法。
接口：接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量。
interface IShape {
void draw();
}
class Cycle implements IShape {
@Override
public void draw() {
System.out.println(“○”);
}
}
public class Test {
public static void main(String[] args) {
IShape shape = new Rect();
shape.draw();
}
}
注意事项：
1.使用 interface 定义一个接口。
2.接口中的方法一定是抽象方法, 因此可以省略 abstract。
3.接口中的方法一定是 public, 因此可以省略 public。
4.Cycle 使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现”
在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例。
5.接口不能单独被实例化。
接口中只能包含抽象方法. 对于字段来说, 接口中只能包含静态常量(final static)

其中的 public, static, final 的关键字都可以省略. 省略后的 num 仍然表示 public 的静态常量。
接口间的继承：接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
…
}
通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”. 此时实现接口创建的 Frog 类, 就继续要实现 run 方法,也需要实现 swim 方法。
接口间的继承相当于把多个接口合并在一起
核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。