计算机程序的思维逻辑 (15) - 初识继承和多态

Posted 2020-08-26 黄金时代1.0

继承

上节我们谈到，将现实中的概念映射为程序中的概念，我们谈了类以及类之间的组合，现实中的概念间还有一种非常重要的关系，就是分类，分类有个根，然后向下不断细化，形成一个层次分类体系。这种例子是非常多的：

在自然世界中，生物有动物和植物，动物有不同的科目，食肉动物、食草动物、杂食动物等，食肉动物有狼、狗、虎等，这些又分为不同的品种 ...

打开电商网站，在显著位置一般都有分类列表，比如家用电器、服装，服装有女装、男装，男装有衬衫、牛仔裤等 ...

计算机程序经常使用类之间的继承关系来表示对象之间的分类关系。在继承关系中，有父类和子类，比如动物类Animal和狗类Dog，Animal是父类，Dog是子类。父类也叫基类，子类也叫派生类，父类子类是相对的，一个类B可能是类A的子类，是类C的父类。

之所以叫继承是因为，子类继承了父类的属性和行为，父类有的属性和行为，子类都有。但子类可以增加子类特有的属性和行为，某些父类有的行为，子类的实现方式可能与父类也不完全一样。

使用继承一方面可以复用代码，公共的属性和行为可以放到父类中，而子类只需要关注子类特有的就可以了，另一方面，不同子类的对象可以更为方便的被统一处理。

本节主要通过图形处理中的一些简单例子来介绍Java中的继承，会介绍继承的基本概念，关于继承更深入的讨论和实现原理，我们在后续章节介绍。

Object

在Java中，所有类都有一个父类，即使没有声明父类，也有一个隐含的父类，这个父类叫Object。Object没有定义属性，但定义了一些方法，如下图所示：

本节我们会介绍toString()方法，其他方法我们会在后续章节中逐步介绍。toString()方法的目的是返回一个对象的文本描述，这个方法可以直接被所有类使用。

比如说，对于我们之前介绍的Point类，可以这样使用toString方法：

Point p = new Point(2,3);
System.out.println(p.toString()); 

输出类似这样：

Point@76f9aa66

这是什么意思呢？@之前是类名，@之后的内容是什么呢？我们来看下toString的代码：

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

getClass().getName() 返回当前对象的类名，hashCode()返回一个对象的哈希值，哈希我们会在后续章节中介绍，这里可以理解为是一个整数，这个整数默认情况下，通常是对 象的内存地址值，Integer.toHexString(hashCode())返回这个哈希值的16进制表示。

为什么要这么写呢？写类名是可以理解的，表示对象的类型，而写哈希值则是不得已的，因为Object类并不知道具体对象的属性，不知道怎么用文本描述，但又需要区分不同对象，只能是写一个哈希值。

但子类是知道自己的属性的，子类可以重写父类的方法，以反映自己的不同实现。所谓重写，就是定义和父类一样的方法，并重新实现。

Point类 - 重写toString()

我们再来看下Point类，这次我们重写了toString()方法。

public class Point {
    private int x;
    private int y;
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public double distance(Point point){
        return Math.sqrt(Math.pow(this.x-point.getX(),2)
                +Math.pow(this.y-point.getY(), 2));
    }
    
    public int getX() {
        return x;
    }
    
    public int getY() {
        return y;
    }

    @Override
    public String toString() {
        return "("+x+","+y+")";
    }
}

toString方法前面有一个 @Override，这表示toString这个方法是重写的父类的方法，重写后的方法返回Point的x和y坐标的值。重写后，将调用子类的实现。比如，如下代码的输出就变成了：(2,3)

Point p = new Point(2,3);
System.out.println(p.toString());

图形处理类

接下来，我们以一些图形处理中的例子来进一步解释，先来看幅图：

 

这都是一些基本的图形，图形有线、正方形、三角形、圆形等，图形有不同的颜色。接下来，我们定义以下类来说明关于继承的一些概念：

• 父类Shape，表示图形。
• 类Circle，表示圆。
• 类Line，表示直线。
• 类ArrowLine，表示带箭头的直线。 

