diff --git a/Java/练习题：基本数据类型与变量.md b/Java/练习题：基本数据类型与变量.md
index 75e2a88..07942e2 100644
--- a/Java/练习题：基本数据类型与变量.md
+++ b/Java/练习题：基本数据类型与变量.md
@@ -26,5 +26,31 @@ public class BMIexponent {
 }
 ```
 #### 练习1：试着实现将37摄氏度转换为整型的华氏度。（提示∶ 华氏度 =32+摄氏度 ×1.8）
-#### 练习2：一个圆柱形粮仓，底面值径为 10米，高为 3米，该粮仓体积为多少立方米?如果每立方米屯粮 750 千克，该粮仓一共可储存多少千克粮食? 
+```java
+public class CelsiusToFahrenheit {
+	public static void main(String[] args) {
+		int celsius = 37;
+		System.out.println("要转换的摄氏度 = " + celsius);
+		double fahrenheit = 9.0/5 * celsius + 32;
+		int intfahrenheit = (int)fahrenheit;
+		System.out.println("37摄氏度 = " + fahrenheit + "华氏度(未转换成int型)");
+		System.out.println("37摄氏度 = " + intfahrenheit + "华氏度(转换成int型)");
+	}
+}
+
+```
+#### 练习2：一个圆柱形粮仓，底面值径为 10米，高为 3米，该粮仓体积为多少立方米?如果每立方米屯粮 750 千克，该粮仓一共可储存多少千克粮食? 
+```java
+public class Granary {
+	public static void main(String[] args) {
+		final double PI = 3.14;
+		int diameter = 10;
+		int height = 3;
+		double volume = diameter/2 * diameter/2 * PI * height;
+		System.out.println("该粮仓的体积 = " + volume + "立方米");
+		int weight = 750;
+		System.out.println("该粮仓一共可储存" + weight * volume + "千克粮食");
+	}
+}
+```
 
diff --git a/Java/练习题：异常处理.md b/Java/练习题：异常处理.md
index 90069c2..c88c12b 100644
--- a/Java/练习题：异常处理.md
+++ b/Java/练习题：异常处理.md
@@ -37,9 +37,77 @@ public class Tomato { // 创建西红柿类
 
 #### 练习1 
 在控制台上简述一个整型数组，如int a[] ={1，2，3，4 }; 数组遍历的过程,并体现出当i的值为多少时，会产生异常，异常的种类是什么?
+```java
+
+public class Array {// 创建一个Array类
+	public static void main(String args[]) {
+		int a[] = { 1, 2, 3, 4 };// 定义一个int类型的数组
+		for (int i = 0; i < 5; i++) {// 遍历数组
+			try {// try块
+				System.out.print("当 i = " + i + "，" + i + " < 5 时，a[" + i + "] = " + a[i] + "；");// 控制台输出
+			} catch (ArrayIndexOutOfBoundsException e) {// catch块
+				System.out.println("当 i = " + i + "，" + i + " < 5 时，a[" + i + "]不存在，会引起"
+						+ e.toString().substring(10, e.toString().indexOf(':'))
+						+ "异常，\n该异常为数组越界异常，主要是由于索引超出了数组的长度范围引起的");// 控制台输出
+			}
+			if (i != 4) {// 当i不等于4的时候
+				System.out.println("执行i++，" + "i = " + (i + 1) + "。");// 控制台输出
+			}
+		}
+	}
+}
+
+```
 #### 练习2 
 模拟一个简单的整数计算器（只能计算两个整数之间的加、减、乘、除的运算），并用try-catch捕捉InputMismatchException（控制台输入的不是整数）异常。
+```java
 
