GroupBlog

何谓继承

继承的基本概念就不在赘述。

多态与is-a

在Java中，子类只能继承一个父类，子类与父类之间会有is-a的关系，我们称之为“是一种”的关系。我们要理解多态，必须知道我们操作的对象是“哪一种”东西。我们可以将自己当做编译程序，检查语法的逻辑是否正确，方法是从=号右边往左读，右边是不是左边的一种呢（右边的类是不是左边的一种子类呢）。

有效的理解多态有助于我们写出来的东西更加的有弹性，更好的维护。

我们来看一个例子：现在让你设计一个方法，要求显示一些游戏角色中的血量。
有人会用重载方法进行设计：

public static void showBlood(SwordsMan swordsMan)
{
    System.out.printf("%s 血量 %d %n", swordsMan.getName(), swordsMan.getBlood());
}

public static void showBlood(Magician magician)
{
    System.out.printf("%s 血量 %d %n", magician.getName(), magician.getBlood());
}

这的确是一个可行的方法，但是如果当我们要显示100个甚至更多的角色血量时，难道要重载出100个方法？这显然是不可能的，我们这时候就可以用下面的方法。

我们知道上面的两个角色都是继承于一种父类，我们暂且将父类命名为Role，我们可以用以下的方法设计并调用：

static void showBlood(Role role)
{
    System.out.printf("%s 血量 %d %n", role.getName(), role.getBlood());
}

showBlood(swordsMan);
showBlood(magician);

可以像上面这样设计的，是因为SwordsMan是一种Role，magician是一种Role。

这就是多态，可以使用单一接口操作多种类型的对象。

重新定义行为

我们有这个需求是当我们需要操作接口相同，而操作内容不同时，可以将这个方法提升至父类。在父类中只是定义了这个方法，但是具体的操作内容是由子类来执行的。在继承父类后，定义与父类中相同的方法部署，但执行的内容不同，这称为重新定义。

标注：在子类中的某个方法前标注 @Override ，表示要求编译程序检查，该方法是不是真正的重新定义了父类中的某个方法，如果不是的话就会引发错误。

抽象方法，抽象类

在上面提到过重新定义行为，当我们在一个类中没有对这个类中的方法写具体操作的代码的时候，这个方法只是被定义了，我们称它为抽象方法，定义这个方法的时候必须加上abstract名称，表示这个方法是不完整的，此时这个类的声明也必须加上abstract，表明这个类也是不完整的，这个类就不能用来生成实例，子类如果继承了抽象类，对抽象方法有两种处理方法，一种就是继续定义它为抽象方法，另一种就是操作这个抽象方法。

继承语法细节

protected成员

protected与static和public一样都是对权限的一种限制，被声明为protected的成员，在相同的包中可以直接存取，在不同的包中，只有继承了父类之后才能进行存取。

重新定义的细节

如果我们想在子类中使用父类中的方法或构造函数，我们可以使用super关键字，当我们使用super调用父类中的方法时，这个方法不能被声明为private。
重新定义方法时，我们对于父类中的方法权限只能扩大，不能缩小。
在JDK5之后，如果子类中重新定义的方法的返回类型是父类方法返回类型的子类，是可以通过编译的。

再看构造函数

构造函数可以重载，父类可以重载多个构造函数，如果子类构造函数中没有指定使用父类中的哪个构造函数，就会默认使用父类中无参数的构造函数。
如果自行定义了构造函数，就不会加入任何构造函数，来看个例子：

class Some
{
    Some(int i)
    {
        out.println("....");
    }
}

class Other extend Some
{
    Other()
    {
        out.println(".....");
    }
}

这是会报错的，因为我们在Some类中已经定义了Some(int i)这个方法，所以不会默认给Some类中加入无参数的方法，当我们编译Other()方法时，程序默认调用父类中的无参数方法，但是父类中没有无参数的方法，所以就会报错。

再看final方法

如果class之前由final方法，表示这个类是最后一个了，不会有子类，也就是不能被继承。
定义方法的时候，也可以限定该方法是final，表明子类中不可以重新定义该方法。

Java.lang.Object

在Java中，如果我们没有指定一个类继承哪个类的时候，默认是继承自Object的，因此Object是最上层的父类，即所有的对象都“是一种”Object。
Array类：可以不限长度的收集对象。来看一个例子：

package com.paranoid;

import java.util.Arrays;

public class ArrayList
{
    private Object[] list;       //使用Object数组收集
    private int next;            //下一个可存储对象的索引

    public ArrayList(int capacity)          //指定初始容量
    {
        list = new Object(capacity);
    }

    public ArrayList()                      //初始容量默认为16
    {
        this(16);
    }

    public void add(Object o)               //收集对象方法
    {
        if(next == list.length)
        {
            list = Arrays.copyOf(list, list.length*2);
        }
        list[next++] = o;
    } 

    public Object get(int index)             //依索引取得收集的对象
    {
        return list[index];
    }
    public int size()                        //已收集对象的个数
    {
        return next;
    }
}

关于equals()和“==”

对于这两个的不同，现在只是浅要的说一下，==比较的是两个变量所参考的是不是同一个对象，而equals()比较的是两个对象的实质相等性。
对于instanceof它判断的是对象是否是由某个类创建的，左操作数是对象，右操作数是类。左边是否是由右边创建的。

关于垃圾收集

创建对象的时候会占据内存，如果程序流程中已经无法再使用某个对象，该对象只是对耗内存的垃圾。对于不再有用的对象，JVM中有垃圾收集机制。

无法通过变量参考的对象就是垃圾。