diff --git a/Java/练习题：基本数据类型与变量.md b/Java/练习题：基本数据类型与变量.md
new file mode 100644
index 0000000..75e2a88
--- /dev/null
+++ b/Java/练习题：基本数据类型与变量.md
@@ -0,0 +1,30 @@
+## 实例：   根据身高、体重计算BMI值
+创建 BMIexponent 类，声明double 型变量height 记录身高，单位为米，声明 int 型变量 weight 记录体重，单位为千克，根据 BMI= 体重/（身高× 身高）的公式计算 BMI指数，实例代码如下∶
+```java
+public class BMIexponent {
+	public static void main(String[] args) {
+		double height = 1.82;							// 身高变量，单位：米
+		int weight = 65;								// 体重变量,单位:千克
+		double exponent = weight / (height * height);	// BMI计算公式
+		System.out.println("您的身高为：" + height);
+		System.out.println("您的体重为：" + weight);
+		System.out.println("您的BMI指数为：" + exponent);
+		System.out.print("您的体重属于：");
+		if (exponent < 18.5) {					// 判断BMI指数是否小于18.5
+			System.out.println("体重过轻");
+		}
+		if (exponent >= 18.5 && exponent < 24.9) {	// 判断BMI指数是否在18.5到24.9之间
+			System.out.println("正常范围");
+		}
+		if (exponent >= 24.9 && exponent < 29.9) {	// 判断BMI指数是否在24.9到29.9之间
+			System.out.println("体重过重");
+		}
+		if (exponent >= 29.9) {					// 判断BMI指数是否大于29.9之间
+			System.out.println("肥胖");
+		}
+	}
+}
+```
+#### 练习1：试着实现将37摄氏度转换为整型的华氏度。（提示∶ 华氏度 =32+摄氏度 ×1.8）
+#### 练习2：一个圆柱形粮仓，底面值径为 10米，高为 3米，该粮仓体积为多少立方米?如果每立方米屯粮 750 千克，该粮仓一共可储存多少千克粮食? 
+
diff --git a/Java/练习题：抽象类与接口.md b/Java/练习题：抽象类与接口.md
new file mode 100644
index 0000000..c02ac8b
--- /dev/null
+++ b/Java/练习题：抽象类与接口.md
@@ -0,0 +1,155 @@
+**思考：** 构造方法能作为抽象方法吗？
+
+## 实例1：使用抽象类模拟"去商场买衣服"场景
+
+"去商场买衣服"，这句话描述的是一个抽象的行为∶到底去哪个商场买衣服，是实体店还是网店，买什么样的衣服，是短衫、裙子，还是其他的什么衣服?在"去商场买衣服"这句话中，并没有为"买衣服"这个抽象行为指明一个确定的信息。设计一个商场的抽象类，并在其中定义买东西的抽象方法，具体是什么商场、买什么东西，交给子类去实现即可。代码如下∶
+```java
+public abstract class Market {
+	public String name; // 商场名称
+	public String goods; // 商品名称
+
+	public abstract void shop(); // 抽象方法，用来输出信息
+}
+```
+定义一个TaobaoMarket类，继承自 Market 抽象类，实现其中的shop()抽象方法:
+```java
+public class TaobaoMarket extends Market {
+	public void shop() {
+		System.out.println(name + "网购" + goods);
+	}
+}
+```
+定义一个 WallMarket 类，继承自Market 抽象类，实现其中的shop()抽象方法:
+```java
+
+public class WallMarket extends Market {
+	public void shop() {
+		System.out.println(name + "实体店购买" + goods);
+	}
+}
+```
+定义一个 GoShopping类，在该类中分别使用WallMarket类和TaobaoMarket类创建抽象类的对象，并分别给抽象类中的成员变量赋不同的值，调用 shop()方法分别输出结果:
+```java
+public class GoShopping {
+	public static void main(String[] args) {
+		Market market = new WallMarket(); // 使用派生类对象创建抽象类对象
+		market.name = "沃尔玛";
+		market.goods = "七匹狼西服";
+		market.shop();
+		market = new TaobaoMarket(); // 使用派生类对象创建抽象类对象
+		market.name = "淘宝";
+		market.goods = "韩都衣舍花裙";
+		market.shop();
+	}
+}
+```
+
+#### 练习1：
+创建 Shape（图形）类，该类中有一个计算面积的方法。圆形和矩形都继承自图形类，输出圆形和矩形的面积。
+
+#### 练习2：
+创建工厂类，工厂类中有一个抽象的生产方法，创建汽车厂和鞋厂类，重写工厂类中的抽象生产方法，输出汽车厂生产的是汽车，鞋厂生产的是鞋。
+
+ 
+     
+
+
+**使用抽象类和抽象方法时，需要遵循以下原则**∶
+- 在抽象类中，可以包含抽象方法，也可以不包含抽象方法，但是包含了抽象方法的类必须被定义为抽象类。
+- 抽象类不能直接被实例化，即使抽象类中没有声明抽象方法，也不能被实例化。
+- 抽象类被继承后，子类需要重写抽象类中所有的抽象方法。
+- 如果继承抽象类的子类也被声明为抽象类，则可以不用重写父类中所有的抽象方法。使用抽象类时，可能会出现这样的问题;程序中会有太多冗余的代码，同时父类的局限性很大。例如，上面的例子中，也许某个不需要 shop()方法的子类也必须重写 shop()方法。如果将这个 shop()方法从父类中拿出，放在别的类里，又会出现新间题∶某些类想要实现"买衣服"的场景，意然需要继承两个父类。Java中规定，一个类不能同时继承多个父类，为解决这种问题，接口应运而生。
+
+
+## 实例2：通过实现接口 绘制出特殊的平行四边形
+特殊的平行四边形有矩形、正方形和菱形。现使用接口的相关知识绘制出特殊的平行四边形。
+```java
+
+interface DrawImage { // 定义“画图形”接口
+	public void draw(); // 定义抽象方法“画”
+}
+
+class Rectangle implements DrawImage { // 矩形类实现了drawTest接口
+	public void draw() { // 矩形类中实现draw()方法
+		System.out.println("画矩形");
+	}
+}
+
+class Square implements DrawImage { // 正方形类实现了drawTest接口
+	public void draw() { // 正方形类中实现draw()方法
+		System.out.println("画正方形");
+	}
+}
+
+class Diamond implements DrawImage { // 菱形类实现了drawTest接口
+	public void draw() { // 菱形类中实现draw()方法
+		System.out.println("画菱形");
+	}
+}
+
+public class SpecialParallelogram { // 定义特殊的平行四边形类
+	public static void main(String[] args) {
+		// 接口也可以进行向上转型操作
+		DrawImage[] images = { new Rectangle(), new Square(), new Diamond() };
+		// 遍历“画图形”接口类型的数组
+		for (int i = 0; i < images.length; i++) {
+			images[i].draw(); // 调用draw()方法
+		}
+	}
+}
+```
+
+**提醒：**  由于接口中的方法都是抽象方法，所以当子类实现接口时，必须实现接口中的所有抽象方法。
+
+
+## 实例3： 使用继承输出儿子喜欢做的事
+爸爸喜欢做的事有抽烟和钓鱼，妈妈喜欢做的事有看电视和做饭，儿子完全继承了爸爸妈妈的爱好，使用多重继承输出儿子喜欢做的事。首先定义一个DadLikeDo接口，并在接口中定义两个方法 smoke()和 fish():
+```java
+public interface DadLikeDo { // 定义“爸爸喜欢做的事”接口
+	void smoke(); // 抽烟的方法
+
+	void fish(); // 钓鱼的方法
+}
+
+public interface MomLikeDo { // 定义“妈妈喜欢做的事”接口
+	void watchTV(); // 看电视的方法
+
+	void cook(); // 做饭的方法
+}
+
+
+// 继承DadLikeDo接口和MomLikeDo接口
+public class SonLikeDo implements DadLikeDo, MomLikeDo {
+	public void watchTV() { // 实现watchTV()方法
+		System.out.println("看电视");
+	}
+
+	public void cook() { // 实现cook()方法
+		System.out.println("做饭");
+	}
+
+	public void smoke() { // 实现smoke()方法
+		System.out.println("抽烟");
+	}
+
+	public void fish() { // 实现fish()方法
+		System.out.println("钓鱼");
+	}
+
+	public static void main(String[] args) {
+		SonLikeDo son = new SonLikeDo(); // 通过子类创建IFather接口对象
+		System.out.println("儿子喜欢做的事有：");
+		// 子类对象调用DadLikeDo和MomLikeDo两个接口被实现的所有方法
+		son.watchTV();
+		son.cook();
+		son.smoke();
+		son.fish();
+	}
+}
+
+
+
+```
+
+**思考：**
+如何区分抽象类和接口？有哪些不同？
\ No newline at end of file
diff --git a/Java/练习题：控制流程.md b/Java/练习题：控制流程.md
new file mode 100644
index 0000000..7e9209c
--- /dev/null
+++ b/Java/练习题：控制流程.md
@@ -0,0 +1,129 @@
+## 实例1：使用 if…else if 语句实现饭店座位分配
+创建 Restaurant类，声明整型变量count表示用餐人数，根据人数安排客人到4人桌、8人桌或包厢用餐，实例代码如下∶ 
+```java
+import java.util.Scanner; //引入Scanner类
+
+public class Restaurant {
+	public static void main(String args[]) {
+		Scanner sc = new Scanner(System.in); // 创建扫描器，获取控制台输入的值
+		System.out.println("欢迎光临，请问有多少人用餐？"); // 输出问题提示
+		int count = sc.nextInt(); // 记录用户输入的用餐人数
+		if (count <= 4) { // 如果人数小于4人
+			System.out.println("客人请到大厅4人桌用餐"); // 请到4人桌
+		} else if (count > 4 && count <= 8) { // 如果人数在4-8人之间
+			System.out.println("客人请到大厅8人桌用餐"); // 请到4人桌
+		} else if (count > 8 && count <= 16) { // 如果人数在8-16人之间
+			System.out.println("客人请到楼上包厢用餐"); // 请到包厢
+		} else { // 当以上条件都不成立时，执行的该语句块
+			System.out.println("抱歉，我们店暂时没有这么大的包厢！"); // 输出信息
+		}
+		sc.close(); // 关闭扫描器
+	}
+}
+```
+
+#### 练习1：将一、二年级学生的学生成绩划分等级，等级划分标准如下∶①"优秀"，大于等于 90分;②"良好"，大于等于 80 分，小于 90分;③"合格"，大于等于 60分，小于80分;④"不合格"，小于 60 分。使用 if…else if语句实现根据控制台输入的成绩，输出与该成绩对应等级的功能。
+#### 练习2：BMI 身体质量指数的等级划分标准如下∶①"偏轻"，BMI 小于18.5;②"正常"，BMI大于等于 18.5，小于25;③"偏重"，BMI 大于等于25，小于30;④"肥胖"，BMI大于等于30。根据控制台输入的身高（ 单位∶ 来）、体重（单位∶ 千克），输出 BMI指数以及与该指数对应的等级。
+
+## 实例2： 用 switch 多分支语句判断成绩等级
+创建 Grade类，使用 Scanner 类在控制台输入成绩，然后用 switch 多分支语句判断输入的分数属于哪个等级。10分和9分属于优，8分属于良，7分和6分属于中，5分、4分、3分、2分、1分以及 0 分均为差，实例代码如下∶ 
+```java
+
+import java.util.Scanner; //引入Scanner类
+
+public class Grade {
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in); // 创建扫描器，接收控制台输入内容
+		System.out.print("请输入成绩："); // 输出字符串
+		int grade = sc.nextInt(); // 获取控制台输入的数字
+		switch (grade) { // 使用switch判断数字
+		case 10: // 如果等于10，则继续执行下一行代码
+		case 9: // 如果等于9
+			System.out.println("成绩为优"); // 输出成绩为优
+			break; // 结束判断
+		case 8: // 如果等于8
+			System.out.println("成绩为良"); // 输出成绩为良
+			break; // 结束判断
+		case 7: // 如果等于7，则继续执行下一行代码
+		case 6: // 如果等于6
+			System.out.println("成绩为中"); // 输出成绩为中
+			break; // 结束判断
+		case 5: // 如果等于5，则继续执行下一行代码
+		case 4: // 如果等于4，则继续执行下一行代码
+		case 3: // 如果等于3，则继续执行下一行代码
+		case 2: // 如果等于5，则继续执行下一行代码
+		case 1: // 如果等于1，则继续执行下一行代码
+		case 0: // 如果等于0
+			System.out.println("成绩为差"); // 输出成绩为差
+			break; // 结束判断
+		default: // 如果不符合以上任何一个结果
+			System.out.println("成绩无效"); // 输出成绩无效
+		}
+		sc.close(); // 关闭扫描器
+	}
+}
+
+```
+
+#### 练习3：使用 switch多分支语句判断控制台输入的某个月份属于哪个季节。
+#### 练习4：使用 switch多分支语句判断控制台输入的某个月份属于哪个季节。（光盘\Code\Try\O3\05）（2）某大型商超为答谢新老顾客，当累计消费金额达到一定数额时，顾客可享受不同的折扣∶①尚未超过 200 元，顾客须按照小票价格支付全款;不少于 200元但尚未超过 600元，顾客全部的消费金额可享 8.5 折优惠;③不少于 600 元但尚未超过 1000 元，顾客全部的消费金额可享 7折优惠;④不少于 1000 元，顾客全部的消费金额可享 6折优惠;
根据顾客购物小票上的消费金额，在控制台上输出该顾客将享受的折扣与打折后需支付的金额。
+
+
+## 实例3：使用 for 循环完成 1～ 100的相加运算
+创建 AdditiveFor类，使用for循环完成1～100的相加运算，实例代码如下∶
+```java
+public class AdditiveFor {
+	public static void main(String[] args) {
+		int sum = 0; // 创建用户求和的变量
+		int i; // 创建用于循环判断的变量
+		for (i = 1; i <= 100; i++) { // for循环语句
+			sum += i; // 循环体内执行的代码
+		}
+		System.out.println("the result :" + sum); // 在循环外输出最后相加的结果
+	}
+}
+```
+$思考：可不可以改写用while实现相加运算呢？$
+
+#### 练习5：有一组数∶ 1、1、2、3、5、8、13、21、34…，请用for循环算出这组数的第n个数是多少?
+#### 练习6：一个球从80米高度自由落下，每次落地后反弹的高度为原高度的一半，第6次落地时共经过多少米?第6次反弹多高？
+
+
+## 实例4：使用嵌套的 for 循环输出乘法口诀表
+创建 Multiplication类，使用两层 for循环实现在控制台输出乘法口诀表，实例代码如下∶
+```java
+
+public class Multiplication {
+	public static void main(String[] args) {
+		int i, j; // i代表行，j代表列
+		for (i = 1; i < 10; i++) { // 输出9行
+			for (j = 1; j < i + 1; j++) { // 输出与行数相等的列
+				System.out.print(j + "*" + i + "=" + i * j + "\t"); // 打印拼接的字符串
+			}
+			System.out.println(); // 换行
+		}
+	}
+}
+```
+
+
+#### 练习7：5文钱可以买一只公鸡，3 文钱可以买一只母鸡，1文钱可以买三只雏鸡，现在用 100文钱买 100 只鸡，那么公鸡、母鸡、雏鸡各有多少只？
+#### 练习8：根据用户控制输入 * 的行数，在控制台中输出相应行数的等腰三角形。
+
+
+## 实例5：找出1 ～ 19 之间所有的偶数
+使用一个for循环输出1～19之间所有的值，如果输出的值是奇数，则使用 continue 语句跳过本次循环，实例代码如下∶
+```java
+public class ContinueTest {
+	public static void main(String[] args) {
+		for (int i = 1; i < 20; i++) { // i的值从1循环至19
+			if (i % 2 != 0) { // 如果i不是偶数
+				continue; // 跳到下一循环
+			}
+			System.out.println(i); // 输出i的值
+		}
+	}
+}
+```
+
+#### 练习：找出1-1000数字种的素数和水花仙数。
diff --git a/Java/练习题：数据类型转换.md b/Java/练习题：数据类型转换.md
new file mode 100644
index 0000000..d15d2a9
--- /dev/null
+++ b/Java/练习题：数据类型转换.md
@@ -0,0 +1,39 @@
+## 实例1：演示隐式转换时自动提升精度的效果
+创建ImplicitConyersion类，让低精度的变量与高精度变量同时做计算，查看计算结果属于哪种精度，实例代码如下∶
+```java
+public class ImplicitConversion {
+	public static void main(String[] args) {
+		// 声明byte型变量mybyte，并把byte型变量允许的最大值赋给mybyte
+		byte mybyte = 127;
+		int myint = 150; 				// 声明int型变量myint，并赋值150
+		float myfloat = 452.12f; 		// 声明float型变量myfloat，并赋值
+		char mychar = 10;			// 声明char型变量mychar，并赋值
+		double mydouble = 45.46546;	// 声明double型变量，并赋值
+		/* 将运算结果输出 */
+		System.out.println("byte型与float型数据进行运算结果为：" + (mybyte + myfloat));
+		System.out.println("byte型与int型数据进行运算结果为：" + mybyte * myint);
+		System.out.println("byte型与char型数据进行运算结果为：" + mybyte / mychar);
+		System.out.println("double型与char型数据进行运算结果为：" + (mydouble + mychar));
+	}
+}
+```
+
+## 实例2：利用显式转换演示精度丢失
+创建 ExplicitConversion类，使用显式转换将不同类型的变量转换成精度更低的类型，输出转换之后发生精度丢失的结果，实例代码如下∶
+```java
+
+public class ExplicitConversion {
+	public static void main(String[] args) {
+		int a = (int) 45.23; 			// double类型强制转化成int类型
+		long b = (long) 456.6F; 		// flaot类型强制转化成long类型
+		char c = (char) 97.14;		// double型强制转换成char型
+		System.out.println("45.23强制转换成int的结果：" + a);
+		System.out.println("456.6F强制转换成long的结果：" + b);
+		System.out.println("97.14强制转换成char的结果" + c);
+	}
+}
+```
+#### 练习1：使用 char型声明'a'～'g'，然后输出它们相加后的结果。
+#### 练习2：IP地址每段数字的最大值可以由byte型的最大值与 short型128相加后得到，使用隐式转换控制台输出 IP 地址每段数字的最大值。
+#### 练习3：将 65～71显式转换为 char 型并输出。
+#### 练习4：一辆货车运输箱子，载货区宽2米，长 4米，一个箱子宽 1.5 米，长 1.5米，请问载货区一层可以放多少个箱子?
\ No newline at end of file
diff --git a/Java/练习题：数组.md b/Java/练习题：数组.md
new file mode 100644
index 0000000..ce35fdd
--- /dev/null
+++ b/Java/练习题：数组.md
@@ -0,0 +1,4 @@
+#### 练习1：遍历二维数组int a[][] = {{23.65，43，68}，{45，99，86，80}，{76，81，34，45}，{88，64，48，25}}后，再通过循环计算该二维数组的两条对角线之和。
+#### 练习2：一个3×3的网格，将从1到9的数字放入方格，达到能够使得每行每列以及每个对角线的值相加都相同。
+#### 练习3：交换二维数组 int array[][] = {{8，75，23}，{21，534}，{15，23，20 }};的行、列数据。
+#### 练习4：使用二维数组实现杨辉三角算法。
\ No newline at end of file
diff --git a/Java/练习题：类与方法.md b/Java/练习题：类与方法.md
new file mode 100644
index 0000000..849dde8
--- /dev/null
+++ b/Java/练习题：类与方法.md
@@ -0,0 +1,44 @@
+扩展知识 
+- 不定长参数：
+声明方法时，如果有若平个相同类型的参数，可以定义为不定长参数，该类型的参数声明如下∶
+```
+权限修饰符 返回值类型 方法名（参数类型... 参数名）
+```
+**注意∶** 参数类型和参数名之间是三个点，而不是其他数量或省略号。
+
+## 实例1：使用 this 关键字实现给饼只加一个蛋
+顾客买鸡蛋灌饼要求加几个蛋，烙饼大妈就给饼加几个蛋，不要求的时候就只加一个蛋。创建鸡蛋灌饼 EggCake 类，创建有参数和无参数构造方法，无参构造方法调用有参数构造方法并实现初始化。
+```java
+public class EggCake { // 创建鸡蛋灌饼EggCake类
+	int eggCount; // 鸡蛋灌饼里蛋的个数（属性）
+	// 有参数构造方法，参数是给饼加蛋的个数
+	public EggCake(int eggCount) { // 参数为鸡蛋灌饼里蛋的个数的构造方法
+		this.eggCount = eggCount; // 将参数eggCount的值付给属性eggCount
+		System.out.println("这个鸡蛋灌饼里有" + eggCount + "个蛋。");
+	}
+	// 无参数构造方法，默认给饼加一个蛋
+	public EggCake() { // 默认构造方法
+		// 调用参数为鸡蛋灌饼里蛋的个数的构造方法，并设置鸡蛋灌饼里蛋的个数为1
+		this(1);
+	}
+	public static void main(String[] args) {
+		EggCake cake1 = new EggCake(); // 创建无参的鸡蛋灌饼对象
+		EggCake cake2 = new EggCake(5); // 创建鸡蛋灌饼对象，且鸡蛋灌饼里有5个蛋
+
+	}
+}
+```
+    定义了两个构造方法，在无参构造方法中可以使用this关键字调用有参的构造方法。但是要注意，this()语句之前不可以有其他代码。
+
+#### 练习1：设计加油站类和汽车类，加油站提供一个给车加油的方法，参数为剩余汽油数量。每次执行加油方法，汽车的剩余汽油数量都会加 2。
+
+
+#### 练习2：智能手机的默认语言为英文。，但制造手机时可以将默认语言设置为中文。编写手机类， 无，参构造方法使用默认语言设计，利用有参构造方法修改手机的默认语言。
+
+#### 练习3：张三去KFC买可乐，商家默认不加冰块。但是张三可以要求加 3 个冰块。请利用有参构造方法实现上述功能。
+
+#### 练习4：创建教师类，类中有姓名、性别和年龄三个属性，在构造方法中使用 this 关键字分别为这三个成员属性赋值。
+
+#### 练习5：一只大熊猫，长 1.3 米，重 90千克。在自定义方法中使用this关键字调用类的成员变量并在控制台输出这只大熊猫的信息。
+
+#### 练习6：创建信用卡类，有两个成员变量分别是卡号和密码，如果用户开户时没有设置初始密码，则使用"123456"作为默认密码。设计两个不同的构造方法，分别用于用户设置密码和用户未设置密码两种构造场景。
\ No newline at end of file
diff --git a/Java/练习题：继承与多态.md b/Java/练习题：继承与多态.md
new file mode 100644
index 0000000..4d570f6
--- /dev/null
+++ b/Java/练习题：继承与多态.md
@@ -0,0 +1,124 @@
+**继承**的基本思想是基于某个父类的扩展，并制定出一个新的子类，子类可以继承父类原有的属性和方法，也可以增加原来父类所不具备的属性和方法，或者直接重写父类中的某些方法。例如，平行四边形是特殊的四边形，如果说平行四边形类继承了四边形类，那么平行四边形类就在保留四边形类所有属性和方法的同时，还扩展了一些平行四边形类特有的属性和方法
+## 实例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：
+ 使用方法的重载描述所有的汽车都至少有两块脚踏板，但手动挡汽车有三块脚踏板。
+
+ 
\ No newline at end of file