+import java.util.InputMismatchException;
+import java.util.Scanner;
+
+public class Calculator {// 创建一个Number类
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in); // 控制台输入
+		try {// try块
+			System.out.println("请输入第一个整数："); // 提示信息
+			int num1 = sc.nextInt(); // 声明一个int类型的变量num1接收控制台输入的信息
+
+			System.out.println("请输入运算符号(+、-、*、/)："); // 提示信息
+			String symbol = sc.next(); // 声明一个String类型的变量symbol接收控制台输入的信息
+
+			System.out.println("请输入第二个整数："); // 提示信息
+			int num2 = sc.nextInt(); // 声明一个int类型的变量num1接收控制台输入的信息
+
+			int result = 0; // 定义并初始化“运算结果”
+
+			switch (symbol) {
+			case "+":
+				result = num1 + num2;
+				break;
+			case "-":
+				result = num1 - num2;
+				break;
+			case "*":
+				result = num1 * num2;
+				break;
+			case "/":
+				if (num2 != 0) {
+					result = num1 / num2;
+				} else {
+					System.out.println("除数怎么可能是“0”呢？");
+					return;
+				}
+				break;
+			}
+			System.out.println("运算结果：" + result); // 输出运算结果
+		} catch (InputMismatchException ime) {// catch块
+			System.out.println("对不起！您输入的不是整数，已经引起了" + ime.toString() + "异常；\n" + "即：用户输入的信息与规定的参数类型不符时出现的异常"); // 输出异常的信息
+		}
+		sc.close();
+	}
+}
+
+```
 
 ## 实例2： 捕捉控制台输入西红柿单价后的异常
 西红柿的单价不是一成不变的，修改上面的实例，首先实现控制台输入单价的功能，然后在finally代码块中关闭控制台输入对象。
@@ -86,9 +154,69 @@ public class Tomato { // 创建西红柿类
 
 #### 练习3
 银行账号中现有余额 1023.79 元。模拟取款，当在控制台上输入的取款金额不是整数时，会引起数字格式转换异常。
+```java
+
+import java.util.InputMismatchException;
+import java.util.Scanner;
+
+public class Account { // 创建一个Account类
+	public static void main(String[] args) {
+		double leftMoney = 1023.79; // 初始化“账户余额”
+		Scanner sc = new Scanner(System.in);
+		System.out.println("请输入取款金额：");
+		try { // try块
+			int drawMoney = sc.nextInt();
+			double result = leftMoney - drawMoney; // 建立变量间的关系
+			if(result >= 0) { // 当余额大于取款金额时
+				System.out.println("您账号上的余额：" + (float)result + "元");
+			} else { // 当取款金额超出余额时
+				System.out.println("您账号上的余额不足！");
+			}
+		}
+		catch (InputMismatchException e) { // catch块
+			System.out.println("发生数字格式转换异常：输入的“取款金额”不是整数！");
+		} finally {
+			sc.close(); // 关闭控制台输入
+		}
+	}
+}
+
+```
 
 #### 练习4
 新买了一台电脑，这台电脑与其他的电脑不一样，无法正常启动开机（电脑品牌未声明）。使用继承来体现这个事件，并尝试利用"电脑品牌"引出空指针异常。
+```java
+
+class Computer { // 创建一个Computer类
+	public void powerUp() { // 创建一个普通的方法powerUp()
+		System.out.println("电脑正常开机启动"); // 控制台输出
+	}
+}
+
+class NewComputer extends Computer { // 创建一个NewComputer类继承Computer类
+	private String brand; // 定义“电脑品牌”
+
+	@Override
+	public void powerUp() {// 重写父类Computer中的powerUp()方法
+		System.out.println("刚买回来的新电脑不能正常开机启动\n新电脑的品牌是：" + brand); // 控制台输出
+	}
+}
+
+public class PowerOn {// 创建一个Test类
+	public static void main(String[] args) {
+		System.out.println("模拟场景：用户新买了台电脑，这台电脑与其他的电脑不一样，无法正常启动开机 \n 经检测，是由于电脑的品牌不确定造成的……\n");
+		try { // try块
+			NewComputer newComputer = new NewComputer(); // 创建对象newComputer
+			newComputer.powerUp(); // 对象newComputer调用powerUp()方法
+		} catch (NullPointerException npe) { // catch块
+			System.out.println("引起空指针异常：" + npe.toString().substring(npe.toString().lastIndexOf('.') + 1)); // 控制台输出
+		} finally { // finally块
+			System.out.println("异常出现的原因：\n新机器newComputer对象中的品牌（brand）为null"); // 控制台输出
+		}
+	}
+}
+
+```
 
 
 ## 实例3： 规定西红柿单价不得超过7元
@@ -187,9 +315,109 @@ public class Tomato {// 创建西红柿类
 
 #### 练习5
 模拟老师上课前的点名过程，并将旷课的学生作为异常抛出∶张三、李四、王五（老师在点名册上记下了“王五旷课”）。
+```java
+
+class Person { // 创建一个Person类
+	private String job; // 定义“职称”
+
+	public String getJob() { // 获得“职称”
+		return job;
+	}
+
+	public void setJob(String job) { // 设置“职称”
+		this.job = job;
+	}
+
+	public void say(String words) { // 创建有参的方法say()
+		System.out.println(job + "：" + words); // 输出结果
+	}
+}
+
+public class CallTheRoll { // 创建一个CallTheRoll类
+	public static void main(String[] args) {
+		try { // try块
+			Person person1 = new Person(); // 创建对象person1
+			person1.setJob("老师"); // 设置对象person1的“职称”
+			person1.say("同学们早上好！现在我们开始点名..."); // 设置对象person1说话的内容
+
+			Person person2 = new Person(); // 创建对象person2
+			person2.setJob("班长"); // 设置对象person2的“职称”
+			person2.say("大家保持安静！准备上课..."); // 设置对象person2说话的内容
+
+			person1.say("张三！"); // 设置对象person1说话的内容
+
+			Person person3 = new Person(); // 创建对象person3
+			person3.setJob("同学张三"); // 设置对象person3的“职称”
+			person3.say("到！"); // 设置对象person3说话的内容
+
+			person1.say("李四！"); // 设置对象person1说话的内容
+
+			Person person4 = new Person(); // 创建对象person4
+			person4.setJob("同学李四"); // 设置对象person4的“职称”
+			person4.say("Here！"); // 设置对象person4说话的内容
+
+			person1.say("下次说中文。下一个！\n　　　王五！"); // 设置对象person1说话的内容
+
+			Person person5 = new Person(); // 创建对象person5
+			person5.setJob("同学王五"); // 设置对象person5的“职称”
+			person5.say("...."); // 设置对象person5说话的内容
+
+			person1.say("王五！"); // 设置对象person1说话的内容
+
+			person5.say("...."); // 设置对象person5说话的内容
+
+			throw new Exception("抛出异常：老师在点名册上记下了“王五旷课”！！！"); // 抛出异常
+		} catch (Exception e) { // catch块
+			System.out.println(e.getMessage()); // 输出异常的信息
+		} finally {
+			System.out.println("老师：今天点名到此结束。现在开始上课！"); // 控制台输出
+		}
+	}
+}
+
+```
 
 #### 练习6
 超市经常会对定价较市场价低的产品实施限购∶ 超市里的鲜鸡蛋每500 克 3.98 元，每人限购1500克。现将超过1500克的作为异常抛出，而对于满足条件的，计算出应付款。
+```java
+
+import java.util.Scanner;
+
+class OverloadException extends Exception {// 自定义一个异常类OverloadException继承Exception类
+	public OverloadException(double weight) {// 构造有参的方法
+		// 出现异常时控制台输出的信息
+		System.out.println("异常提示：这份鲜鸡蛋的重量为" + weight + "斤，超过3斤了，超重了！！！");
+	}
+}
+
+public class BuyEggs {// 创建一个BuyEggs类
+	public static void pay(double weight) throws OverloadException {// 创建一个静态的、有参的pay(double
+		if (weight > 3.0) {// 如果鸡蛋的重量超过三斤
+			throw new OverloadException(weight); // 抛出异常
+		}
+		float money = (float) (weight * 3.98); // 如果鸡蛋的重量没有超过三斤，计算“应付款”
+		System.out.println("应付款：" + money + "元"); // 输出“应付款”
+	}
+
+	public static void main(String[] args) {
+		System.out.print("请输入鲜鸡蛋的重量(斤)：");
+		Scanner sc = new Scanner(System.in); // 控制台输入
+		double weight = sc.nextDouble(); // 声明一个double类型的变量weight接收控制台输入的值
+		try {// try块
+			pay(weight); // 调用pay()方法，并传递参数weight
+		} catch (OverloadException ole) {// catch块
+			/*
+			 * 注意： 这个方法体之所以为“空”是因为在自定义异常的类OverloadException中， 我们通过构造的有参方法public
+			 * OverloadException(double weight)，已将出现异常时的信息在控制台上输出了；
+			 * 所以，此处就不必再写“System.out.println(ole);”这条控制台输出语句。
+			 */
+		} finally {// finally块
+			sc.close(); // 关闭控制台输入
+		}
+	}
+}
+
+```
 
 
 ##### 知识补充：
diff --git a/Java/练习题：控制流程.md b/Java/练习题：控制流程.md
index 7e9209c..6c6db0b 100644
--- a/Java/练习题：控制流程.md
+++ b/Java/练习题：控制流程.md
@@ -23,7 +23,54 @@ public class Restaurant {
 ```
 
 #### 练习1：将一、二年级学生的学生成绩划分等级，等级划分标准如下∶①"优秀"，大于等于 90分;②"良好"，大于等于 80 分，小于 90分;③"合格"，大于等于 60分，小于80分;④"不合格"，小于 60 分。使用 if…else if语句实现根据控制台输入的成绩，输出与该成绩对应等级的功能。