图形 (Shape)

所有图形都有一个表示颜色的属性，有一个表示绘制的方法，下面是代码：

public class Shape {
    private static final String DEFAULT_COLOR = "black";
    
    private String color;
    
    public Shape() {
        this(DEFAULT_COLOR);
    }

    public Shape(String color) {
        this.color = color;
    }
    
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    
    public void draw(){
        System.out.println("draw shape");
    }
}

以上代码基本没什么可解释的，实例变量color表示颜色，draw方法表示绘制，我们不会写实际的绘制代码，主要是演示继承关系。

圆 (Circle)

圆继承自Shape，但包括了额外的属性，中心点和半径，以及额外的方法area，用于计算面积，另外，重写了draw方法，代码如下：

public class Circle extends Shape {
    //中心点
    private Point center;
    
    //半径
    private double r; 

    public Circle(Point center, double r) {
        this.center = center;
        this.r = r;
    }

    @Override
    public void draw() {
        System.out.println("draw circle at "
                +center.toString()+" with r "+r
                +", using color : "+getColor());    
    }
    
    public double area(){
        return Math.PI*r*r;
    }
}

说明几点：

• Java使用extends关键字标明继承关系，一个类最多只能有一个父类。
• 子类不能直接访问父类的私有属性和方法，比如，在Circle中，不能直接访问shape的私有实例变量color。
• 除了私有的外，子类继承了父类的其他属性和方法，比如，在Circle的draw方法中，可以直接调用getColor()方法。 

看下使用它的代码：

public static void main(String[] args) {
    Point center = new Point(2,3);
    //创建圆，赋值给circle
    Circle circle = new Circle(center,2);
    //调用draw方法，会执行Circle的draw方法
    circle.draw();
    //输出圆面积
    System.out.println(circle.area());
}

程序的输出为：

draw circle at (2,3) with r 2.0, using color : black
12.566370614359172

这里比较奇怪的是，color是什么时候赋值的？在new的过程中，父类的构造方法也会执行，且会优先于子类先执行。在这个例子中，父类Shape的默认构造方法会在子类Circle的构造方法之前执行。关于new过程的细节，我们会在后续章节进一步介绍。

直线 (Line)

线继承自Shape，但有两个点，有一个获取长度的方法，另外，重写了draw方法，代码如下：

public class Line extends Shape {
    private Point start;
    private Point end;
    
    public Line(Point start, Point end, String color) {
        super(color);
        this.start = start;
        this.end = end;
    }

    public double length(){
        return start.distance(end);
    }
    
    public Point getStart() {
        return start;
    }

    public Point getEnd() {
        return end;
    }
    
    @Override
    public void draw() {
        System.out.println("draw line from "
                + start.toString()+" to "+end.toString()
                + ",using color "+super.getColor());
    }
}

这里我们要说明的是super这个关键字，super用于指代父类，可用于调用父类构造方法，访问父类方法和变量：

• 在line构造方法中，super(color)表示调用父类的带color参数的构造方法，调用父类构造方法时，super(...)必须放在第一行。
• 在draw方法中，super.getColor()表示调用父类的getColor方法，当然不写super.也是可以的，因为这个方法子类没有同名的，没有歧义，当有歧义的时候，通过super.可以明确表示调用父类的。
• super同样可以引用父类非私有的变量。

可以看出，super的使用与this有点像，但super和this是不同的，this引用一个对象，是实实在在存在的，可以作为函数参数，可以作为返回值，但super只是一个关键字，不能作为参数和返回值，它只是用于告诉编译器访问父类的相关变量和方法。

带箭头直线 (ArrowLine)

带箭头直线继承自Line，但多了两个属性，分别表示两端是否有箭头，也重写了draw方法，代码如下：

public class ArrowLine extends Line {
    
    private boolean startArrow;
    private boolean endArrow;
    
    public ArrowLine(Point start, Point end, String color, 
            boolean startArrow, boolean endArrow) {
        super(start, end, color);
        this.startArrow = startArrow;
        this.endArrow = endArrow;
    }

