**继承**的基本思想是基于某个父类的扩展，并制定出一个新的子类，子类可以继承父类原有的属性和方法，也可以增加原来父类所不具备的属性和方法，或者直接重写父类中的某些方法。例如，平行四边形是特殊的四边形，如果说平行四边形类继承了四边形类，那么平行四边形类就在保留四边形类所有属性和方法的同时，还扩展了一些平行四边形类特有的属性和方法
## 实例1： 使用继承表现 Pad和 Computer 的关系
创建一个电脑类 Computer，Computer 类中有屏幕属性 screen 和开机方法 startup()。现 Computer类有一个子类 Pad（平板电脑）类，除了和 Computer类具有相同的屏幕属性和开机方法以外，Pad类还有电池属性 battery，使用继承表现 Pad 和 Computer 的关系。代码如下∶
```java
class Computer { // 父类：电脑
	String screen = "液晶显示屏"; // 属性：屏幕

	void startup() { // 方法：开机
		System.out.println("电脑正在开机，请等待...");
	}
}

public class Pad extends Computer { // 子类：平板电脑
	String battery = "5000毫安电池"; // 平板电脑的属性：电池

	public static void main(String[] args) {
		Computer pc = new Computer(); // 创建电脑类对象
		System.out.println("computer的屏幕是：" + pc.screen);
		pc.startup(); // 电脑类对象调用开机方法
		Pad ipad = new Pad(); // 创建平板电脑类对象
		System.out.println("pad的屏幕是：" + ipad.screen); // 平板电脑类对象使用父类属性
		System.out.println("pad的电池是：" + ipad.battery);// 平板电脑类对象使用自己的属性
		ipad.startup(); // 平板电脑类对象使用父类方法
	}
}
```

#### 练习1：创建银行卡类，并设计银行卡的两个子类∶ 储蓄卡与信用卡。


## 实例2：让平板电脑调用台式机的功能
编写一个程序，平板电脑类是普通电脑类的子类，当使用普通电脑时，普通电脑会提示"欢迎使用的信息;当使用平板电脑时，平板电脑会提示"欢迎使用iPad"的信息。代码如下∶
```java

class Computer3 { // 父类：电脑
	String sayHello() { // 方法：打招呼
		return "欢迎使用";
	}
}

public class Pad3 extends Computer3 { // 子类：平板电脑
	String sayHello() { // 子类重写父类方法
		return super.sayHello() + "iPad"; // 调用父类方法并添加字符串
	}

	public static void main(String[] args) {
		Computer3 pc = new Computer3(); // 创建电脑类对象
		System.out.println(pc.sayHello());
		Pad3 ipad = new Pad3(); // 创建平板电脑类对象
		System.out.println(ipad.sayHello());
	}
}
```

#### 练习3：
设计火车类和高铁类，高铁类继承火车类，不管火车类的行进速度是多少，高铁的行进速度永远是火车的二倍。
#### 练习4：
设计人类，有二个自我介绍的方法，输出"我是 XXX";设计博士类，继承人类，博士类自我介绍时输出"我是XXX 博士"。

**扩展知识：**
在开始学习使用class关键字定义类时，就应用到了继承原理，因为在Java中，所有的类都直接或间接继承了java.lang.Obiect类。Obiect类是比较特殊的类，它是所有类的父类，是Java类层中的最高层类。当创建一个类时，除非已经指定要从其他类继承，否则都是从java.lang.Object类继承而来的，所以Java中的每个类都源于java.lang.Object类，如 String、Integer等类都是继承于 Object类。除此之外，自定义的类也都继承于Object类。由于所有类都是Obiect子类，所以在定义类时，省略了extends Object语句。


## 实例3： 编写 add()方法的多个重载形式
在项目中创建 OverLoadTest类，在类中编写add（）方法的多个重载形式，然后在主方法中分别输出这些方法的返回值。代码如下∶
```java

public class OverLoadTest {
	// 定义一个方法
	public static int add(int a) {
		return a;
	}

	// 定义与第一个方法参数个数不同的方法
	public static int add(int a, int b) {
		return a + b;
	}

	// 定义与第一个方法相同名称、参数类型不同的方法
	public static double add(double a, double b) {
		return a + b;
	}

	// 定义一个成员方法
	public static int add(int a, double b) {
		return (int) (a + b);
	}

	// 这个方法与前一个方法参数次序不同
	public static int add(double a, int b) {
		return (int) (a + b);
	}

	// 定义不定长参数
	public static int add(int... a) {
		int s = 0;
		// 根据参数个数循环操作
		for (int i = 0; i < a.length; i++) {
			s += a[i];// 将每个参数的值相加
		}
		return s;// 将计算结果返回
	}

	public static void main(String args[]) {
		System.out.println("调用add(int)方法：" + add(1));
		System.out.println("调用add(int,int)方法：" + add(1, 2));
		System.out.println("调用add(double,double)方法：" + add(2.1, 3.3));
		System.out.println("调用add(int a, double b)方法：" + add(1, 3.3));
		System.out.println("调用add(double a, int b) 方法：" + add(2.1, 3));
		System.out.println("调用add(int... a)不定长参数方法：" + add(1, 2, 3, 4, 5, 6, 7, 8, 9));
		System.out.println("调用add(int... a)不定长参数方法：" + add(2, 3, 4));
	}
}

```
 在本实例中分别定义了6个方法，在这 6个方法中，前两个方法的参数个数不同，所以构成.了重载关系; 前两个方法与第3 个方法比较时，方法的参数类型不同，并且方法的返回值类型也不同，所以这 3 个方法也构成了重载关系;比较第 4、第5两个方法时，会发现除了参数的出现顺序不同之外，其他都相同，这样同样可以根据这个区别将两个方法构成重载关系; 而最后一个使用不定长参数的方法，实质上与参数数量不同是一个概念，也构成了重载。

 #### 练习5：
 使用方法的重载描述所有的超市都支持现金付款，但大型商超还支持刷卡付款。

 #### 练习6：
 使用方法的重载描述所有的汽车都至少有两块脚踏板，但手动挡汽车有三块脚踏板。

 