+```java
+import java.util.Scanner;
+
+public class ScoreLevel {
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.print("请输入您的分数：");
+		double score = sc.nextDouble();
+		if (score >= 90) {
+			System.out.println("您的分数" + score + "对应的等级为“优秀”");
+		} else if (score >= 80) {
+			System.out.println("您的分数" + score + "对应的等级为“良好”");
+		} else if (score >= 60) {
+			System.out.println("您的分数" + score + "对应的等级为“合格”");
+		} else if (score < 60) {
+			System.out.println("您的分数" + score + "对应的等级为“不合格”");
+		}
+		sc.close();
+	}
+}
+
+```
 #### 练习2：BMI 身体质量指数的等级划分标准如下∶①"偏轻"，BMI 小于18.5;②"正常"，BMI大于等于 18.5，小于25;③"偏重"，BMI 大于等于25，小于30;④"肥胖"，BMI大于等于30。根据控制台输入的身高（ 单位∶ 来）、体重（单位∶ 千克），输出 BMI指数以及与该指数对应的等级。
+```java
+import java.util.Scanner;
+
+public class BMIexponent {
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.print("请输入您的身高（单位：米）：");
+		double height = sc.nextDouble();
+		System.out.print("请输入您的体重（单位：公斤）：");
+		double weight = sc.nextDouble();
+		double exponent = weight/(height * height);
+		if (exponent < 18.5) {
+			System.out.println("您的身体质量指数（BMI）为" + exponent + "，偏轻。");
+		} else if (exponent < 25) {
+			System.out.println("您的身体质量指数（BMI）为" + exponent + "，正常。");
+		} else if (exponent < 30) {
+			System.out.println("您的身体质量指数（BMI）为" + exponent + "，偏重。");
+		} else if (exponent >= 30) {
+			System.out.println("您的身体质量指数（BMI）为" + exponent + "，肥胖。");
+		}
+		sc.close();
+	}
+}
+
+```
 
 ## 实例2： 用 switch 多分支语句判断成绩等级
 创建 Grade类，使用 Scanner 类在控制台输入成绩，然后用 switch 多分支语句判断输入的分数属于哪个等级。10分和9分属于优，8分属于良，7分和6分属于中，5分、4分、3分、2分、1分以及 0 分均为差，实例代码如下∶ 
