继承，顾名思义，即从已经存在的类中定义新的类。
使用继承，为了程序更加利于编写和维护。
因为属性和方法的继承，子类往往比它的父类包含更多的信息和方法。
利用父类定义的公共的访问器（get）和修改器（set），可以访问父类的私有数据域。
JAVA不允许多重继承，子类只能有一个父类，但类似功能可在接口中实现。
设计思考：
为什么每个类最好要设计一个无参构造方法？
例：
public class Apple extends Fruit{
}
class Fruit{
public Fruit(String name){
System.out.println("aa");
}
}
由于在Apple中无显式定义的构造方法，因此，Apple的默认无参构造方法被隐式调用。
由于Apple是Fruit的子类，所以Apple的默认构造方法会自动调用Fruit的无参构造方法。
然而，Fruit并没有无参构造方法，因为Fruit显式定义了构造方法，因此程序不能被成功编译。
所以设计一个无参构造方法，以便于对该类进行扩展，避免错误。
调用父类的方法：
关键字super()
super()不仅可以引用父类的构造方法，也可以引用父类的方法。
方法重写：
子类修改父类中定义的方法的实现，这称作方法重写。
需要在子类中使用和父类一样的签名以及一样的返回值类型来对该方法进行定义。
但需要注意一点：
私有方法在它的类本身以外是不能访问的，它不能被覆盖。
静态方法可以继承，但不能覆盖，如果子类重新定义父类静态方法，那么在父类中定义的静态方法将被隐藏；
被隐藏的方法可以通过父类名.方法调用。例如：
Test.java
package test;
public class Test2 {
public Test2() {};
public static void test2() {
System.out.println('6');
};
}
Test2.java
package test;
import java.util.regex.*;
public class Test extends Test2 {
public Test() {};
public static void test2() {
System.out.println('1');
}
public static void main(String[] args) {
Test t = new Test();
t.test2();
Test2.test2();
}
}
方法重写与重载：
重写意味着在子类中提供一个对于方法的新的实现。
那么重载意味着使用同样的名字但是不同的签名来定义多个方法。
粗略看，区别在于参数~
Identify the problems in the following code:
public class Circle {
private double radius;
public Circle(double radius) {
radius = radius;
}
public double getRadius() {
return radius;
}
public double getArea() {
return radius * radius * Math.PI;
}
}
class B extends Circle {
private double length;
B(double radius, double length) {
Circle(radius);
length = length;
} @Override
public double getArea() {
return getArea() * length;
}
}
The following lines are erroneous:
{
radius = radius; // Must use this.radius = radius
}
class B extends Circle
{
Circle(radius); // Must use super(radius)
length = length; // Must use this.length = length
}
public double getArea()
{
return getArea()*length; // super.getArea(){ radius = radius; // Must use}ps：JAVA中
方法前不写关键字，默认模式是frienly，即一个包内的类可以访问。