    @Override
    public void draw() {
        super.draw();
        if(startArrow){
            System.out.println("draw start arrow");
        }
        if(endArrow){
            System.out.println("draw end arrow");
        }
    }
}

ArrowLine继承自Line，而Line继承自Shape，ArrowLine的对象也有Shape的属性和方法。

注意draw方法的第一行，super.draw()表示调用父类的draw()方法，这时候不带super.是不行的，因为当前的方法也叫draw()。

需要说明的是，这里ArrowLine继承了Line，也可以直接在类Line里加上属性，而不需要单独设计一个类ArrowLine，这里主要是演示继承的层次性。

图形管理器

使用继承的一个好处是可以统一处理不同子类型的对象，比如说，我们来看一个图形管理者类，它负责管理画板上的所有图形对象并负责绘制，在绘制代码中，只需要将每个对象当做Shape并调用draw方法就可以了，系统会自动执行子类的draw方法。代码如下：

public class ShapeManager {
    private static final int MAX_NUM = 100;
    private Shape[] shapes = new Shape[MAX_NUM];
    private int shapeNum = 0;
    
    public void addShape(Shape shape){
        if(shapeNum<MAX_NUM){
            shapes[shapeNum++] = shape;    
        }
    }
    
    public void draw(){
        for(int i=0;i<shapeNum;i++){
            shapes[i].draw();
        }
    }
}

ShapeManager使用一个数组保存所有的shape，在draw方法中调用每个shape的draw方法。ShapeManager并不知道每个shape具体的类型，也不关心，但可以调用到子类的draw方法。

我们来看下使用ShapeManager的一个例子：

public static void main(String[] args) {
    ShapeManager manager = new ShapeManager();
    
    manager.addShape(new Circle(new Point(4,4),3));
    manager.addShape(new Line(new Point(2,3),
            new Point(3,4),"green"));
    manager.addShape(new ArrowLine(new Point(1,2), 
            new Point(5,5),"black",false,true));
    
    manager.draw();
}

新建了三个shape，分别是一个圆、直线和带箭头的线，然后加到了shape manager中，然后调用manager的draw方法。

需要说明的是，在addShape方法中，参数Shape shape，声明的类型是Shape，而实际的类型则分别是Circle，Line和ArrowLine。子类对象赋值给父类引用变量，这叫向上转型，转型就是转换类型，向上转型就是转换为父类类型。

变量shape可以引用任何Shape子类类型的对象，这叫多态，即一种类型的变量，可引用多种实际类型对象。这样，对于变量shape，它就有两个类型，类型Shape，我们称之为shape的静态类型，类型Circle/Line/ArrowLine，我们称之为shape的动态类型。在ShapeManager的draw方法中，shapes[i].draw()调用的是其对应动态类型的draw方法，这称之为方法的动态绑定。

为什么要有多态和动态绑定呢？创建对象的代码 (ShapeManager以外的代码）和操作对象的代码(ShapeManager本身的代码），经常不在一起，操作对象的代码往往只知道对象是某种父类型，也往往只需要知道它是某种父类型就可以了。

可以说，多态和动态绑定是计算机程序的一种重要思维方式，使得操作对象的程序不需要关注对象的实际类型，从而可以统一处理不同对象，但又能实现每个对象的特有行为。后续章节我们会进一步介绍动态绑定的实现原理。

小结

本节介绍了继承和多态的基本概念：

• 每个类有且只有一个父类，没有声明父类的其父类为Object，子类继承了父类非private的属性和方法，可以增加自己的属性和方法，可以重写父类的方法实现。
• new过程中，父类先进行初始化，可通过super调用父类相应的构造方法，没有使用super的话，调用父类的默认构造方法。
• 子类变量和方法与父类重名的情况下，可通过super强制访问父类的变量和方法。
• 子类对象可以赋值给父类引用变量，这叫多态，实际执行调用的是子类实现，这叫动态绑定。

但关于继承，还有很多细节，比如实例变量重名的情况。另外，继承虽然可以复用代码，便于统一处理不同子类的对象，但继承其实是把双刃剑，使用不当，也有很多问题。让我们下节来讨论这些问题，而关于继承和多态的实现原理，让我们再下节来讨论。

----------------