@@ -66,7 +113,77 @@ public class Grade {
 ```
 
 #### 练习3：使用 switch多分支语句判断控制台输入的某个月份属于哪个季节。
+```java
+
+import java.util.Scanner;
+
+public class Seasons {
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.print("请输入某个月份（1~12）：");
+		int month = sc.nextInt();
+		if (month < 1 || month > 12) {
+			System.out.println("警告：您在非法操作……");
+		} else {
+			switch (month) {
+			case 3:
+			case 4:
+			case 5:
+				System.out.println(month + "月正值春季");
+				break;
+			case 6:
+			case 7:
+			case 8:
+				System.out.println(month + "月正值夏季");
+				break;
+			case 9:
+			case 10:
+			case 11:
+				System.out.println(month + "月正值秋季");
+				break;
+			case 12:
+			case 1:
+			case 2:
+				System.out.println(month + "月正值冬季");
+				break;
+			}
+		}
+		sc.close();
+	}
+}
+
+```
 #### 练习4：使用 switch多分支语句判断控制台输入的某个月份属于哪个季节。（光盘\Code\Try\O3\05）（2）某大型商超为答谢新老顾客，当累计消费金额达到一定数额时，顾客可享受不同的折扣∶①尚未超过 200 元，顾客须按照小票价格支付全款;不少于 200元但尚未超过 600元，顾客全部的消费金额可享 8.5 折优惠;③不少于 600 元但尚未超过 1000 元，顾客全部的消费金额可享 7折优惠;④不少于 1000 元，顾客全部的消费金额可享 6折优惠;
根据顾客购物小票上的消费金额，在控制台上输出该顾客将享受的折扣与打折后需支付的金额。
+```java
+
+import java.util.Scanner;
+
+public class Discount {
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.print("请输入您的消费金额：");
+		int money = sc.nextInt();
+		switch (money / 200) {
+		case 0:
+			System.out.println("您已消费：" + money + "元，尚未超过200元，须按照小票价格支付全款，即" + money + "元RMB");
+			break;
+		case 1:
+		case 2:
+			System.out.println("您已消费：" + money + "元，不少于200元但尚未超过600元，全部的消费金额可享8.5折优惠，即" + (money * 0.85) + "元RMB");
+			break;
+		case 3:
+		case 4:
+			System.out.println("您已消费：" + money + "元，不少于600元但尚未超过1000元，全部的消费金额可享7折优惠，即" + (money * 0.7) + "元RMB");
+			break;
+		default:
+			System.out.println("您已消费：" + money + "元，不少于1000元，全部的消费金额可享6折优惠，即" + (money * 0.6) + "元RMB");
+			break;
+		}
+		sc.close();
+	}
+}
+
+```
 
 
 ## 实例3：使用 for 循环完成 1～ 100的相加运算
@@ -86,7 +203,54 @@ public class AdditiveFor {
 $思考：可不可以改写用while实现相加运算呢？$
 
 #### 练习5：有一组数∶ 1、1、2、3、5、8、13、21、34…，请用for循环算出这组数的第n个数是多少?
+```java
+
+import java.util.Scanner;
+
+public class Arithmetic {
+	public static void main(String[] args) {
+		int num1 = 1, num2 = 1, temp;//定义3个变量，num1用来记录
+		Scanner sc = new Scanner(System.in);// 创建扫描器对象，用于输入
+		System.out.print("请输入要查看第n个数中的n值：");
+		int num = sc.nextInt();// 记录用户输入的数字
+		for (int i = 2; i < num; i++) {
+			num1 += num2;//后一个数字是前两个数字之和
+			//交换num1和num2的值
+			temp = num1; 
+			num1 = num2;
+			num2 = temp;
+		}
+		System.out.println("第" + num + "个数为" + num2);//输出指定位数上的数据
+		sc.close();
+	}
+}
+
+```
 #### 练习6：一个球从80米高度自由落下，每次落地后反弹的高度为原高度的一半，第6次落地时共经过多少米?第6次反弹多高？
+```java
+
+public class Fall {// 创建一个Fall类
+	public static void main(String[] args) {
+		double high = 80;// 声明double类型变量high
+		double sum = 0;// 声明double类型变量sum
+		// i = 0代表小球第一次落地时，i = 10代表第六次落地时
+		for (int i = 0; i < 11; i++) {
+			// 小球开始下落到第六次落地时经过的总路程
+			sum += high;
+			// 判断小球是否完成了一次完整地落地、反弹过程
+			if (i % 2 == 0) {
+				// 每次落地之后反弹高度为原来的一半
+				high = high / 2;
+			}
+		}
+		// 控制台输出小球第六次落地时经过的总路程
+		System.out.println("第六次落地时共经过" + sum + "米");
+		// 控制台输出小球第六次落地后反弹的高度
+		System.out.println("第六次落地后反弹：" + high + "米");
+	}
+}
+
+```
 
 
 ## 实例4：使用嵌套的 for 循环输出乘法口诀表
@@ -108,8 +272,56 @@ public class Multiplication {
 
 
 #### 练习7：5文钱可以买一只公鸡，3 文钱可以买一只母鸡，1文钱可以买三只雏鸡，现在用 100文钱买 100 只鸡，那么公鸡、母鸡、雏鸡各有多少只？
-#### 练习8：根据用户控制输入 * 的行数，在控制台中输出相应行数的等腰三角形。
+```java
 
+public class BuyChicken {// 百钱买百鸡
+	public static void main(String[] args) {
+		int cock, hen, chick;// 公鸡、母鸡、小鸡
+		for (cock = 0; cock <= 20; cock++) {// 最多买20只公鸡
+			for (hen = 0; hen <= 33; hen++) {// 最多买33只母鸡
+				for (chick = 3; chick <= 99; chick += 3) {// 最多买99只小鸡（有“百鸡”的限制）
+					if (5 * cock + 3 * hen + chick / 3 == 100)// 百钱
+					{
+						if (cock + hen + chick == 100)// 百鸡
+						{
+							System.out.println("公鸡：" + cock + "\t母鸡：" + hen + "\t小鸡：" + chick);
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+```
+#### 练习8：根据用户控制输入 * 的行数，在控制台中输出相应行数的等腰三角形。
+```java
+
+import java.util.Scanner;
+
+public class OutputTriangle {
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.print("等腰三角形由多行“*”号组成，请输入“*”的行数：");
+		int line = sc.nextInt();
+		if (line <= 1) {
+			System.out.println("须输入大于1的自然数！");
+		} else {
+			for (int i = 1; i <= line; i++) {// 控制“*”的行数
+				for (int j = 1; j <= line - i; j++) {// 每行添加空格的个数
+					System.out.print(" ");
+				}
+				for (int j = 1; j <= 2 * i - 1; j++) {// 在空格后添加“*”
+					System.out.print("*");
+				}
+				System.out.println();
+			}
+		}
+		sc.close();
+	}
+}
+
+```
 
 ## 实例5：找出1 ～ 19 之间所有的偶数
 使用一个for循环输出1～19之间所有的值，如果输出的值是奇数，则使用 continue 语句跳过本次循环，实例代码如下∶
@@ -126,4 +338,3 @@ public class ContinueTest {
 }
 ```
 
-#### 练习：找出1-1000数字种的素数和水花仙数。
diff --git a/Java/练习题：数据类型转换.md b/Java/练习题：数据类型转换.md
index d15d2a9..72348e0 100644
--- a/Java/练习题：数据类型转换.md
+++ b/Java/练习题：数据类型转换.md
@@ -34,6 +34,65 @@ public class ExplicitConversion {
 }
 ```
 #### 练习1：使用 char型声明'a'～'g'，然后输出它们相加后的结果。
+```java
+public class PlusChar {
+	public static void main(String[] args) {
+		char a = 'a';
+		char b = 'b';
+		char c = 'c';
+		char d = 'd';
+		char e = 'e';
+		char f = 'f';
+		char g = 'g';
+		System.out.println("’a’~’g’相加后的结果：" + (a + b + c + d + e + f + g));
+	}
+}
+
+```
 #### 练习2：IP地址每段数字的最大值可以由byte型的最大值与 short型128相加后得到，使用隐式转换控制台输出 IP 地址每段数字的最大值。
+
+```java
+public class MaxIP {
+	public static void main(String[] args) {
+		byte maxvalue = 127;
+		short s = 128;
+		System.out.println("IP中的每段数字的最大值 = " + (maxvalue + s));
+	}
+}
+```
+
 #### 练习3：将 65～71显式转换为 char 型并输出。
-#### 练习4：一辆货车运输箱子，载货区宽2米，长 4米，一个箱子宽 1.5 米，长 1.5米，请问载货区一层可以放多少个箱子?
\ No newline at end of file
+```java
+public class IntToChar {
+	public static void main(String[] args) {
+		int i_a = 65;
+		int i_b = 66;
+		int i_c = 67;
+		int i_d = 68;
+		int i_e = 69;
+		int i_f = 70;
+		int i_g = 71;
+		System.out.println("65转换为char型的结果为" + (char)i_a);
+		System.out.println("66转换为char型的结果为" + (char)i_b);
+		System.out.println("67转换为char型的结果为" + (char)i_c);
+		System.out.println("68转换为char型的结果为" + (char)i_d);
+		System.out.println("69转换为char型的结果为" + (char)i_e);
+		System.out.println("70转换为char型的结果为" + (char)i_f);
+		System.out.println("71转换为char型的结果为" + (char)i_g);
+	}
+}
+```
+#### 练习4：一辆货车运输箱子，载货区宽2米，长 4米，一个箱子宽 1.5 米，长 1.5米，请问载货区一层可以放多少个箱子?
+```java
+public class GoodsVan {
+	public static void main(String[] args) {
+		int vanWidth = 2;
+		int vanLength = 4;
+		double boxWidth = 1.5;
+		double boxLength = 1.5;
+		int boxNumber = (int)(vanWidth/boxWidth) * (int)(vanLength/boxLength);
+		System.out.println("载货区一层可以放" + boxNumber + "箱子！");
+	}
+}
+
+```
\ No newline at end of file
diff --git a/Java/练习题：数组.md b/Java/练习题：数组.md
index ce35fdd..a66efef 100644
--- a/Java/练习题：数组.md
+++ b/Java/练习题：数组.md
@@ -1,4 +1,132 @@
 #### 练习1：遍历二维数组int a[][] = {{23.65，43，68}，{45，99，86，80}，{76，81，34，45}，{88，64，48，25}}后，再通过循环计算该二维数组的两条对角线之和。
+```java
+public class GetSum {// 创建GetSum类
+	public static void main(String args[]) {
+		// 初始化int类型的二维数组
+		int a[][] = {{ 23, 65, 43, 68 }, 
+					 { 45, 99, 86, 80 }, 
+					 { 76, 81, 34, 45 }, 
+					 { 88, 64, 48, 25 }};
+		System.out.println("原始数组如下：");// 控制台输出提示信息
+		for (int i = 0; i < a.length; i++) {// 遍历二维数组
+			for (int j = 0; j < a[i].length; j++) {
+				System.out.print(a[i][j] + " ");
+			}
+			System.out.println();
+		}
+		int sum1 = 0;// 声明int类型的变量sum1(求一条对角线的和)
+		int sum2 = 0;// 声明int类型的变量sum2(求另一条对角线的和)
+		// 通过循环,获得元素的下标，并分别求出两条对角线的和
+		for (int i = 0, j = a[i].length - 1; i < a.length; i++, j--) {
+			sum1 += a[i][i];
+			sum2 += a[i][j];
+		}
+		// 把两条对角线的和相加求和并输出
+		System.out.println("对角线总和为：" + (sum1 + sum2));
+	}
+}
+
+```
 #### 练习2：一个3×3的网格，将从1到9的数字放入方格，达到能够使得每行每列以及每个对角线的值相加都相同。
+```java
+
+public class NineGrids {// 创建NineGrids类
+	public static void main(String[] args) {
+		// 声明int类型的数组并分配内存（三阶方阵）
+		int arr[][] = new int[3][3];
+		// 确定数字“1”的位置
+		int a = 2;// 第3行的下标
+		int b = 3 / 2;// 第2列的下标
+		for (int i = 1; i <= 9; i++) {// 给数组赋值
+			arr[a++][b++] = i;// 避免数组下标越界
+			if (i % 3 == 0) {// 如果i是3的倍数
+				a = a - 2;
+				b = b - 1;
+			} else {// 如果i不是3的倍数
+				a = a % 3;
+				b = b % 3;
+			}
+		}
+		System.out.println("九宫格：");
+		// 遍历数组
+		for (int i = 0; i < 3; i++) {
+			for (int j = 0; j < arr.length; j++) {
+				System.out.print(arr[i][j] + " ");// 输出数组中的数据
+			}
+			System.out.println();// 换行
+		}
+	}
+}
+
+```
 #### 练习3：交换二维数组 int array[][] = {{8，75，23}，{21，534}，{15，23，20 }};的行、列数据。
-#### 练习4：使用二维数组实现杨辉三角算法。
\ No newline at end of file
+```java
+
+public class SwapRC {// 交换二维数组的行列数据
+	public static void main(String[] args) {
+		int i, j;// 定义两个变量，分别用来作为行和列的循环变量
+		// 初始化一个静态的int型二维数组
+		int[][] array = { { 8, 75, 23 }, { 21, 55, 34 }, { 15, 23, 20 } };
+		System.out.println("—————原始数组—————");// 提示信息
+		// 遍历原始的二维数组
+		for (i = 0; i < 3; i++) {
+			for (j = 0; j < 3; j++) {
+				System.out.print(array[i][j] + "\t");// 输出原始数组中的元素
+			}
+			System.out.println();// 换行
+		}
+		int temp;// 临时变量
+		// 通过循环调换元素的位置
+		for (i = 0; i < 3; i++) {
+			for (j = 0; j < i; j++) {
+				temp = array[i][j];// 把数组元素赋给临时变量
+				// 交换行列数据
+				array[i][j] = array[j][i];
+				array[j][i] = temp;
+			}
+		}
+		System.out.println("——调换位置之后的数组——");// 提示信息
+		// 遍历调换位置之后的二维数组
+		for (i = 0; i < 3; i++) {
+			for (j = 0; j < 3; j++) {
+				System.out.print(array[i][j] + "\t");// 输出调换位置后的数组元素
+			}
+			System.out.println();// 换行
+		}
+	}
+}
+
+```
+#### 练习4：使用二维数组实现杨辉三角算法。
+```java
+
+public class YangHui {// 杨辉三角算法的实现
+	public static void main(String[] args) {
+		// 定义一个长度为10的二维数组
+		int[][] Array_int = new int[10][];
+		// 向数组中记录杨辉三角形的值
+		for (int i = 0; i < Array_int.length; i++) {// 遍历行数
+			Array_int[i] = new int[i + 1];// 定义二维数组的列数
+			// 遍历二维数组的列数
+			for (int j = 0; j < Array_int[i].length; j++) {
+				if (i <= 1) {// 如果是数组的前两行
+					Array_int[i][j] = 1;// 将其设置为1
+					continue;
+				} else {
+					// 如果是行首或行尾
+					if (j == 0 | j == Array_int[i].length - 1)
+						Array_int[i][j] = 1;// 将其设置为1
+					else// 根据杨辉算法进行计算
+						Array_int[i][j] = Array_int[i - 1][j - 1] + Array_int[i - 1][j];
+				}
+			}
+		}
+		for (int i = 0; i < Array_int.length; i++) {// 输出杨辉三角
+			for (int j = 0; j < Array_int[i].length; j++)
+				System.out.print(Array_int[i][j] + "\t");
+			System.out.println();
+		}
+	}
+}
+
+```
\ No newline at end of file
diff --git a/Java/练习题：类与方法.md b/Java/练习题：类与方法.md
index 849dde8..1be613b 100644
--- a/Java/练习题：类与方法.md
+++ b/Java/练习题：类与方法.md
@@ -31,14 +31,139 @@ public class EggCake { // 创建鸡蛋灌饼EggCake类
     定义了两个构造方法，在无参构造方法中可以使用this关键字调用有参的构造方法。但是要注意，this()语句之前不可以有其他代码。
 
 #### 练习1：设计加油站类和汽车类，加油站提供一个给车加油的方法，参数为剩余汽油数量。每次执行加油方法，汽车的剩余汽油数量都会加 2。
+```java
+
+class GasStation {
+	public int addOil(int oilVolume) {
+		oilVolume += 2;
+		return oilVolume;
+	}
+}
+
+public class AutoMobile {
+	public static void main(String[] args) {
+		int leftOilVolume = 10;
+		GasStation gs = new GasStation();
+		for (int i = 1; i <= 5; i++) {
+			leftOilVolume = gs.addOil(leftOilVolume);
+		}
+		System.out.println("该车现有油量：" + leftOilVolume + "L。");
+	}
+}
+
+```
 
 
 #### 练习2：智能手机的默认语言为英文。，但制造手机时可以将默认语言设置为中文。编写手机类， 无，参构造方法使用默认语言设计，利用有参构造方法修改手机的默认语言。
+```java
+
+public class Cellphone {
+	
+	public Cellphone() {
+		System.out.println("智能手机的默认语言为英文");
+	}
+	
+	public Cellphone(String defaultLanguage) {
+		System.out.println("将智能手机的默认语言设置为" + defaultLanguage);
+	}
+
+	public static void main(String[] args) {
+		Cellphone cellphone1 = new Cellphone();
+		Cellphone cellphone2 = new Cellphone("中文");
+	}
+}
+
+```
 
 #### 练习3：张三去KFC买可乐，商家默认不加冰块。但是张三可以要求加 3 个冰块。请利用有参构造方法实现上述功能。
+```java
+
+public class IceBlock {
+	
+	public IceBlock() {
+		System.out.println("商家默认可乐里没有冰块……");
+	}
+	
+	public IceBlock(String name, int number) {
+		System.out.println(name + "要求向可乐里放入" + number + "个冰块。");
+	}
+	
+	public static void main(String[] args) {
+		IceBlock block = new IceBlock();
+		IceBlock iceBlock = new IceBlock("张三", 3);
+	}
+}
+
+```
 
 #### 练习4：创建教师类，类中有姓名、性别和年龄三个属性，在构造方法中使用 this 关键字分别为这三个成员属性赋值。
+```java
+
+public class Teacher {
+	String name;
+	char sex;
+	int age;
+	
+	public Teacher(String name, char sex, int age) {
+		this.name = name;
+		this.sex = sex;
+		this.age = age;
+		System.out.println("教师姓名：" + name + "\n教师性别：" + sex + "\n教师年龄：" + age);
+	}
+	
+	public static void main(String[] args) {
+		Teacher chinese = new Teacher("张三", '男', 38);
+		Teacher math = new Teacher("李四", '男', 45);
+		Teacher english = new Teacher("王五", '女', 32);
+	}
+}
+
+```
 
 #### 练习5：一只大熊猫，长 1.3 米，重 90千克。在自定义方法中使用this关键字调用类的成员变量并在控制台输出这只大熊猫的信息。
+```java
 
-#### 练习6：创建信用卡类，有两个成员变量分别是卡号和密码，如果用户开户时没有设置初始密码，则使用"123456"作为默认密码。设计两个不同的构造方法，分别用于用户设置密码和用户未设置密码两种构造场景。
\ No newline at end of file
+public class Panda {
+	private double length = 1.3;
+	private double weight = 90.0;
+
+	public String getMessages() {
+		return "熊猫体长" + this.length + "米，体重" + this.weight + "KG。";
+	}
+
+	public static void main(String[] args) {
+		Panda panda = new Panda();
+		System.out.println(panda.getMessages());
+	}
+}
+
+```
+
+#### 练习6：创建信用卡类，有两个成员变量分别是卡号和密码，如果用户开户时没有设置初始密码，则使用"123456"作为默认密码。设计两个不同的构造方法，分别用于用户设置密码和用户未设置密码两种构造场景。
+```java
+
+public class Credit {
+	String cardNum;
+	String password;
+	
+	public Credit(String cardNum, String password) {
+		this.cardNum = cardNum;
+		this.password = password;
+		if (password.equals("123456")) {
+			System.out.println("信用卡" + cardNum + "的默认密码为" + password);
+		} else {
+			System.out.println("重置信用卡" + cardNum + "的密码为" + password);
+		}
+	}
+	
+	public Credit(String cardNum) {
+		this(cardNum, "123456");
+	}
+	
+	public static void main(String[] args) {
+		Credit initialCredit = new Credit("4013735633800642");
+		Credit resetedCredit = new Credit("4013735633800642", "168779");
+	}
+}
+
+```
\ No newline at end of file
diff --git a/Java/练习题：继承与多态.md b/Java/练习题：继承与多态.md
index 4d570f6..4133c9a 100644
--- a/Java/练习题：继承与多态.md
+++ b/Java/练习题：继承与多态.md
@@ -26,6 +26,57 @@ public class Pad extends Computer { // 子类：平板电脑
 ```
 
 #### 练习1：创建银行卡类，并设计银行卡的两个子类∶ 储蓄卡与信用卡。
+```java
+public class BankCard {
+	String cardNum;
+	
+	public void saveMoney() {
+		System.out.println("卡号为" + cardNum + "银行卡可以存钱。");
+	}
+}
+
+
+public class CreditCard extends BankCard{
+	public void drawMoney() {
+		System.out.println("卡号为" + cardNum + "银行卡可以取钱。");
+	}
+	
+	public void borrowMoney() {
+		System.out.println("卡号为" + cardNum + "银行卡可以借钱。");
+	}
+}
+
+
+
+public class SavingCard extends BankCard{
+	public void drawMoney() {
+		System.out.println("卡号为" + cardNum + "银行卡可以取钱。");
+	}
+}
+
+
+
+public class Test {
+	public static void main(String[] args) {
+		System.out.println("--------------银行卡的特点--------------");
+		BankCard bankCard = new BankCard();
+		bankCard.cardNum = "6224 4569 2421 3677";
+		bankCard.saveMoney();
+		System.out.println("--------------储蓄卡的特点--------------");
+		SavingCard savingCard = new SavingCard();
+		savingCard.cardNum = "6212 2636 0001 2739";
+		savingCard.saveMoney();
+		savingCard.drawMoney();
+		System.out.println("--------------信用卡的特点--------------");
+		CreditCard creditCard = new CreditCard();
+		creditCard.cardNum = "4013 7356 3380 0642";
+		creditCard.saveMoney();
+		creditCard.drawMoney();
+		creditCard.borrowMoney();
+	}
+}
+
+```
 
 
 ## 实例2：让平板电脑调用台式机的功能
@@ -54,8 +105,52 @@ public class Pad3 extends Computer3 { // 子类：平板电脑
 
 #### 练习3：
 设计火车类和高铁类，高铁类继承火车类，不管火车类的行进速度是多少，高铁的行进速度永远是火车的二倍。
+```java
+
+class Train {
+	public double getSpeed() {
+		return 145.8;
+	}
+}
+
+public class HighSpeedRail extends Train {
+	public double getSpeed() {
+		return super.getSpeed() * 2;
+	}
+	
+	public static void main(String[] args) {
+		Train train = new Train();
+		System.out.println("火车的速度为" + train.getSpeed() + "公里/小时");
+		HighSpeedRail highSpeedRail = new HighSpeedRail();
+		System.out.println("高铁的速度为" + highSpeedRail.getSpeed() + "公里/小时");
+	}
+}
+
+```
 #### 练习4：
 设计人类，有二个自我介绍的方法，输出"我是 XXX";设计博士类，继承人类，博士类自我介绍时输出"我是XXX 博士"。
+```java
+
+class Person {
+	public String introduce() {
+		return "我是XXX";
+	}
+}
+
+public class Doctor extends Person {
+	public String introduce() {
+		return super.introduce() + "博士";
+	}
+
+	public static void main(String[] args) {
+		Person person = new Person();
+		System.out.println(person.introduce());
+		Doctor doctor = new Doctor();
+		System.out.println(doctor.introduce());
+	}
+}
+
+```
 
 **扩展知识：**
 在开始学习使用class关键字定义类时，就应用到了继承原理，因为在Java中，所有的类都直接或间接继承了java.lang.Obiect类。Obiect类是比较特殊的类，它是所有类的父类，是Java类层中的最高层类。当创建一个类时，除非已经指定要从其他类继承，否则都是从java.lang.Object类继承而来的，所以Java中的每个类都源于java.lang.Object类，如 String、Integer等类都是继承于 Object类。除此之外，自定义的类也都继承于Object类。由于所有类都是Obiect子类，所以在定义类时，省略了extends Object语句。
@@ -117,8 +212,43 @@ public class OverLoadTest {
 
  #### 练习5：
  使用方法的重载描述所有的超市都支持现金付款，但大型商超还支持刷卡付款。
+```java
 
+public class Market {
+	public static String pay(String payStyle) {
+		return "所有的超市都支持" + payStyle;
+	}
+	
+	public static String pay(String marketStyle, String payStyle) {
+		return marketStyle + "还支持" + payStyle;
+	}
+	
+	public static void main(String[] args) {
+		System.out.println(pay("现金付款"));
+		System.out.println("但" + pay("大型商超", "刷卡付款"));
+	}
+}
+
+```
  #### 练习6：
  使用方法的重载描述所有的汽车都至少有两块脚踏板，但手动挡汽车有三块脚踏板。
+ ```java
+
+public class Car {
+	public static Integer havePedalNum(int pedalNum) {
+		return pedalNum;
+	}
+	
+	public static String havePedalNum(String name, int pedalNum) {
+		return name + "有" + pedalNum;
+	}
+	
+	public static void main(String[] args) {
+		System.out.println("所有的汽车至少有" + havePedalNum(2) + "块脚踏板");
+		System.out.println("但" + havePedalNum("手动挡汽车", 3) + "块脚踏板");
+	}
+}	
+
+ ```
 
  
\ No newline at end of file
diff --git a/Java/练习题：运算符.md b/Java/练习题：运算符.md
new file mode 100644
index 0000000..ac16e79
--- /dev/null
+++ b/Java/练习题：运算符.md
@@ -0,0 +1,91 @@
+自增、自减运算符是单目运算符，可以放在变量之前，也可以放在变量之后。自增、自减运算符的作用是使变量的值加 1或减1。语法如下∶
+```java
+a++;   // 先输出a的原值，后做+1运算
+++a;   // 先做+1运算，再输出a计算之后的值
+a--;   // 先输出a的原值，后做-1运算
+--a;   // 先做-1运算，再输出a计算之后的值
+```
+
+## 实例1：对同一个变量做自增、自减运算
+创建 AutolncrementDecreasing类，对一个整型变量先做自增运算，再做自减运算，实例代码如下：
+```java
+public class AutoIncrementDecreasing {
+	public static void main(String[] args) {
+		int a = 1;							// 创建整型变量a,初始值为1
+		System.out.println("a = " + a);		// 输出此时a的值
+		a++;									// a自增1
+		System.out.println("a++ = " + a);		// 输出此时a的值
+		a++;									// a自增1
+		System.out.println("a++ = " + a);		// 输出此时a的值
+		a++;									// a自增1
+		System.out.println("a++ = " + a);		// 输出此时a的值
+		a--;									// a自减1
+		System.out.println("a-- = " + a);		// 输出此时a的值
+	}
+}
+```
+
+#### 练习1：使用赋值运算符输出银行的年利率 （2.95%）以及存款额 15000元后，计算并输出3年后的本金和利息的总和。
+```java
+public class CorpusAndInterest {
+	public static void main(String[] args) {
+		double interest = 0.0295;
+		int corpus = 15000;
+		double sum = corpus * (1 + interest) * (1 + interest) * (1 + interest);
+		System.out.println("存款额15000元,3年后的本息和 = " + sum + "元RMB");
+	}
+}
+```
+#### 练习2：规定 1美元=6.8995元人民币后，计算10000元人民币可兑换多少美元。
+```java
+public class RMBToDollar {
+	public static void main(String[] args) {
+		double dollarToRMB = 6.8995;
+		int RMB = 10000;
+		double dollar = RMB/dollarToRMB;
+		System.out.println("10000元人民币可兑换" + dollar + "美元");
+	}
+}
+
+```
+
+
+
+## 实例2：逻辑运算符结合关系运算符进行运算
+创建 LogicalAndRelational类，首先利用关系运算符计算出布尔结果，再用逻辑运算符做二次计算，实例代码如下∶
+```java
+
+public class LogicalAndRelational {
+	public static void main(String[] args) {
+		int a = 2;					 // 声明int型变量a
+		int b = 5;					 // 声明int型变量b
+		// 声明boolean型变量，用于保存应用逻辑运算符“&&”后的返回值
+		boolean result = ((a > b) && (a != b));
+		// 声明boolean型变量，用于保存应用逻辑运算符“||”后的返回值
+		boolean result2 = ((a > b) || (a != b));
+		System.out.println(result); 	// 将变量result输出
+		System.out.println(result2);	// 将变量result2输出
+	}
+}
+```
+
+#### 练习3：有两名男性应聘者∶ 一位25岁，一位32 岁。该公司招聘信息中有一个要求，即男性应聘者的年龄在 23～30 岁之间，判断这两名应聘者是否满足这个要求。
+```java
+public class Interview {
+	public static void main(String[] args) {
+		int employeeAge_A = 25;
+		int employeeAge_B = 32;
+		System.out.println("25岁的应聘者是否满足这个要求：" + ((employeeAge_A >= 23) && (employeeAge_A <= 30)));
+		System.out.println("32岁的应聘者是否满足这个要求：" + ((employeeAge_B >= 23) && (employeeAge_B <= 30)));
+	}
+}
+```
+#### 练习4：我们在登录一个网站时，可以使用账户名登录，也可以使用手机号登录，还可以使用电子邮箱地址登录。请判断某用户是否可以登录。（已知服务器中有如下记录，账户名∶ 张三，手机号∶ 1234567890，电子邮箱∶zhangsan@163.com）
+```java
+public class Login {
+	public static void main(String[] args) {
+		System.out.println("某用户是否可以登录此网站：" + 
+				(("张三" == "张三") || ("1234567890" == "1234567890") || ("zhangsan@163.com" == "zhangsan@163.com")));
+	}
+}
+```
\ No newline at end of file