目录
第六章
成员变量基础练习
第一题
案例：
- 声明员工类Employee，包含属性：编号、姓名、年龄、薪资，
- 声明Test01测试类，并在main方法中，创建2个员工对象，并为属性赋值，并打印两个员工的信息。
public class Employee {
int id;
String name;
int age;
double salary;
}
public class Test01 {
public static void main(String[] args) {
Employee emp1 = new Employee();
emp1.id = 1;
emp1.name = "张三";
emp1.age = 23;
emp1.salary = 10000;
Employee emp2 = new Employee();
emp2.id = 2;
emp2.name = "李四";
emp2.age = 22;
emp2.salary = 11000;
System.out.println("员工1的编号：" + emp1.id +"，姓名：" + emp1.name + "，年龄：" + emp1.age + "，薪资：" + emp1.salary);
System.out.println("员工2的编号：" + emp2.id +"，姓名：" + emp2.name + "，年龄：" + emp2.age + "，薪资：" + emp2.salary);
}
}第二题
案例：
- 声明一个日期类MyDate，包含属性：年、月、日
- 声明一个Test02测试类，并在main方法中，创建3个日期对象，一个是你的出生日期，一个是来尚硅谷的日期，一个是毕业的日期，并打印显示
public class MyDate {
int year;
int month;
int day;
}
public class Test02 {
public static void main(String[] args) {
MyDate bir = new MyDate();
bir.year = 1995;
bir.month = 5;
bir.day = 5;
System.out.println("生日：" + bir.year + "年" + bir.month + "月" + bir.day + "日");
MyDate come = new MyDate();
come.year = 2019;
come.month = 5;
come.day = 12;
System.out.println("来尚硅谷：" + come.year + "年" + come.month + "月" + come.day + "日");
MyDate go = new MyDate();
go.year = 2019;
go.month = 10;
go.day = 25;
System.out.println("毕业：" + go.year + "年" + go.month + "月" + go.day + "日");
}
}第三题
案例：
- 声明公民类Citizen，包含属性：姓名，生日，身份证号，其中姓名是String类型，生日是MyDate类型，身份证号也是String类型。
- 声明Test03测试类，在main方法中创建你们家庭成员的几个对象，并打印信息。
public class Test03 {
public static void main(String[] args){
//1、创建爸爸的对象
Citizen baba = new Citizen();
baba.name = "小头爸爸";
baba.cardId = "1111111";
//左边的birthday是一个引用数据类型的变量，右边就需要赋值一个对象
baba.birthday = new MyDate();
//baba.birthday是对象名
baba.birthday.year = 1967;
baba.birthday.month = 5;
baba.birthday.day = 2;
//2、创建妈妈的对象
Citizen mama = new Citizen();
mama.name = "围裙妈妈";
mama.cardId = "222222";
MyDate bir = new MyDate();
bir.year = 1970;
bir.month = 6;
bir.day = 1;
mama.birthday = bir;
//3、创建自己的对象
Citizen self = new Citizen();
self.name = "大头儿子";
self.cardId = "3333333";
MyDate date = new MyDate();
date.year = 1995;
date.month = 6;
date.day = 12;
self.birthday = date;
System.out.println("爸爸的姓名：" + baba.name + "，身份证号：" + baba.cardId + "，生日：" + baba.birthday.year+"年" + baba.birthday.month + "月" + baba.birthday.day+"日");
System.out.println("妈妈的姓名：" + mama.name + "，身份证号：" + mama.cardId + "，生日：" + mama.birthday.year+"年" + mama.birthday.month + "月" + mama.birthday.day+"日");
System.out.println("我的姓名：" + self.name + "，身份证号：" + self.cardId + "，生日：" + self.birthday.year+"年" + self.birthday.month + "月" + mama.birthday.day+"日");
}
}成员方法基础练习
第四题：
案例：
- 声明一个日期类MyDate，包含属性：年、月、日，并在MyDate类中声明几个方法：
1、boolean isLeapYear()：判断当前日期的是闰年吗？
2、void set(int y, int m, int d)：修改年，月，日为新日期
3、void puls(int years, int months, int days)：加上years年，months月，days天后的日期
- 并在测试类Test04的main方法中创建对象，并调用测试
public class MyDate {
int year;
int month;
int day;
boolean isLeapYear(){
return year%4==0 && year%100!=0 || year%400==0;
}
void set(int y, int m, int d){
year = y;
month = m;
day = d;
}
void puls(int years, int months,int days){
day += days;
month += months;
year += years;
while(month>12){
month-=12;
year++;
}
while(true){
if(month==1 || month==3 || month==5 || month==7 || month==8 || month==10){
if(day>31){
day -= 31;
month++;
}else{
break;
}
}else if(month==4 || month==6 || month==9 || month==11){
if(day>30){
day -= 30;
month++;
}else{
break;
}
}else if(month==2){
if(year%4==0 && year%100!=0 || year%400==0){
if(day>29){
day -= 29;
month++;
}else{
break;
}
}else{
if(day>28){
day-=28;
month++;
}else{
break;
}
}
}else if(month == 12){
if(day>31){
day-=31;
month=1;
year++;
}else{
break;
}
}
}
}
}
public class Test04 {
public static void main(String[] args) {
MyDate my = new MyDate();
my.set(2019, 5, 13);
System.out.println(my.year + "年" + my.month + "月" + my.day + "日");
System.out.println("是闰年吗？" + my.isLeapYear());
my.puls(1, 70, 70);
System.out.println("再加1年70个月70天之后的日期是：");
System.out.println(my.year + "年" + my.month + "月" + my.day + "日");
}
}第五题：
案例：
- 声明一个三角形类Triangle，包含属性：a,b,c，表示三条边，包含几个方法：
1、boolean isRightTriangle()：判断是否是一个直角三角形
2、boolean isIsoscelesTriangle()：判断是否是一个等腰三角形
3、boolean isEquilateralTriangle()：判断是否是一个等边三角形
4、double getArea()：根据三条边，用海伦公式求面积
5、double getLength()：求周长
- 并在测试类Test05的main方法中调用测试
public class Triangle {
double a;
double b;
double c;
// 判断是否是一个直角三角形
boolean isRightTriangle() {
// 判断值合法
if (a > 0 && b > 0 && c > 0) {
// 判断是否是三角形
if (a + b > c && a + c > b && b + c > a) {
if (a * a + b * b == c * c || b * b + c * c == a * a || a * a + c * c == b * b) {
return true;
}
}
}
return false;
}
boolean isIsoscelesTriangle() {
// 判断值合法
if (a > 0 && b > 0 && c > 0) {
// 判断是否是三角形
if (a + b > c && a + c > b && b + c > a) {
// 判断是否是等腰三角形
if (a == b || b == c || a == c) {
return true;
}
}
}
return false;
}
boolean isEquilateralTriangle() {
// 判断值合法
if (a > 0 && b > 0 && c > 0) {
// 判断是否是三角形
if (a + b > c && a + c > b && b + c > a) {
// 判断是否是等边三角形
if (a == b && b == c) {
return true;
}
}
}
return false;
}
double getArea() {
// 判断值合法
if (a > 0 && b > 0 && c > 0) {
// 判断是否是三角形
if (a + b > c && a + c > b && b + c > a) {
double p = (a + b + c) / 2;
return Math.sqrt(p * (p - a) * (p - b) * (p - c));
}
}
return 0;
}
double getLength() {
// 判断值合法
if (a > 0 && b > 0 && c > 0) {
// 判断是否是三角形
if (a + b > c && a + c > b && b + c > a) {
return a + b + c;
}
}
return 0;
}
}
public class Test05 {
public static void main(String[] args) {
Triangle t = new Triangle();
t.a = 3;
t.b = 4;
t.c = 5;
System.out.println("是否是直接三角形：" + t.isRightTriangle());
System.out.println("是否是等腰三角形：" + t.isIsoscelesTriangle());
System.out.println("是否是等边三角形：" + t.isEquilateralTriangle());
System.out.println("三角形的面积：" + t.getArea());
System.out.println("三角形的周长：" + t.getLength());
}
}第六题：
案例：
- 声明一个数学计算工具类MathTools，包含如下方法：
1、int add(int a, int b)：求a+b
2、int subtract(int a,int b)：求a-b
3、int mutiply(int a, int b)：求a*b
4、int divide(int a, int b)：求a/b
5、int remainder(int a, int b)：求a%b
6、int max(int a, int b)：求a和b中的最大值
7、int min(int a, int b)：求a和b中的最小值
8、boolean equals(int a, int b)：判断a和b是否相等
9、boolean isEven(int a)：判断a是否是偶数
10、boolean isPrimeNumer(int a)：判断a是否是素数
11、int round(double d)：返回d的四舍五入后的整数值
- 声明一个Test06测试类，并在main方法中调用测试
public class MathTools {
static int add(int a, int b) {
return a + b;
}
static int subtract(int a, int b) {
return a - b;
}
static int mutiply(int a, int b) {
return a * b;
}
static int divide(int a, int b) {
return a / b;
}
static int remainder(int a, int b) {
return a % b;
}
static int max(int a, int b) {
return a > b ? a : b;
}
static int min(int a, int b) {
return a < b ? a : b;
}
static boolean equals(int a, int b) {
return a == b;
}
static boolean isEven(int a) {
return a % 2 == 0;
}
static boolean isPrimeNumber(int a){
for (int i = 2; i < a; i++) {
if(a%i == 0){
return false;
}
}
return true;
}
static int round(double d){
return (int)(d + 0.5);
}
}
public class Test06 {
public static void main(String[] args) {
int a = 5;
int b = 3;
System.out.println(a + "+" + b + "=" + MathTools.add(a,b));
System.out.println(a + "-" + b + "=" + MathTools.subtract(a,b));
System.out.println(a + "*" + b + "=" + MathTools.mutiply(a,b));
System.out.println(a + "/" + b + "=" + MathTools.divide(a,b));
System.out.println(a + "%" + b + "=" + MathTools.remainder(a,b));
System.out.println(a + "," + b + "的最大值：" + MathTools.max(a, b));
System.out.println(a + "," + b + "的最小值：" + MathTools.min(a, b));
System.out.println(a + "==" + b + "？" + MathTools.equals(a,b));
System.out.println(a + "是偶数？" + MathTools.isEven(a));
System.out.println(a + "是素数？" + MathTools.isPrimeNumber(a));
System.out.println("5.4四舍五入的结果：" + MathTools.round(5.4));
System.out.println("5.6四舍五入的结果：" + MathTools.round(5.6));
}
}第七题：
案例：
- 声明一个数组管理工具类MyArrays，包含如下方法：
1、void sort(int[] arr)：可以为任意一维整型数组arr实现从小到大排序
2、int indexOf(int[] arr, int value)：可以在任意一维整型数组arr中查找value值的下标，如果不存在返回-1
3、int[] copy(int[] arr, int len)：可以实现从任意一维数组arr中复制一个新数组返回，新数组的长度为len，从arr[0]开始复制
4、void print(int[] arr)：可以打印数组的元素，效果：[1,2,3,4,5]
- 声明一个Test07测试类，并在main方法中调用测试
public class MyArrays {
static void sort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
static int indexOf(int[] arr, int value) {
for (int i = 0; i < arr.length; i++) {
if (value == arr[i]) {
return i;
}
}
return -1;
}
static int[] copy(int[] arr, int len) {
// (1)创建新数组
int[] newArr = new int[len];
// (2)复制元素
// [i]既不能超过旧数组下标范围，也不能超过新数组下标范围
for (int i = 0; i < newArr.length && i < arr.length; i++) {
newArr[i] = arr[i];
}
// (3)返回新数组
return newArr;
}
static void print(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==0){
System.out.print(arr[i]);
}else{
System.out.print("," + arr[i]);
}
}
System.out.println("]");
}
}
public class Test07 {
public static void main(String[] args) {
int[] all = {4,5,2,6,1};
System.out.println("排序前：");
MyArrays.print(all);
MyArrays.sort(all);
System.out.println("排序后：");
MyArrays.print(all);
int index = MyArrays.indexOf(all, 4);
System.out.println("4在数组的下标是：" + index);
System.out.println("新数组：");
int[] copyArr = MyArrays.copy(all, 10);
MyArrays.print(copyArr);
}
}第八题：
案例：
- 声明一个常识工具类CommonsTools，包含如下方法：
1、String getWeekName(int week)：根据星期值，返回对应的英语单词
2、String getMonthName(int month)：根据月份值，返回对应的英语单词
3、int getTotalDaysOfMonth(int year, int month)：返回某年某月的总天数
4、int getTotalDaysOfYear(int year)：获取某年的总天数
5、boolean isLeapYear(int year)：判断某年是否是闰年
- 声明一个Test08测试类，并在main方法中调用测试
public class CommonsTools {
static String getWeekName(int week){
switch(week){
case 1:
return "Monday";
case 2:
return "Tuesday";
case 3:
return "Wednesday";
case 4:
return "Thursday";
case 5:
return "Friday";
case 6:
return "Saturday";
case 7:
return "Sunday";
}
return "";
}
static String getMonthName(int month){
String[] all = {"January","February","March","April","May","June","July","August","September","October","November","December"};
if(month >= 1 && month <= 12){
return all[month-1];
}
return "";
}
static int getTotalDaysOfMonth(int year, int month){
int[] days = {31,28,31,30,31,30,31,31,30,31,30,31};
if(isLeapYear(year)){
days[1]++;//闰年2月29天
}
if(month >= 1 && month <= 12){
return days[month-1];
}
return 0;
}
static int getTotalDaysOfYear(int year){
if(isLeapYear(year)){
return 366;
}
return 365;
}
static boolean isLeapYear(int year){
return year%4==0 && year%100!=0 || year%400==0;
}
}public class Test08 {
public static void main(String[] args) {
System.out.println("3月：" + CommonsTools.getMonthName(3));
System.out.println("周三：" + CommonsTools.getWeekName(3));
System.out.println("2019-2的总天数：" + CommonsTools.getTotalDaysOfMonth(2019, 2));
System.out.println("2019年是否是闰年？" + CommonsTools.isLeapYear(2019) );
System.out.println("2019年的总天数：" + CommonsTools.getTotalDaysOfYear(2019));
}
}第七章
基础练习
第一题
知识点：可变参数
案例：
- 在Count类中，声明如下方法：
1、public long sum(int... nums)：求0~n个整数的累加和，如果没有传参，就返回0
2、public int max(int a, int... others)：求1~n个整数中的最大值
3、public String concat(String... strings)：求0~n个字符串的拼接结果
4、public boolean isEven(int... nums)：判断0~n个整数是否都是偶数，如果都是偶数，返回true，否则返回false
- 声明一个Test01测试类，并在main方法中调用测试
public class Count{
public long sum(int... nums){
long sum = 0;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
return sum;
}
public int max(int a, int... others){
int max = a;
for (int i = 0; i < others.length; i++) {
if(others[i] > max){
max = others[i];
}
}
return max;
}
public String concat(String... strings){
String result = "";
for (int i = 0; i < strings.length; i++) {
result += strings[i];
}
return result;
}
public boolean isEven(int... nums){
for (int i = 0; i < nums.length; i++) {
if(nums[i]%2 !=0){
return false;
}
}
return true;
}
}
public class Test01 {
public static void main(String[] args) {
Count c = new Count();
System.out.println("1,2,3,4,5的总和：" + c.sum(1,2,3,4,5));
System.out.println("3,4,2,1的最大值是：" + c.max(3,4,2,1));
System.out.println("尚，硅，谷，好拼接的结果：" + c.concat("尚","硅","谷","好"));
System.out.println("2,4,6,8是否都是偶数：" + c.isEven(2,4,6,8));
}
}
第二题
知识点：方法的声明与调用、方法的重载
案例：
- 声明一个图形工具类GraphicTools，包含如下方法：
1、void printRectangle()：该方法打印5行5列*矩形
2、void printRectangle(int line, int column, String sign)：该方法打印line行colomn列由sign组成的矩形
3、double getTriangleArea(double base, double height)：根据底边和底边对应的高求三角形面积
4、double getTriangleArea(double a, double b, double c)：根据三角形的三条边求三角形面积，如果a,b,c不能组成三角形，打印不能组成三角形，并返回0.0
- 声明Test02测试类，并在main方法中调用测试
public class GraphicTools {
void printRectangle() {
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
System.out.print("*");
}
System.out.println();
}
}
void printRectangle(int line, int column, String sign) {
for (int i = 1; i <= line; i++) {
for (int j = 1; j <= column; j++) {
System.out.print(sign);
}
System.out.println();
}
}
double getTriangleArea(double base, double height) {
return base * height / 2;
}
double getTriangleArea(double a, double b, double c) {
if(a>0 && b>0 && c>0 && a+b>c && a+c>b && b+c >a){
double p = (a + b + c) / 2;
return Math.sqrt(p * (p - a) * (p - b) * (p - c));
}else{
System.out.println(a +"," + b +"," + c + "不能构成三角形");
return 0;
}
}
}
public class Test02 {
public static void main(String[] args) {
GraphicTools tools = new GraphicTools();
tools.printRectangle();
System.out.println("--------------------------");
tools.printRectangle(5, 10, "#");
System.out.println("--------------------------");
System.out.println("底边为3，高为4的三角形面积：" + tools.getTriangleArea(3, 4));
System.out.println("边为3，4，5的三角形面积：" + tools.getTriangleArea(3, 4, 5));
}
}第三题
知识点：方法的重载
案例：
- 声明一个数组工具类MyArrays，包含如下方法：
1、int binarySearch(int[] arr, int value)：使用二分查找法在arr数组中查找value的下标，如果value不存在，就返回-1，如果数组arr不是有序的，结果将不一定正确
2、int binarySearch(char[] arr, char value)：使用二分查找法在arr数组中查找value的下标，如果value不存在，就返回-1，如果数组arr不是有序的，结果将不一定正确
3、int binarySearch(double[] arr, double value)：使用二分查找法在arr数组中查找value的下标，如果value不存在，就返回-1，如果数组arr不是有序的，结果将不一定正确
4、int[] copy(int[] arr , int length)：从指定的arr数组的arr[0]开始复制得到一个新数组，新数组的长度为length。
5、double[] copy(double[] arr , int length)：从指定的arr数组的arr[0]开始复制得到一个新数组，新数组的长度为length。
6、char[] copy(char[] arr , int length)：从指定的arr数组的arr[0]开始复制得到一个新数组，新数组的长度为length。
7、void sort(int[] arr)：可以给arr数组从小到大排序，用冒泡排序实现
8、void sort(char[] arr)：可以给arr数组从小到大排序，用冒泡排序实现
9、void sort(double[] arr)：可以给arr数组从小到大排序，用冒泡排序实现
- 声明Test03测试类，并在main方法中调用测试
public class MyArrays {
public int binarySearch(int[] arr, int value) {
int left = 0;
int right = arr.length - 1;
int mid = (left + right) / 2;
while (left <= right) {
if (arr[mid] == value) {
return mid;
} else if (value > arr[mid]) {
left = mid + 1;
} else if (value < arr[mid]) {
right = mid - 1;
}
mid = (left + right) / 2;
}
return -1;
}
public int binarySearch(char[] arr, int value) {
int left = 0;
int right = arr.length - 1;
int mid = (left + right) / 2;
while (left <= right) {
if (arr[mid] == value) {
return mid;
} else if (value > arr[mid]) {
left = mid + 1;
} else if (value < arr[mid]) {
right = mid - 1;
}
mid = (left + right) / 2;
}
return -1;
}
public int binarySearch(double[] arr, int value) {
int left = 0;
int right = arr.length - 1;
int mid = (left + right) / 2;
while (left <= right) {
if (arr[mid] == value) {
return mid;
} else if (value > arr[mid]) {
left = mid + 1;
} else if (value < arr[mid]) {
right = mid - 1;
}
mid = (left + right) / 2;
}
return -1;
}
public int[] copy(int[] arr, int length) {
// (1)创建新数组
int[] newArr = new int[length];
// (2)复制元素
for (int i = 0; i < arr.length && i < newArr.length; i++) {
newArr[i] = arr[i];
}
return newArr;
}
public double[] copy(double[] arr, int length) {
// (1)创建新数组
double[] newArr = new double[length];
// (2)复制元素
for (int i = 0; i < arr.length && i < newArr.length; i++) {
newArr[i] = arr[i];
}
return newArr;
}
public char[] copy(char[] arr, int length) {
// (1)创建新数组
char[] newArr = new char[length];
// (2)复制元素
for (int i = 0; i < arr.length && i < newArr.length; i++) {
newArr[i] = arr[i];
}
return newArr;
}
public void sort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public void sort(double[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
double temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public void sort(char[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
char temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public void print(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==0){
System.out.print(arr[i]);
}else{
System.out.print("," + arr[i]);
}
}
System.out.println("]");
}
public void print(double[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==0){
System.out.print(arr[i]);
}else{
System.out.print("," + arr[i]);
}
}
System.out.println("]");
}
public void print(char[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==0){
System.out.print(arr[i]);
}else{
System.out.print("," + arr[i]);
}
}
System.out.println("]");
}
}
public class Test03 {
public static void main(String[] args) {
int[] arr = {3,4,2,7,1};
MyArrays my = new MyArrays();
my.print(arr);
System.out.println("1在数组中的下标：" + my.binarySearch(arr, 1));//结果错误，因为数组无序
my.sort(arr);
my.print(arr);
System.out.println("1在数组中的下标：" + my.binarySearch(arr, 1));
my.print(my.copy(arr, 10));
}
}第四题
知识点：方法的参数传递机制
案例：
- 声明圆Circle类，包含radius属性（本题属性不私有化）
- 在PassParamDemo类中，声明如下方法，并体会方法的参数传递机制：
1、public void doubleNumber(int num)：尝试将num变为原来的2倍大，看是否可以将给num赋值的实参变量值也扩大2倍，如果不能，请画图说明为什么？
2、public void toUpperCase(char letter)：尝试将letter的小写字母转为大写字母，看是否可以将给letter赋值的实参变量值也转为大写，如果不能，请画图说明为什么？
3、public void expandCircle(Circle c，double times)：尝试将Circle的c对象的半径扩大为原来的times倍，看是否可以将给c赋值的实参对象的半径也扩大times倍，如果可以，请画图说明为什么？
4、public void sort(int[] arr)：尝试对arr数组实现从小到大排序，看是否可以将给arr赋值的实参数组也排序，如果可以，请画图说明为什么？
- 在Test04测试类的main()方法中调用测试
public class Circle {
double radius;
}
public class PassParamDemo {
public void doubleNumber(int x) {
x *= 2;
}
public void toUpperCase(char letter) {
letter = (char) (letter - 32);
}
public void expandCircle(Circle c, double times) {
c.radius *= times;
}
public void sort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
public class Test04 {
public static void main(String[] args){
PassParamDemo p = new PassParamDemo();
int x = 1;
p.doubleNumber(x);
System.out.println("x = " + x);
char letter = 'a';
p.toUpperCase(letter);
System.out.println(letter);
Circle c = new Circle();
c.radius = 1.0;
p.expandCircle(c, 5);
System.out.println("半径：" + c.radius);
int[] arr = {3,4,2,7,1};
p.sort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}第五题
知识点：对象数组
案例：
1、声明一个Employee员工类，
包含属性：编号(id)、姓名(name)、薪资(salary)、年龄(age)，此时属性不私有化
包含方法：
（1）void printInfo()：可以打印员工的详细信息
（2）void setInfo(int i, String n, double s, int a)：可以同时给id,name,salary,age赋值
2、声明一个EmployeeManager类，包含如下方法：
（1）public void print(Emplyee[] all)：遍历打印员工数组中的每个员工的详细信息
（2）public void sort(Employee[] all)：将all员工数组按照年龄从高到低排序
（3）public void addSalary(Employee[] all, double increament)：将all员工数组的每一个员工的工资，增加increament
3、声明Test05测试类
（1）public static void main(String[] args)：在main方法中，创建Employee[]数组，并创建5个员工对象放到数组中，并为员工对象的属性赋值
（2）创建EmployeeManager对象，
（3）调用print方法，显示员工信息
（4）调用sort方法对员工数组进行按照年龄排序，并调用print方法，显示员工信息
（5）调用addSalary方法给每一个员工加薪1000元，并调用print方法，显示员工信息
public class Employee {
int id;
String name;
double salary;
int age;
void printInfo(){
System.out.println("编号：" + id + "，姓名：" + name + "，薪资：" + salary + "，年龄：" +age);
}
void setInfo(int i, String n, double s, int a){
id = i;
name = n;
salary = s;
age = a;
}
}
public class EmployeeManager {
public void print(Employee[] all){
for(int i=0; i<all.length; i++){
all[i].printInfo();
}
}
public void sort(Employee[] all){
for(int i=1; i<all.length; i++){
for(int j=0; j<all.length-i; j++){
//从高到低
if(all[j].age < all[j+1].age){
Employee temp = all[j];
all[j] = all[j+1];
all[j+1] = temp;
}
}
}
}
public void addSalary(Employee[] all, double increament){
for(int i=0; i<all.length; i++){
all[i].salary += increament;
}
}
}
public class Test05 {
public static void main(String[] args){
Employee[] all = new Employee[5];
all[0] = new Employee();
all[0].setInfo(1,"张三",10000,23);
all[1] = new Employee();
all[1].setInfo(2,"李四",12000,23);
all[2] = new Employee();
all[2].setInfo(3,"王五",8000,18);
all[3] = new Employee();
all[3].setInfo(4,"赵六",6000,20);
all[4] = new Employee();
all[4].setInfo(5,"钱七",15000,21);
EmployeeManager em = new EmployeeManager();
em.print(all);
System.out.println("------------------------------------------");
em.sort(all);
em.print(all);
System.out.println("------------------------------------------");
em.addSalary(all, 200);
em.print(all);
}
}
递归练习（难）
第六题
用递归实现不死神兔：故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契。
在他的一部著作中提出了一个有趣的问题：假设一对刚出生的小兔一个月后就能长成大兔，
再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，没有发生死亡，
问：现有一对刚出生的兔子2年后(24个月)会有多少对兔子?
public class Test06 {
public static void main(String[] args) {
Count c = new Count();
int sum = c.sum(24);
System.out.println(sum);
}
}
class Count{
//从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子
/*
* 第1个月，1对 f(1) = 1
* 第2个月，1对 f(2) = 2
* 第3个月，2对 老兔子本身1对，加上生出来的一对第1个月
* f(3) = f(2) + f(1)
* 第4个月，3对 老兔子本身1对，上月出生的兔子第2个月，老兔子又生出一对新的第1个月
* 整理： 老兔子本身1对，老兔子又生出一对新的第1个月==》等价于第3个月的状态
上月出生的兔子第2个月，==>等价于第2个月的兔子状态
* f(4) = f(3)+f(2)
* 第5个月，5对 老兔子本身1对，老兔子又生出1对新的第1个月，第3个月初始的兔子也成新的老兔子1对，
它也生出一对新的第1个月，第4个月出生的兔子第2个月1对
* 整理分析：
*老兔子本身1对，老兔子又生出1对新的第1个月，第4个月出生的兔子第2个月1对 ==》等价于第4个月的状态
*第3个月初始的兔子也成新的老兔子1对，它也生出一对新的第1个月 ==》等价于第2个月的兔子状态
* f(5) = f(4) + f(2)
* .... f(n) = f(n-1) + f(n-2)
*
*/
public int sum(int n){
if(n==1 || n==2){
return 1;
}else{
return sum(n-1) + sum(n-2);
}
}
}第七题
描述：猴子吃桃子问题，猴子第一天摘下若干个桃子，当即吃了快一半，还不过瘾，又多吃了一个。第二天又将仅剩下的桃子吃掉了一半，又多吃了一个。以后每天都吃了前一天剩下的一半多一个。到第十天，只剩下一个桃子。试求第一天共摘了多少桃子？
public class Test07 {
public static void main(String[] args) {
Count c = new Count();
System.out.println(c.sum(1));
System.out.println(c.sum(2));
System.out.println(c.sum(3));
System.out.println(c.sum(4));
System.out.println(c.sum(5));
System.out.println(c.sum(6));
System.out.println(c.sum(7));
System.out.println(c.sum(8));
System.out.println(c.sum(9));
System.out.println(c.sum(10));
}
}
class Count{
public int sum(int n){
if(n==10){//第10天
return 1;
}else{
/*
* 第9天没吃之前是 第10天+1个的2倍
* 第8天没吃之前是 第9天+1个的2倍
* 。。。。
*/
return (sum(n+1)+1)*2;
}
}
}第八题
通项公式如下：f(n)=n + (n-1) + (n-2) + .... + 1，其中n是大于等于5并且小于10000的整数，例如：f(5) = 5 + 4 + 3 + 2 + 1，f(10) = 10 + 9 + 8 + 7+ 6 + 5 + 4 + 3 + 2 + 1，请用递归的方式完成方法long f( int n)的方法体。
public class Test8 {
public static void main(String[] args) {
Count c = new Count();
System.out.println(c.f(5));
System.out.println(c.f(10));
}
}
class Count{
public long f(int n) {
long sum = 0;
if(n==1){
sum += 1;
}else if(n>1){
sum += n + f(n-1);
}
return sum;
}
}第九题
有n步台阶，一次只能上1步或2步，共有多少种走法？
/*
* 1级：1
* 2级：2 1步1步 和 2步
* 3级：上到1级的总走法（因为从1级上到3级直接跨2步） + 上到2级的总走法（从2级上到3级直接跨1步）
* 因为从1级走1步就归到上到2级的走法里面了
* 4级：上到2级的总走法 + 上到3级的总走法
* ...
*
* 即最后一步要么跨1步，要么跨2步
*/
public class Test9 {
public static void main(String[] args) {
Count c = new Count();
System.out.println(c.f(10));
}
}
class Count{
public int f(int n) {
if (n <= 2){
return n;
}
return f(n - 1) + f(n - 2);
}
}代码阅读题
第十题
知识点：方法的参数传递
案例：分析运行结果
package com.atguigu.test10;
public class Test10 {
public static void main(String[] args) {
Other o = new Other();
new Test12().addOne(o);
System.out.println(o.i);
}
public void addOne(Other o){
o.i++;
}
}
class Other{
public int i;
}
package com.atguigu.test10;
/*
* 方法的参数传递机制：
* 形参是基本数据类型，那么实参给形参的是数据值的副本，形参的修改不影响实参；
* 形参是引用数据类型，那么实参给形参的是地址值的副本，形参对象修改属性相当于实参对象修改属性
*/
public class Test10 {
public static void main(String[] args) {
Other o = new Other();
new Test12().addOne(o);
System.out.println(o.i);//1
}
public void addOne(Other o){
o.i++;
}
}
class Other{
public int i;
}第十一题
知识点：方法的参数传递
案例：分析运行结果
package com.atguigu.test11;
public class Test11 {
public static void main(String[] args) {
int i = 0;
change(i);
i = i++;
System.out.println("i = " + i);
}
public static void change(int i){
i++;
}
}
package com.atguigu.test11;
/*
* 1、方法的参数传递机制：
* 形参是基本数据类型，那么实参给形参的是数据值的副本，形参的修改不影响实参；
* 形参是引用数据类型，那么实参给形参的是地址值的副本，形参对象修改属性相当于实参对象修改属性
*
* 2、自增运算符
* ++在后，先加载值后自增；
* ++在前，先自增后加载值
*
* i = i++;
* ①先加载i的值"0"，②i自增,i=1，③最后算赋值，把刚才的“0”赋值给i
*/
public class Test11 {
public static void main(String[] args) {
int i = 0;
change(i);
i = i++;
System.out.println("i = " + i);//i=0
}
public static void change(int i){
i++;
}
}
第八章
代码阅读题
第一题
知识点：实例初始化
案例：判断运行结果
package com.atguigu.test01;
class HelloA{
public HelloA(){
System.out.println("HelloA");
}
{
System.out.println("I'm A Class");
}
}
class HelloB extends HelloA{
public HelloB(){
System.out.println("HelloB");
}
{
System.out.println("I'm B Class");
}
}
public class Test01{
public static void main(String[] args) {
new HelloB();
}
}
package com.atguigu.test01;
/*
* 创建对象是通过执行实例初始化方法来完成的。
* 如果new后面跟无参构造，就说明调用无参的实例初始化方法<init>()，
* 如果new后面跟有参构造，就说明调用有参的实例初始化方法<init>(形参列表)。
* 编译器编译后类中没有构造器，而是编译为一个个的实例初始化方法。
* 实例初始化由：
* （1）非静态成员变量的显式赋值代码
* （2）非静态代码块代码
* （3）构造器代码
* 其中（1）（2）按编写顺序，（3）在最后
* 在子类实例初始化首行会有super()或super(实参列表)表示调用父类的实例初始化方法，
* 如果没写super()或super(实参列表)，那么默认就是super()，因此：
* （1）先执行父类实例初始化
* <init>(){
* System.out.println("I'm A Class");
* System.out.println("HelloA");
* }
* （2）再执行子类实例初始化
* <init>(){
* System.out.println("I'm B Class");
* System.out.println("HelloB");
* }
*/
class HelloA{
public HelloA(){
System.out.println("HelloA");
}
{
System.out.println("I'm A Class");
}
}
class HelloB extends HelloA{
public HelloB(){
System.out.println("HelloB");
}
{
System.out.println("I'm B Class");
}
}
public class Test01{
public static void main(String[] args) {
new HelloB();
}
}
第二题
知识点：实例初始化
案例：判断运行结果
package com.atguigu.test02;
public class Test02 {
public static void main(String[] args) {
new Child("mike");
}
}
class People {
private String name;
public People() {
System.out.print("1");
}
public People(String name) {
System.out.print("2");
this.name = name;
}
}
class Child extends People {
People father;
public Child(String name) {
super();
System.out.print("3");
father = new People(name + " F");
}
public Child() {
System.out.print("4");
}
}
package com.atguigu.test02;
/*
* 实例初始化的过程：
* (1)父类的实例初始化
* <init>(){
* System.out.print("1");
* }
* (2)子类的实例初始化
* <init>(String name){
* System.out.print("3");
* father = new People(name + " F");//创建了一个父类的对象
* 调用父类的<init>(String name){
* System.out.print("2");
* }
* }
*
*/
public class Test02 {
public static void main(String[] args) {
new Child("mike");
}
}
class People {
private String name;
public People() {
System.out.print("1");
}
public People(String name) {
System.out.print("2");
this.name = name;
}
}
class Child extends People {
People father;
public Child(String name) {
System.out.print("3");
father = new People(name + " F");
}
public Child() {
System.out.print("4");
}
}第三题
知识点：实例初始化
案例：分析运行结果
package com.atguigu.test03;
public class Test03 {
public static void main(String[] args) {
Father f = new Father();
Child c = new Child();
}
}
class Father {
public Father(){
System.out.println("father create");
}
}
class Child extends Father{
public Child(){
System.out.println("child create");
}
}
package com.atguigu.test03;
/*
* 1、Father f = new Father();
* 执行父类的实例初始化方法
* <init>(){
* System.out.println("father create");
* }
*
* 2、Child c = new Child();
* （1）先执行父类的实例初始化方法
* <init>(){
* System.out.println("father create");
* }
* （2）再执行子类的实例初始化方法
* <init>(){
* System.out.println("child create");
* }
*/
public class Test03 {
public static void main(String[] args) {
Father f = new Father();
Child c = new Child();
}
}
class Father {
public Father(){
System.out.println("father create");
}
}
class Child extends Father{
public Child(){
System.out.println("child create");
}
}第四题
知识点：继承、属性同名问题
package com.atguigu.test04;
public class Test04 extends Father{
private String name = "test";
public static void main(String[] args) {
Test04 test = new Test04();
System.out.println(test.getName());
}
}
class Father {
private String name = "father";
public String getName() {
return name;
}
}
package com.atguigu.test04;
/*
* 当父类与子类有同名的属性时：
* 通过子类对象调用getName()访问的是父类的name还是子类的name，
* 那么要看子类是否重写，如果没有重写，就是父类的，重写了就是子类的。
*/
public class Test04 extends Father{
private String name = "test";
public static void main(String[] args) {
Test04 test = new Test04();
System.out.println(test.getName());
}
}
class Father {
private String name = "father";
public String getName() {
return name;
}
}第五题
知识点：实例初始化、构造器
案例：分析运行结果
package com.atguigu.test05;
public class Test05 {
public static void main(String[] args) {
new A(new B());
}
}
class A {
public A() {
System.out.println("A");
}
public A(B b) {
this();
System.out.println("AB");
}
}
class B {
public B() {
System.out.println("B");
}
}
package com.atguigu.test05;
/*
* 1、先算new B()
* 执行B类的实例初始化方法：
* <init>(){
* System.out.println("B");
* }
* 2、再算new A(B对象)
* 执行A类的实例初始化方法：
* <init>(B b){
* this();
* 即调用本类的无参构造，或者说无参实参初始化方法
* <init>(){
* System.out.println("A");
* }
* System.out.println("AB");
* }
*/
public class Test05 {
public static void main(String[] args) {
new A(new B());
}
}
class A {
public A() {
System.out.println("A");
}
public A(B b) {
this();
System.out.println("AB");
}
}
class B {
public B() {
System.out.println("B");
}
}
第六题
知识点：实例初始化
案例：分析运行结果
package com.atguigu.test06;
public class Test06 {
public static void main(String[] args) {
Sub s = new Sub();
}
}
class Base{
Base(){
method(100);// this.method(100);调用当前对象的method，现在new子类对象，当前对象是子类，子类重写了method，这里执行子类的method
}
{
System.out.println("base");
}
public void method(int i){
System.out.println("base : " + i);
}
}
class Sub extends Base{
Sub(){
super.method(70);
}
{
System.out.println("sub");
}
public void method(int j){
System.out.println("sub : " + j);
}
}
package com.atguigu.test06;
/*
* 创建对象是通过执行实例初始化方法来完成的。
* 如果new后面跟无参构造，就说明调用无参的实例初始化方法<init>()，
* 如果new后面跟有参构造，就说明调用有参的实例初始化方法<init>(形参列表)。
* 编译器编译后类中没有构造器，而是编译为一个个的实例初始化方法。
* 实例初始化由：
* （1）非静态成员变量的显式赋值代码
* （2）非静态代码块代码
* （3）构造器代码
* 其中（1）（2）按编写顺序，（3）在最后
* 在子类实例初始化首行会有super()或super(实参列表)表示调用父类的实例初始化方法，
* 如果没写super()或super(实参列表)，那么默认就是super()，因此：
* 1、执行父类的实例初始化方法
* <ini>(){
* System.out.println("base");
* method(100); //因为此时在创建子类的对象过程中，所以这个method(100)方法是
* 子类对象再调用，那么又因为子类重写了method(int)方法，
* 所以执行子类的method(int)
* 即System.out.println("sub : " + j);
* }
*
* 2、执行子类的实例初始化方法
* <init>(){
* System.out.println("sub");
* super.method(70);//因为这里用super.，那么一定是调用父类的method(int)
* 即System.out.println("base : " + i);
* }
*/
public class Test06 {
public static void main(String[] args) {
Sub s = new Sub();
}
}
class Base{
Base(){
method(100);
}
{
System.out.println("base");
}
public void method(int i){
System.out.println("base : " + i);
}
}
class Sub extends Base{
Sub(){
super.method(70);
}
{
System.out.println("sub");
}
public void method(int j){
System.out.println("sub : " + j);
}
}第七题
public class Test07 {
public static void main(String[] args) {
Son son = new Son();
}
}
class Father{
static{
System.out.println("（1）父类的静态代码块");
}
{
System.out.println("（2）父类的非静态代码块");
}
Father(){
System.out.println("（3）父类的无参构造");
}
}
class Son extends Father{
static{
System.out.println("（4）子类的静态代码块");
}
{
System.out.println("（5）子类的非静态代码块");
}
Son(){
System.out.println("（6）子类的无参构造");
}
}
package com.atguigu.test07;
/*
* （1）Father类的类初始化
* ①类变量显式赋值：这里没有
* ②静态代码块
* System.out.println("（1）父类的静态代码块");
* （2）Son类的类初始化
* ①类变量显式赋值：这里没有
* ②静态代码块
* System.out.println("（4）子类的静态代码块");
*
* （3）执行Father类的是实参初始化方法<init>()
* ①非静态成员变量的显式赋值：这里没有
* ②非静态代码块：
* System.out.println("（2）父类的非静态代码块");
* ③父类的无参构造
* System.out.println("（3）父类的无参构造");
*
* （4）执行Son类的实例初始化方法<init>()
* ①非静态成员变量的显式赋值：这里没有
* ②非静态代码块：
* System.out.println("（5）子类的非静态代码块");
* ③子类的无参构造
* System.out.println("（6）子类的无参构造");
*/
public class Test07 {
public static void main(String[] args) {
Son son = new Son();
}
}
class Father{
static{
System.out.println("（1）父类的静态代码块");
}
{
System.out.println("（2）父类的非静态代码块");
}
Father(){
System.out.println("（3）父类的无参构造");
}
}
class Son extends Father{
static{
System.out.println("（4）子类的静态代码块");
}
{
System.out.println("（5）子类的非静态代码块");
}
Son(){
System.out.println("（6）子类的无参构造");
}
}
第八题
public class Test08 {
public static void main(String[] args) {
Zi zi = new Zi();
}
}
class Fu{
private static int i = getNum("（1）i");
private int j = getNum("（2）j");
static{
print("（3）父类静态代码块");
}
{
print("（4）父类非静态代码块，又称为构造代码块");
}
Fu(){
print("（5）父类构造器");
}
public static void print(String str){
System.out.println(str + "->" + i);
}
public static int getNum(String str){
print(str);
return ++i;
}
}
class Zi extends Fu{
private static int k = getNum("（6）k");
private int h = getNum("（7）h");
static{
print("（8）子类静态代码块");
}
{
print("（9）子类非静态代码块，又称为构造代码块");
}
Zi(){
print("（10）子类构造器");
}
public static void print(String str){
System.out.println(str + "->" + k);
}
public static int getNum(String str){
print(str);
return ++k;
}
}
package com.atguigu.test08;
/*
* （1）Fu类的类初始化
* ①类变量显式赋值：
* i = getNum("（1）i");
* public static int getNum(String str){
print(str);
print方法代码如下：
public static void print(String str){
System.out.println(str + "->" + i); (1)i -> 0（默认值）
}
return ++i; i=1
}
* ②静态代码块
* static{
print("（3）父类静态代码块");
print方法代码如下：
public static void print(String str){
System.out.println(str + "->" + i); （3）父类静态代码块 -> 1
}
}
* （2）Zi类的类初始化
* ①类变量显式赋值：
* k = getNum("（6）k");
*
public static int getNum(String str){
print(str);
print方法代码如下：
public static void print(String str){
System.out.println(str + "->" + k); （6）k -> 0（默认值）
}
return ++k; k=1
}
* ②静态代码块
* static{
print("（8）子类静态代码块");
print方法代码如下：
public static void print(String str){
System.out.println(str + "->" + k); （8）子类静态代码块 -> 1
}
}
*
* （3）执行Fu类的是实参初始化方法<init>()
* ①非静态成员变量的显式赋值：
* j = getNum("（2）j");
*
public static int getNum(String str){
print(str);
print方法代码如下：
public static void print(String str){
System.out.println(str + "->" + i); （2）j -> 1
}
return ++i; i=2
}
* ②非静态代码块：
* {
print("（4）父类非静态代码块，又称为构造代码块");
print方法代码如下：
public static void print(String str){
System.out.println(str + "->" + i); （4）父类非静态代码块，又称为构造代码块 -> 2
}
}
* ③父类的无参构造
* Fu(){
print("（5）父类构造器");
print方法代码如下：
public static void print(String str){
System.out.println(str + "->" + i); （5）父类构造器 -> 2
}
}
*
* （4）执行Zi类的实例初始化方法<init>()
* ①非静态成员变量的显式赋值：
* h = getNum("（7）h");
public static int getNum(String str){
print(str);
print方法代码如下：
public static void print(String str){
System.out.println(str + "->" + k); （7）h ->1
}
return ++k; k=2
}
*
* ②非静态代码块：
* {
print("（9）子类非静态代码块，又称为构造代码块");
print方法代码如下：
public static void print(String str){
System.out.println(str + "->" + k); （9）子类非静态代码块，又称为构造代码块 ->2
}
}
* ③子类的无参构造
* Zi(){
print("（10）子类构造器");
print方法代码如下：
public static void print(String str){
System.out.println(str + "->" + k); （10）子类构造器 ->2
}
}
*/
public class Test08 {
public static void main(String[] args) {
Zi zi = new Zi();
}
}
class Fu{
private static int i = getNum("（1）i");
private int j = getNum("（2）j");
static{
print("（3）父类静态代码块");
}
{
print("（4）父类非静态代码块，又称为构造代码块");
}
Fu(){
print("（5）父类构造器");
}
public static void print(String str){
System.out.println(str + "->" + i);
}
public static int getNum(String str){
print(str);
return ++i;
}
}
class Zi extends Fu{
private static int k = getNum("（6）k");
private int h = getNum("（7）h");
static{
print("（8）子类静态代码块");
}
{
print("（9）子类非静态代码块，又称为构造代码块");
}
Zi(){
print("（10）子类构造器");
}
public static void print(String str){
System.out.println(str + "->" + k);
}
public static int getNum(String str){
print(str);
return ++k;
}
}
第九题
public class T {
public static int k = 0;
public static T t1 = new T("t1");
public static T t2 = new T("t2");
public static int i = print("i");
public static int n = 99;
public int j = print("j");
{
print("构造块");
}
static{
print("静态块");
}
public T(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
++i;
}
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
return ++i;
}
public static void main(String[] args) {
}
}package com.atguigu.test09;
/*
* 对于T来说，就完成类初始化
*
* 创建对象，调用类的实例初始化<init>()或<init>(String str)
*
* （1）静态变量的显式赋值
* k = 0;
t1 = new T("t1");
<init>(String str)
①j = print("j");
print方法代码如下：
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 1：j i=0 n=0
++n; n=1 k=1
return ++i; i=1
}
② {
print("构造块");
print方法代码如下：
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 2：构造块 i=1 n=1
++n; n=2 k=2
return ++i; i=2
}
}
③public T(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 3:t1 i=2 n=2
++n; n=3 k=3
++i; i=3
}
* t2 = new T("t2");
<init>(String str)
①j = print("j");
print方法代码如下：
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 4：j i=3 n=3
++n; n=4 k=4
return ++i; i=4
}
② {
print("构造块");
print方法代码如下：
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 5：构造块 i=4 n=4
++n; n=5 k=5
return ++i; i=5
}
}
③public T(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 6:t2 i=5 n=5
++n; n=6 k=6
++i; i=6
}
i = print("i");
print方法代码如下：
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 7：i i=6 n=6
++n; n=7 k=7
return ++i; i=7
}
n = 99;
* （2）静态代码块
* static{
print("静态块");
print方法代码如下：
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 8：静态块 i=7 n=99
++n; n=100 k=8
return ++i; i=8
}
}
*/
public class T {
public static int k = 0;
public static T t1 = new T("t1");
public static T t2 = new T("t2");
public static int i = print("i");
public static int n = 99;
public int j = print("j");
{
print("构造块");
}
static{
print("静态块");
}
public T(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
++i;
}
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
return ++i;
}
public static void main(String[] args) {
}
}第十题
考核知识点：方法的参数传递、final关键字
package com.atguigu.test10;
public class Test10 {
public static void main(String[] args) {
Other o = new Other();
new Test10().addOne(o);
System.out.println(o.i);
}
public void addOne(final Other o){
o.i++;
}
}
class Other{
public int i;
}/*
* 1、final
* final修饰的是o，不是i，因此o变量的值不能修改，不是说i变量的值不能修改
* 2、方法的参数传递机制：
* 形参是基本数据类型，那么实参给形参的是数据值的副本，形参的修改不影响实参；
* 形参是引用数据类型，那么实参给形参的是地址值的副本，形参对象修改属性相当于实参对象修改属性
*/
public class Test10 {
public static void main(String[] args) {
Other o = new Other();
new Test10().addOne(o);
System.out.println(o.i);
}
public void addOne(final Other o){
o.i++;
}
}
class Other{
public int i;
}第十一题
考核知识点：类初始化，局部变量与类变量，自增自减
package com.atguigu.test11;
public class Test11 {
static int x, y, z;
static {
int x = 5;
x--;
}
static {
x--;
}
public static void main(String[] args) {
System.out.println("x=" + x);
z--;
method();
System.out.println("result:" + (z + y + ++z));
}
public static void method() {
y = z++ + ++z;
}
}/*
* （1）类的初始化
* <clinit>(){
* int x = 5;//局部变量
x--;//局部变量 x=4
* Test07.x--;//静态变量 x = -1
* }
* （2）执行main方法
* System.out.println("x=" + x);//静态变量 -1
* z--;//静态变量 z=-1
* method();
* y = z++ + ++z;//静态变量
* ①先加载z的值“-1”②z自增，z=0③z自增 z =1④加载z的值“1” ⑤求和 “-1” + “1” = 0⑥把0赋值给y y=0
* System.out.println("result:" + (z + y + ++z));
* ①加载z的值“1” ②加载y的值"0" ③z自增 z=2 ④加载z的值“2” ⑤求和 “1” + “0” + “2”
*
*/
public class Test11 {
static int x, y, z;//类变量，静态变量，成员变量 默认值0
static {
int x = 5;//局部变量
x--;//局部变量
}
static {
x--;//静态变量
}
public static void main(String[] args) {
System.out.println("x=" + x);//静态变量
z--;//静态变量
method();
System.out.println("result:" + (z + y + ++z));//静态变量
}
public static void method() {
y = z++ + ++z;//静态变量
}
}第十二题
考核知识点：继承、this
package com.atguigu.test12;
public class Test12 {
public static void main(String[] args) {
Father f = new Father();
Son s = new Son();
System.out.println(f.getInfo());
System.out.println(s.getInfo());
s.setInfo("尚硅谷");
System.out.println(f.getInfo());
System.out.println(s.getInfo());
}
}
class Father{
private String info = "atguigu";
public void setInfo(String info){
this.info = info;
}
public String getInfo(){
return info;
}
}
class Son extends Father{
}/*
1、私有的属性是否可以被继承到子类中？
（1）如果从可以访问性的角度来说：不能，因为在子类中不能直接访问父类的私有的属性，但是可以通过get/set操作
（2）如果从类的概念来说，
类是一类具有相同特性（属性、方法等）的事物的抽象描述，
那么子类是从父类派生出来的，那么子类是有父类的这个特征的，即有这个属性的
2、每一个对象的非静态属性是独立的，其中一个对象修改和另一个对象是无关的
*/
public class Test12 {
public static void main(String[] args) {
Father f = new Father();
Son s = new Son();
System.out.println(f.getInfo());
System.out.println(s.getInfo());
s.setInfo("尚硅谷");
System.out.println(f.getInfo());
System.out.println(s.getInfo());
}
}
class Father{
private String info = "atguigu";
public void setInfo(String info){
this.info = info;
}
public String getInfo(){
return info;
}
}
class Son extends Father{
}
第十三题
考核知识点：继承、this、super
package com.atguigu.test13;
public class Test13 {
public static void main(String[] args) {
Father f = new Father();
Son s = new Son();
System.out.println(f.getInfo());
System.out.println(s.getInfo());
s.test();
System.out.println("-----------------");
s.setInfo("大硅谷");
System.out.println(f.getInfo());
System.out.println(s.getInfo());
s.test();
}
}
class Father{
private String info = "atguigu";
public void setInfo(String info){
this.info = info;
}
public String getInfo(){
return info;
}
}
class Son extends Father{
private String info = "尚硅谷";
public void test(){
System.out.println(this.getInfo());
System.out.println(super.getInfo());
}
}/*
1、私有的属性是否可以被继承到子类中？
（1）如果从可以访问性的角度来说：不能，因为在子类中不能直接访问父类的私有的属性，但是可以通过get/set操作
（2）如果从类的概念来说，
类是一类具有相同特性（属性、方法等）的事物的抽象描述，
那么子类是从父类派生出来的，那么子类是有父类的这个特征的，即有这个属性的
2、每一个对象的非静态属性是独立的，其中一个对象修改和另一个对象是无关的
3、当子类有与父类的属性同名时，那么通过子类对象调用get/set方法操作的是父类继承还是子类自己的属性呢？
要看子类是否重写：
如果没有重写，操作的都是父类的，不管是直接getInfo()还是this.getInfo()，还是super.getInfo()
如果重写了，如果通过子类对象调用，操作的是子类的，例如：getInfo()还是this.getInfo()，
如果通过super.调用的，操作的是父类的。
*/
public class Test13 {
public static void main(String[] args) {
Father f = new Father();
Son s = new Son();
System.out.println(f.getInfo());
System.out.println(s.getInfo());
s.test();
System.out.println("-----------------");
s.setInfo("大硅谷");
System.out.println(f.getInfo());
System.out.println(s.getInfo());
s.test();
}
}
class Father{
private String info = "atguigu";
public void setInfo(String info){
this.info = info;
}
public String getInfo(){
return info;
}
}
class Son extends Father{
private String info = "尚硅谷";
public void test(){
System.out.println(this.getInfo());
System.out.println(super.getInfo());
}
}
第十四题
考核知识点：继承、this、super、重写
package com.atguigu.test14;
public class Test14 {
public static void main(String[] args) {
Father f = new Father();
Son s = new Son();
System.out.println(f.getInfo());
System.out.println(s.getInfo());
s.test();
System.out.println("-----------------");
s.setInfo("大硅谷");
System.out.println(f.getInfo());
System.out.println(s.getInfo());
s.test();
}
}
class Father{
private String info = "atguigu";
public void setInfo(String info){
this.info = info;
}
public String getInfo(){
return info;
}
}
class Son extends Father{
private String info = "尚硅谷";
public void setInfo(String info){
this.info = info;
}
public String getInfo(){
return info;
}
public void test(){
System.out.println(this.getInfo());
System.out.println(super.getInfo());
}
}/*
1、私有的属性是否可以被继承到子类中？
（1）如果从可以访问性的角度来说：不能，因为在子类中不能直接访问父类的私有的属性，但是可以通过get/set操作
（2）如果从类的概念来说，
类是一类具有相同特性（属性、方法等）的事物的抽象描述，
那么子类是从父类派生出来的，那么子类是有父类的这个特征的，即有这个属性的
2、每一个对象的非静态属性是独立的，其中一个对象修改和另一个对象是无关的
3、当子类有与父类的属性同名时，那么通过子类对象调用get/set方法操作的是父类继承还是子类自己的属性呢？
要看子类是否重写：
如果没有重写，操作的都是父类的，不管是直接getInfo()还是this.getInfo()，还是super.getInfo()
如果重写了，如果通过子类对象调用，操作的是子类的，例如：getInfo()还是this.getInfo()，
如果通过super.调用的，操作的是父类的。
*/
public class Test14 {
public static void main(String[] args) {
Father f = new Father();
Son s = new Son();
System.out.println(f.getInfo());
System.out.println(s.getInfo());
s.test();
System.out.println("-----------------");
s.setInfo("大硅谷");
System.out.println(f.getInfo());
System.out.println(s.getInfo());
s.test();
}
}
class Father{
private String info = "atguigu";
public void setInfo(String info){
this.info = info;
}
public String getInfo(){
return info;
}
}
class Son extends Father{
private String info = "尚硅谷";
public void setInfo(String info){
this.info = info;
}
public String getInfo(){
return info;
}
public void test(){
System.out.println(this.getInfo());
System.out.println(super.getInfo());
}
}
第十五题
考核知识点：类初始化与实例初始化
package com.atguigu.test15;
class HelloA{
public HelloA(){
System.out.println("HelloA");
}
{
System.out.println("I'm A Class");
}
static{
System.out.println("static A");
}
}
public class HelloB extends HelloA{
public HelloB(){
System.out.println("HelloB");
}
{
System.out.println("I'm B Class");
}
static{
System.out.println("static B");
}
public static void main(String[] args) {
new HelloB();
}
}/*
* 1、main是Java程序的入口，那么main所在的类需要先完成类初始化，才能执行main方法。
* 即先完成HelloB的类初始化，才能执行main中的new Hello()
* 2、但是在类初始化时，如果发现父类还没有初始化，会先初始化父类，即先完成HelloA的类初始化
* 3、类初始化方法由：
* （1）静态变量的显式赋值代码
* （2）静态代码块代码
* 4、 创建对象是通过执行实例初始化方法来完成的。
* 如果new后面跟无参构造，就说明调用无参的实例初始化方法<init>()，
* 如果new后面跟有参构造，就说明调用有参的实例初始化方法<init>(形参列表)。
* 编译器编译后类中没有构造器，而是编译为一个个的实例初始化方法。
* 实例初始化由：
* （1）非静态成员变量的显式赋值代码
* （2）非静态代码块代码
* （3）构造器代码
* 其中（1）（2）按编写顺序，（3）在最后
* 在子类实例初始化首行会有super()或super(实参列表)表示调用父类的实例初始化方法，
* 如果没写super()或super(实参列表)，那么默认就是super()，因此：
*
* 因此：
* 1、先执行HelloA的类初始化
* <clinit>(){
* System.out.println("static A");
* }
* 2、在完成Hello的类初始化
* <clinit>(){
* System.out.println("static B");
* }
* 3、再执行父类HelloA的实例初始化方法
* <init>(){
* System.out.println("I'm A Class");
* System.out.println("HelloA");
* }
* 4、最后执行子类HelloB的是实例初始化方法
* <init>(){
* System.out.println("I'm B Class");
* System.out.println("HelloB");
* }
*/
class HelloA{
public HelloA(){
System.out.println("HelloA");
}
{
System.out.println("I'm A Class");
}
static{
System.out.println("static A");
}
}
public class HelloB extends HelloA{
public HelloB(){
System.out.println("HelloB");
}
{
System.out.println("I'm B Class");
}
static{
System.out.println("static B");
}
public static void main(String[] args) {
new HelloB();
}
}代码编程题
第十六题
案例：
1、在com.atguigu.test16包中声明员工类、程序员类、设计师类、架构师类，
员工类属性：编号、姓名、年龄、薪资
程序员类属性：编程语言，默认都是"java"
设计师类属性：奖金
架构师类属性：持有股票数量
要求：属性私有化，无参有参构造，get/set，getInfo方法（考虑重写）
2、在com.atguigu.test16包中声明Test16类，并在main中创建每一个类的对象，并为属性赋值，并调用它们的getInfo()显示信息
package com.atguigu.test16;
public class Employee {
private int id;
private String name;
private int age;
private double salary;
public Employee() {
super();
}
public Employee(int id, String name, int age, double salary) {
super();
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String getInfo(){
return id + "\t" + name + "\t" + age + "\t" + salary;
}
}package com.atguigu.test16;
public class Programmer extends Employee{
private String language = "java";
public Programmer() {
super();
}
public Programmer(int id, String name, int age, double salary) {
super(id, name, age, salary);
}
public Programmer(int id, String name, int age, double salary, String language) {
super(id, name, age, salary);
this.language = language;
}
public String getLanguage() {
return language;
}
public void setLanguage(String language) {
this.language = language;
}
@Override
public String getInfo() {
return super.getInfo() + "\t" + language;
}
}package com.atguigu.test16;
public class Designer extends Programmer {
private double bonus;
public Designer() {
super();
}
public Designer(int id, String name, int age, double salary, double bonus) {
super(id, name, age, salary);
this.bonus = bonus;
}
public Designer(int id, String name, int age, double salary, String language, double bonus) {
super(id, name, age, salary, language);
this.bonus = bonus;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public String getInfo() {
return super.getInfo()+ "\t" + bonus;
}
}package com.atguigu.test16;
public class Architect extends Designer {
private int stock;
public Architect() {
super();
}
public Architect(int id, String name, int age, double salary, double bonus, int stock) {
super(id, name, age, salary, bonus);
this.stock = stock;
}
public Architect(int id, String name, int age, double salary, String language, double bonus, int stock) {
super(id, name, age, salary, language, bonus);
this.stock = stock;
}
public int getStock() {
return stock;
}
public void setStock(int stock) {
this.stock = stock;
}
@Override
public String getInfo() {
return super.getInfo() + "\t" + stock;
}
}package com.atguigu.test16;
public class Test16 {
public static void main(String[] args) {
Employee emp = new Employee(1, "张三", 23, 13000);
Programmer pro = new Programmer(2, "李四", 23, 14000);
Designer des = new Designer(3, "王五", 25, 15000, "scalar", 2000);
Architect arc = new Architect(4, "赵六", 26, 16000, 3000, 100);
System.out.println("编号\t姓名\t年龄\t薪资\t语言\t奖金\t股票");
System.out.println(emp.getInfo());
System.out.println(pro.getInfo());
System.out.println(des.getInfo());
System.out.println(arc.getInfo());
}
}第九章
代码阅读分析题
第一题
考核知识点：属性与多态无关
package com.atguigu.test01;
public class Test01 {
public static void main(String[] args) {
A a = new B();
System.out.println(a.num);
System.out.println(((B)a).num);
System.out.println(((A)((B)a)).num);
System.out.println("-------------------");
B b = new B();
System.out.println(b.num);
System.out.println(((A)b).num);
System.out.println(((B)((A)b)).num);
}
}
class A{
int num = 1;
}
class B extends A{
int num = 2;
}
/*
* 多态性现象：编译时类型与运行时类型不一致
* 但是多态性是针对方法来说，方法有动态绑定一说。
* 属性没有多态性。属性都是按照编译时类型处理的。
*/
public class Test01 {
public static void main(String[] args) {
A a = new B();
System.out.println(a.num);//a编译时类型就是A 1
System.out.println(((B)a).num);//编译后，因为a被强制成B类，是B类型 2
System.out.println(((A)((B)a)).num);//编译后，a转成B又转成A，是A类型 1
System.out.println("-------------------");
B b = new B();
System.out.println(b.num);//b编译时类型就是B 2
System.out.println(((A)b).num);//b被强制升级为A类型，按A类型处理， 1
System.out.println(((B)((A)b)).num);//b先转A又转B，最终是B类型 2
}
}
class A{
int num = 1;
}
class B extends A{
int num = 2;
}第二题
考核知识点：实例初始化方法，属性与多态无关
package com.atguigu.test02;
public class Test02 {
public static void main(String[] args) {
Father f = new Son();
System.out.println(f.x);
}
}
class Father{
int x = 10;
public Father(){
this.print();
x = 20;
}
public void print(){
System.out.println("Father.x = " + x);
}
}
class Son extends Father{
int x = 30;
public Son(){
this.print();
x = 40;
}
public void print(){
System.out.println("Son.x = " + x);
}
}
package com.atguigu.test02;
/*
* 1、Father f = new Son();
* 实例初始化的过程：
* （1）父类的实例初始化
* <init>(){
* x = 10;//父类的x
* this.print();//子类的print，因为this代表的是正在创建的子类对象，而子类重写了print，所以是子类的print'
* System.out.println("Son.x = " + x);//子类的x，此时还没有赋值，那么是默认值x=0
x = 20;//父类的x
* }
* （2）子类的实例初始化
* <init>(){
* x = 30;//子类的x
* this.print();//子类的print
* System.out.println("Son.x = " + x);//子类的x，此时已经赋值x=30
x = 40;//子类的x
* }
*
* 2、执行System.out.println(f.x);
* 属性没有多态性，只看编译时类型，那么此时f.x表示父类的x
*/
public class Test02 {
public static void main(String[] args) {
Father f = new Son();
System.out.println(f.x);
}
}
class Father{
int x = 10;
public Father(){
this.print();
x = 20;
}
public void print(){
System.out.println("Father.x = " + x);
}
}
class Son extends Father{
int x = 30;
public Son(){
this.print();
x = 40;
}
public void print(){
System.out.println("Son.x = " + x);
}
}第三题
考核知识点：多态，重写，实例初始化过程
package com.atguigu.test03;
public class Test03 {
public static void main(String[] args) {
Base b1 = new Base();
Base b2 = new Sub();
}
}
class Base {
Base() {
method(100);
}
public void method(int i) {
System.out.println("base : " + i);
}
}
class Sub extends Base {
Sub() {
super.method(70);
}
public void method(int j) {
System.out.println("sub : " + j);
}
}
package com.atguigu.test03;
/*
* 1、Base b1 = new Base();
* 父类的实例初始化，和子类无关
*
* <init>(){
* method(100);
* System.out.println("base : " + i); base:100
* }
*
* 2、Base b2 = new Sub();
* （1） 父类的实例初始化
*
* <init>(){
* method(100);//执行了子类重写的method()
* System.out.println("sub : " + j); sub:100
* }
*
* （2）子类的实例初始化
* <init>(){
* super.method(70);
* System.out.println("base : " + i); base:70
* }
*/
public class Test03 {
public static void main(String[] args) {
Base b1 = new Base();
Base b2 = new Sub();
}
}
class Base {
Base() {
method(100);
}
public void method(int i) {
System.out.println("base : " + i);
}
}
class Sub extends Base {
Sub() {
super.method(70);
}
public void method(int j) {
System.out.println("sub : " + j);
}
}第四题
考核知识点：多态、重载、重写
public class Test04 {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println("(1)" + a1.show(b));
System.out.println("(2)" + a2.show(d));
System.out.println("(3)" + b.show(c));
System.out.println("(4)" + b.show(d));
}
}
class A{
public String show(D obj){
return ("A and D");
}
public String show(A obj){
return "A and A";
}
}
class B extends A{
public String show(B obj){
return "B and B";
}
public String show(A obj){
return "B and A";
}
}
class C extends B{
}
class D extends B{
}
/*
* 1、分析方法列表和继承关系
* A类：
* public String show(D obj)
* public String show(A obj)
* B类：
* public String show(D obj)继承的
* public String show(A obj)重写
* public String show(B obj)自定义的
* C->B->A
* D->B->A
*
* 2、方法重载：找最合适的形参类型
* 3、方法重写：如果子类重写，就执行重写的
* 4、分析执行结果
* a1.show(b)：a1没有多态引用，直接找A类的方法，b是B类对象，只能选择public String show(A obj) A and A
* a2.show(d)：a2多态引用，执行子类的方法，d是D类对象，选最合适的public String show(D obj) A and D
* b.show(c)：b没有多态引用，直接找B类的方法，c是C类的对象，选择最合适的public String show(B obj) B and B
* b.show(d)：b没有多态引用，直接找B类的方法，d是D类对象，选最合适的public String show(D obj) A and D
*/
public class Test04 {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println("(1)" + a1.show(b));
System.out.println("(2)" + a2.show(d));
System.out.println("(3)" + b.show(c));
System.out.println("(4)" + b.show(d));
}
}
class A {
public String show(D obj) {
return ("A and D");
}
public String show(A obj) {
return "A and A";
}
}
class B extends A {
public String show(B obj) {
return "B and B";
}
public String show(A obj) {
return "B and A";
}
}
class C extends B {
}
class D extends B {
}第五题
考核知识点：多态、重载、重写
public class Test05 {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println("(1)" + a1.show(b));
System.out.println("(2)" + a2.show(d));
System.out.println("(3)" + b.show(c));
System.out.println("(4)" + b.show(d));
}
}
class A {
public String show(C obj) {
return ("A and C");
}
public String show(A obj) {
return "A and A";
}
}
class B extends A {
public String show(B obj) {
return "B and B";
}
public String show(A obj) {
return "B and A";
}
}
class C extends B {
}
class D extends B {
}
package com.atguigu.test02;
/*
* 1、分析每个类的方法列表和继承关系
* A类：
* public String show(C obj)
* public String show(A obj)
* B类：
* public String show(C obj)继承的
* public String show(A obj)重写
* public String show(B obj)自定义的
* C->B->A
* D->B->A
*
* 2、方法重载：找最合适的形参类型
* 3、方法重写：如果子类重写，就执行重写的
* 4、如果特殊的重载，那么多态时，编译时先从父类中查找最合适的形参类型，然后如果子类如果有重写，执行子类重写的，如果没有重写，执行父类的。
* 5、分析执行结果
* a1.show(b)：a1没有多态引用，直接找A类的方法，b是B类对象，只能选择public String show(A obj) A and A
* a2.show(d)：a2多态引用，执行子类的方法，d是D类对象，但是因为此时编译时按A类编译，所以在编译期间先确定是调用
* public String show(A obj)，而后执行子类重写的public String show(A obj) B and A
* 而不是直接选最合适的public String show(B obj)
* b.show(c)：b没有多态引用，直接找B类的方法，c是C类的对象，选择最合适的public String show(C obj) A and C
* b.show(d)：b没有多态引用，直接找B类的方法，d是D类对象，选最合适的public String show(B obj) B and B
*/
public class Test02 {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println("(1)" + a1.show(b));
System.out.println("(2)" + a2.show(d));
System.out.println("(3)" + b.show(c));
System.out.println("(4)" + b.show(d));
}
}
class A {
public String show(C obj) {
return ("A and C");
}
public String show(A obj) {
return "A and A";
}
}
class B extends A {
public String show(B obj) {
return "B and B";
}
public String show(A obj) {
return "B and A";
}
}
class C extends B {
}
class D extends B {
}第六题
考核知识点：属性与多态无关
public class Test06 {
public static void main(String[] args) {
Base b = new Sub();
System.out.println(b.x);
}
}
class Base{
int x = 1;
}
class Sub extends Base{
int x = 2;
}
package com.atguigu.test06;
/*
* 属性没有多态性，只看编译时类型
*/
public class Test06 {
public static void main(String[] args) {
Base b = new Sub();
System.out.println(b.x);
}
}
class Base{
int x = 1;
}
class Sub extends Base{
int x = 2;
}第题七
考核知识点：权限修饰符
如下代码是否可以编译通过，如果能，结果是什么，如果不能，为什么？
public class Father{
private String name = "atguigu";
int age = 0;
}
public class Child extends Father{
public String grade;
public static void main(String[] args){
Father f = new Child();
System.out.println(f.name);
}
}
package com.atguigu.test07;
public class Child extends Father{
public String grade;
public static void main(String[] args){
Father f = new Child();
// System.out.println(f.name);//编译错误，因为name私有化
}
}第八题
考核知识点：继承，super，static
如下代码是否可以编译通过，如果能，结果是什么，如果不能，为什么？
public class Person{
public Person(){
System.out.println("this is a Person.");
}
}
public class Teacher extends Person{
private String name = "tom";
public Teacher(){
System.out.println("this is a teacher.");
super();
}
public static void main(String[] args){
Teacher tea = new Teacher();
System.out.println(this.name);
}
}
package com.atguigu.test08;
public class Teacher extends Person{
private String name = "tom";
public Teacher(){
System.out.println("this is a teacher.");
// super();//错误，super()必须在构造器首行
}
public static void main(String[] args){
Teacher tea = new Teacher();
// System.out.println(this.name);//错误，static方法中不能使用this
}
}
代码编程题
第九题
知识点：抽象类
语法点：继承，抽象类
按步骤编写代码，效果如图所示：
- 编写步骤：
定义抽象类A，抽象类B继承A，普通类C继承B
A类中，定义成员变量numa，赋值为10，抽象showA方法。
B类中，定义成员变量numb，赋值为20，抽象showB方法。
C类中，定义成员变量numc，赋值为30，重写showA方法，打印numa，重写showB方法，打印numb，定义showC方法，打印numc。
测试类Test09中，创建C对象，调用showA方法，showB方法，showC方法。
package com.atguigu.test09;
public class Test09 {
public static void main(String[] args) {
C c = new C();
c.showA();
c.showB();
c.showC();
}
}
abstract class A{
protected int numa = 10;
public abstract void showA();
}
abstract class B extends A{
protected int numb = 20;
public abstract void showB();
}
class C extends B{
private int numc = 30;
@Override
public void showB() {
System.out.println("B类中numb:" + numb);
}
@Override
public void showA() {
System.out.println("A类中numa:" + numa);
}
public void showC(){
System.out.println("C类中numc:" + numc);
}
}第十题
知识点：抽象类
案例：
1、声明抽象父类Person，包含抽象方法public abstract void pee();
2、声明子类Woman，重写抽象方法，打印坐着尿
3、声明子类Man，重写抽象方法，打印站着上尿
4、声明测试类Test10，创建Person数组，存放Woman和Man对象，并遍历数组，调用pee()方法
package com.atguigu.test10;
public abstract class Person {
public abstract void pee();
}
package com.atguigu.test10;
public class Man extends Person{
@Override
public void pee() {
System.out.println("男人站着尿");
}
}
package com.atguigu.test10;
public class Woman extends Person{
@Override
public void pee() {
System.out.println("女人坐着尿");
}
}
package com.atguigu.test10;
public class Test10 {
public static void main(String[] args) {
Person[] all = new Person[2];
all[0] = new Woman();
all[1] = new Man();
for (int i = 0; i < all.length; i++) {
all[i].pee();
}
}
}
第十一题
知识点：抽象类
案例：
1、声明抽象父类Person，包含抽象方法public abstract void eat();
2、声明子类中国人Chinese，重写抽象方法，打印用筷子吃饭
3、声明子类美国人American，重写抽象方法，打印用刀叉吃饭
4、声明子类印度人Indian，重写抽象方法，打印用手抓饭
5、声明测试类Test11，创建Person数组，存储各国人对象，并遍历数组，调用eat()方法
package com.atguigu.test11;
public class Test11 {
public static void main(String[] args) {
Person[] all = new Person[3];
all[0] = new Chinese();
all[1] = new American();
all[2] = new Indian();
for (int i = 0; i < all.length; i++) {
all[i].eat();
}
}
}
abstract class Person{
public abstract void eat();
}
class Chinese extends Person{
@Override
public void eat() {
System.out.println("中国人用筷子吃饭");
}
}
class American extends Person{
@Override
public void eat() {
System.out.println("美国人用刀叉吃饭");
}
}
class Indian extends Person{
@Override
public void eat() {
System.out.println("印度人用手抓饭");
}
}第十二题
知识点：Object类的方法
案例：
1、声明三角形类，包含a,b,c三边
（1）属性私有化，提供无参，有参构造，提供get/set
（2）重写：toString()
（3）重写：hashCode和equals方法
（4）编写 public double getArea()：求面积方法
（5）编写 public double getPiremeter()：求周长方法
2、声明测试类Test12，在测试类中创建两个三角形对象，调用以上方法进行测试
package com.atguigu.test12;
public class Test12 {
public static void main(String[] args) {
Triangle t1 = new Triangle(3,4,5);
Triangle t2 = new Triangle(3,3,3);
System.out.println(t1);
System.out.println(t2);
System.out.println("t1的面积：" + t1.getArea());
System.out.println("t1的周长：" + t1.getPiremeter());
System.out.println("t2的面积：" + t2.getArea());
System.out.println("t2的面积：" + t2.getPiremeter());
System.out.println("t1和t2是否相同：" + t1.equals(t2));
}
}
class Triangle{
private double a;
private double b;
private double c;
public Triangle(double a, double b, double c) {
super();
this.a = a;
this.b = b;
this.c = c;
}
public Triangle() {
super();
}
public double getA() {
return a;
}
public void setA(double a) {
this.a = a;
}
public double getB() {
return b;
}
public void setB(double b) {
this.b = b;
}
public double getC() {
return c;
}
public void setC(double c) {
this.c = c;
}
@Override
public String toString() {
return "三角形的三条边：a=" + a + ", b=" + b + ", c=" + c;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(a);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(b);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(c);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Triangle other = (Triangle) obj;
if (Double.doubleToLongBits(a) != Double.doubleToLongBits(other.a))
return false;
if (Double.doubleToLongBits(b) != Double.doubleToLongBits(other.b))
return false;
if (Double.doubleToLongBits(c) != Double.doubleToLongBits(other.c))
return false;
return true;
}
public double getArea(){
double p = (a + b + c)/2;
return Math.sqrt(p * (p-a) * (p-b) * (p-c));
}
public double getPiremeter(){
return a + b + c;
}
}第十三题
案例：
1、在com.atguigu.test13包中声明员工类、程序员类、设计师类、架构师类，
员工类属性：编号、姓名、年龄、薪资
程序员类属性：编程语言，默认都是"java"
设计师类属性：奖金
架构师类属性：持有股票数量
要求：属性私有化，无参有参构造，get/set，getInfo方法（考虑重写）
2、在com.atguigu.test13包中声明Test13测试类
（1）在main中有一些常量和一个二维数组
final int EMPLOYEE = 10;//表示普通员工 final int PROGRAMMER = 11;//表示程序员 final int DESIGNER = 12;//表示设计师 final int ARCHITECT = 13;//表示架构师 String[][] EMPLOYEES = { {"10", "1", "段誉", "22", "3000"}, {"13", "2", "令狐冲", "32", "18000", "15000", "2000"}, {"11", "3", "任我行", "23", "7000"}, {"11", "4", "张三丰", "24", "7300"}, {"12", "5", "周芷若", "28", "10000", "5000"}, {"11", "6", "赵敏", "22", "6800"}, {"12", "7", "张无忌", "29", "10800","5200"}, {"13", "8", "韦小宝", "30", "19800", "15000", "2500"}, {"12", "9", "杨过", "26", "9800", "5500"}, {"11", "10", "小龙女", "21", "6600"}, {"11", "11", "郭靖", "25", "7100"}, {"12", "12", "黄蓉", "27", "9600", "4800"} };（2）创建一个员工数组
（3）根据以上数据，初始化员工数组
提示：把字符串转为int和double类型的值，可以使用如下方式：
String idStr = "1"; int id = Integer.parseInt(idStr); String salaryStr = "7300"; double salary = Double.parseDouble(salaryStr);（4）遍历数组，使用如下格式
编号 姓名 年龄 薪资 语言 奖金 股票 .....
package com.atguigu.test13;
public class Employee {
private int id;
private String name;
private int age;
private double salary;
public Employee() {
super();
}
public Employee(int id, String name, int age, double salary) {
super();
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String getInfo(){
return id + "\t" + name + "\t" + age + "\t" + salary;
}
}
package com.atguigu.test13;
public class Programmer extends Employee{
private String language = "java";
public Programmer() {
super();
}
public Programmer(int id, String name, int age, double salary) {
super(id, name, age, salary);
}
public Programmer(int id, String name, int age, double salary, String language) {
super(id, name, age, salary);
this.language = language;
}
public String getLanguage() {
return language;
}
public void setLanguage(String language) {
this.language = language;
}
@Override
public String getInfo() {
return super.getInfo() + "\t" + language;
}
}
package com.atguigu.test13;
public class Designer extends Programmer {
private double bonus;
public Designer() {
super();
}
public Designer(int id, String name, int age, double salary, double bonus) {
super(id, name, age, salary);
this.bonus = bonus;
}
public Designer(int id, String name, int age, double salary, String language, double bonus) {
super(id, name, age, salary, language);
this.bonus = bonus;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public String getInfo() {
return super.getInfo()+ "\t" + bonus;
}
}
package com.atguigu.test13;
public class Architect extends Designer {
private int stock;
public Architect() {
super();
}
public Architect(int id, String name, int age, double salary, double bonus, int stock) {
super(id, name, age, salary, bonus);
this.stock = stock;
}
public Architect(int id, String name, int age, double salary, String language, double bonus, int stock) {
super(id, name, age, salary, language, bonus);
this.stock = stock;
}
public int getStock() {
return stock;
}
public void setStock(int stock) {
this.stock = stock;
}
@Override
public String getInfo() {
return super.getInfo() + "\t" + stock;
}
}
package com.atguigu.test13;
public class Test13 {
public static void main(String[] args) {
final int EMPLOYEE = 10;//表示普通员工
final int PROGRAMMER = 11;//表示程序员
final int DESIGNER = 12;//表示设计师
final int ARCHITECT = 13;//表示架构师
String[][] EMPLOYEES = {
{"10", "1", "段誉", "22", "3000"},
{"13", "2", "令狐冲", "32", "18000", "15000", "2000"},
{"11", "3", "任我行", "23", "7000"},
{"11", "4", "张三丰", "24", "7300"},
{"12", "5", "周芷若", "28", "10000", "5000"},
{"11", "6", "赵敏", "22", "6800"},
{"12", "7", "张无忌", "29", "10800","5200"},
{"13", "8", "韦小宝", "30", "19800", "15000", "2500"},
{"12", "9", "杨过", "26", "9800", "5500"},
{"11", "10", "小龙女", "21", "6600"},
{"11", "11", "郭靖", "25", "7100"},
{"12", "12", "黄蓉", "27", "9600", "4800"}
};
Employee[] all = new Employee[EMPLOYEES.length];
for (int i = 0; i < all.length; i++) {
int type = Integer.parseInt(EMPLOYEES[i][0]);
int id = Integer.parseInt(EMPLOYEES[i][1]);
String name = EMPLOYEES[i][2];
int age = Integer.parseInt(EMPLOYEES[i][3]);
double salary = Double.parseDouble(EMPLOYEES[i][4]);
if(type == EMPLOYEE){
all[i] = new Employee(id, name, age, salary);
}else if(type == PROGRAMMER){
all[i] = new Programmer(id, name, age, salary);
}else if(type == DESIGNER){
double bonus = Integer.parseInt(EMPLOYEES[i][5]);
all[i] = new Designer(id, name, age, salary, bonus);
}else if(type == ARCHITECT){
double bonus = Double.parseDouble(EMPLOYEES[i][5]);
int stock = Integer.parseInt(EMPLOYEES[i][6]);
all[i] = new Architect(id, name, age, salary, bonus, stock);
}
}
System.out.println("编号\t姓名\t年龄\t薪资\t语言\t奖金\t股票");
for (int i = 0; i < all.length; i++) {
System.out.println(all[i].getInfo());
}
}
}
第十四题
案例：
1、在com.atguigu.test14包中声明图形Graphic、圆Circle、矩形Rectangle类、三角形Triangle类
2、图形Graphic类中有：
①public double getArea()方法：返回面积
②public double getPerimeter()方法：返回周长
③public String getInfo()方法：返回图形信息
3、圆类和矩形类重写这两个方法
4、在com.atguigu.test14包中声明测试类Test14_1
(1)请设计一个方法，可以用于比较两个图形的面积是否相等
(2)请设计一个方法，可以用于找出两个图形中面积大的那个
(3)public static void main(String[] args){}
在主方法中，创建1个圆、1个矩形、1个三角形对象，并分别调用(1)、(2)方法进行测试。
5、在com.atguigu.test14包中测试类Test14_2
(1)请设计一个方法，可以用于遍历一个图形数组
(2)请设计一个方法，可以用于给一个图形数组进行按照面积从小到大排序
(3)public static void main(String[] args){}
在主方法中，创建1个圆、1个矩形、1个三角形对象，放到数组中，遍历显示，然后排序后再遍历显示。
package com.atguigu.test14;
public class Graphic {
public double getArea(){
return 0.0;
}
public double getPerimeter(){
return 0.0;
}
public String getInfo(){
return "面积：" + getArea() + "，周长：" + getPerimeter();
}
}
package com.atguigu.test14;
public class Circle extends Graphic{
private double radius;
public Circle() {
super();
}
public Circle(double radius) {
super();
this.radius = radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
@Override
public double getArea() {
return 3.14 * radius * radius;
}
@Override
public double getPerimeter() {
return 2 * 3.14 * radius;
}
@Override
public String getInfo() {
return "半径：" + radius + "," + super.getInfo();
}
}
package com.atguigu.test14;
public class Rectangle extends Graphic{
private double length;
private double width;
public Rectangle(double length, double width) {
super();
this.length = length;
this.width = width;
}
public Rectangle() {
super();
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
@Override
public double getArea() {
return length * width;
}
@Override
public double getPerimeter() {
return 2 * (length + width);
}
@Override
public String getInfo() {
return "长：" + length + "，宽：" + width + "," + super.getInfo();
}
}
package com.atguigu.test14;
public class Triangle extends Graphic{
private double a;
private double b;
private double c;
public Triangle() {
super();
}
public Triangle(double a, double b, double c) {
super();
this.a = a;
this.b = b;
this.c = c;
}
public double getA() {
return a;
}
public void setA(double a) {
this.a = a;
}
public double getB() {
return b;
}
public void setB(double b) {
this.b = b;
}
public double getC() {
return c;
}
public void setC(double c) {
this.c = c;
}
@Override
public double getArea() {
double p = (a + b + c)/2;
return Math.sqrt(p * (p-a) * (p-b) * (p-c));
}
@Override
public double getPerimeter() {
return a+b+c;
}
@Override
public String getInfo() {
return "边长为：" + a + "," + b +"," + c+"," + super.getInfo();
}
}
package com.atguigu.test14;
public class Test14_01 {
public static void main(String[] args) {
Circle c1 = new Circle(2);
Rectangle r1 = new Rectangle(2, 3);
Triangle t1 = new Triangle(3, 4, 5);
System.out.println("c1的面积：" + c1.getArea());
System.out.println("r1的面积：" + r1.getArea());
System.out.println("t1的面积：" + t1.getArea());
System.out.println("c1和r1的面积是否相等：" + equal(c1, r1));
System.out.println("c1和t1的面积是否相等：" + equal(c1, t1));
System.out.println("r1和t1的面积是否相等：" + equal(r1, t1));
Graphic max1 = getMax(c1, r1);
System.out.println("c1和r1中面积大的是：" + max1.getArea());
Graphic max2 = getMax(c1, t1);
System.out.println("c1和t1中面积大的是：" + max2.getArea());
Graphic max3 = getMax(r1, t1);
System.out.println("r1和t1中面积大的是：" + max3.getArea());
}
public static boolean equal(Graphic g1, Graphic g2){
return g1.getArea() == g2.getArea();
}
public static Graphic getMax(Graphic g1, Graphic g2){
return g1.getArea() > g2.getArea() ? g1 : g2;
}
}
package com.atguigu.test14;
public class Test14_02 {
public static void main(String[] args) {
Graphic[] all = new Graphic[3];
all[0] = new Circle(2);
all[1] = new Rectangle(2, 3);
all[2] = new Triangle(3, 4, 5);
System.out.println("排序前：");
print(all);
sort(all);
System.out.println("排序后：");
print(all);
}
public static void print(Graphic[] all){
for (int i = 0; i < all.length; i++) {
System.out.println(all[i].getInfo());
}
}
public static void sort(Graphic[] all){
for (int i = 1; i < all.length; i++) {
for (int j = 0; j < all.length-i; j++) {
if(all[j].getArea() > all[j+1].getArea()){
Graphic temp = all[j];
all[j] = all[j+1];
all[j+1] = temp;
}
}
}
}
}
第十五题
案例：
1、在com.atguigu.test15包中声明人Person、男人Man、女人Woman类
（1）在Person类中，包含
①public void eat()：打印吃饭
②public void toilet()：打印上洗手间
（2）在Man类中，包含
①重写上面的方法
②增加 public void smoke()：打印抽烟
（3）在Woman类中，包含
①重写上面的方法
②增加 public void makeup()：打印化妆
2、在com.atguigu.test15包中声明测试类Test15
（1）public static void meeting(Person... ps)
在该方法中，每一个人先吃饭，然后上洗手间，然后如果是男人，随后抽根烟，如果是女人，随后化个妆
（2）public static void main(String[] args)
在主方法中，创建多个男人和女人对象，并调用meeting()方法进行测试
package com.atguigu.test15;
public class Person {
public void eat(){
System.out.println("吃饭");
}
public void toilet(){
System.out.println("上洗手间");
}
}
package com.atguigu.test15;
public class Man extends Person{
@Override
public void eat() {
System.out.println("细嚼慢咽吃饭");
}
@Override
public void toilet() {
System.out.println("坐着上洗手间");
}
public void smoke(){
System.out.println("抽烟爽爽");
}
}
package com.atguigu.test15;
public class Woman extends Person{
@Override
public void eat() {
System.out.println("狼吞虎咽吃饭");
}
@Override
public void toilet() {
System.out.println("站着上洗手间");
}
public void makeup(){
System.out.println("化妆美美");
}
}
package com.atguigu.test15;
public class Test15 {
public static void main(String[] args) {
meeting(new Woman(),new Man(), new Woman(), new Man());
}
public static void meeting(Person... ps){
for (int i = 0; i < ps.length; i++) {
ps[i].eat();
ps[i].toilet();
if(ps[i] instanceof Woman){
((Woman)ps[i]).makeup();
}else if(ps[i] instanceof Man){
((Man)ps[i]).smoke();
}
}
}
}第十章
接口编程代码题
第一题
-
语法点：接口
-
按步骤编写代码，效果如图所示：
-
编写步骤：
定义接口A，普通类B实现接口A
A接口中，定义抽象方法showA。
A接口中，定义默认方法showB。
B类中，重写showA方法
测试类中，创建B类对象，调用showA方法，showB方法。
package com.atguigu.test01;
public class Test01 {
public static void main(String[] args) {
B b = new B();
b.showA();
b.showB();
}
}
interface A{
void showA();
default void showB(){
System.out.println("BBB");
}
}
class B implements A{
@Override
public void showA() {
System.out.println("AAA");
}
}第二题
-
语法点：接口，多态
-
按步骤编写代码，效果如图所示：
-
编写步骤
定义接口Universe，提供抽象方法doAnything。
定义普通类Star，提供成员发光shine方法，打印“star:星星一闪一闪亮晶晶"
定义普通类Sun，
继承Star类，重写shine方法，打印"sun:光照八分钟，到达地球"
实现Universe接口，实现doAnything，打印"sun:太阳吸引着9大行星旋转"
测试类中，创建Star对象，调用shine方法
测试类中，多态的方式创建Sun对象，调用doAnything方法，向下转型，调用shine方法。
package com.atguigu.test02;
public class Test02 {
public static void main(String[] args) {
Star s = new Star();
s.shine();
System.out.println("======================");
Universe u = new Sun();
u.doAnything();
Star sun = (Star) u;
sun.shine();
}
}
interface Universe{
void doAnything();
}
class Star{
public void shine(){
System.out.println("star:星星一闪一闪亮晶晶");
}
}
class Sun extends Star implements Universe{
@Override
public void shine(){
System.out.println("sun:光照8分钟到达地球");
}
@Override
public void doAnything() {
System.out.println("sun:太阳吸引着9大行星旋转");
}
}第三题
模拟玩家选择角色。
定义接口FightAble：
抽象方法：specialFight。
默认方法：commonFight,方法中打印"普通打击"。
定义战士类：
实现FightAble接口,重写方法中打印"武器攻击"。
定义法师类Mage：
实现FightAble接口,重写方法中打印"法术攻击"。
定义玩家类Player：
静态方法：FightAble select(String str)，根据指令选择角色。
法力角色，选择法师。
武力角色，选择战士。
-
代码实现，效果如图所示：
package com.atguigu.test03;
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("选择：");
String role1 = input.next();
FightAble f1 = Player.select(role1);
f1.specialFight();
f1.commonFight();
System.out.println("====================");
System.out.print("选择：");
String role2 = input.next();
FightAble f2 = Player.select(role2);
f2.specialFight();
f2.commonFight();
input.close();
}
}
interface FightAble{
void specialFight();
default void commonFight(){
System.out.println("普通攻击");
}
}
class Soldier implements FightAble{
@Override
public void specialFight() {
System.out.println("武器攻击");
}
}
class Mage implements FightAble{
@Override
public void specialFight() {
System.out.println("法术攻击");
}
}
class Player{
public static FightAble select(String str){
if("法力角色".equals(str)){
return new Mage();
}else if("武力角色".equals(str)){
return new Soldier();
}
return null;
}
}第四题
模拟工人挑苹果。
定义苹果类：
属性：大小，颜色。
提供基本的构造方法和get方法，set方法
定义接口CompareAble：
定义默认方法compare，挑选较大苹果。
定义接口实现类CompareBig。
定义接口实现类CompareColor。挑选红色苹果。
定义工人类：
成员方法：挑选苹果public void pickApple(CompareAble c,Apple a1,Apple a2)。
测试类：
创建Worker对象。
创建两个Apple对象，一个Apple（5，"青色"）,一个Apple（3，"红色"）
-
代码实现，效果如图所示：
package com.atguigu.test04;
public class Test04 {
public static void main(String[] args) {
Worker w = new Worker();
Apple a1 = new Apple(5, "青色");
Apple a2 = new Apple(3, "红色");
w.pickApple(new CompareBig(), a1, a2);
w.pickApple(new CompareColor(), a1, a2);
}
}
class Apple{
private double size;
private String color;
public Apple(double size, String color) {
super();
this.size = size;
this.color = color;
}
public Apple() {
super();
}
public double getSize() {
return size;
}
public void setSize(double size) {
this.size = size;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return size + "-" + color;
}
}
interface CompareAble{
default void compare(Apple a1,Apple a2){
System.out.println("默认挑大的：");
if(a1.getSize() > a2.getSize()){
System.out.println(a1);
}else{
System.out.println(a2);
}
}
}
class CompareBig implements CompareAble{
}
class CompareColor implements CompareAble{
@Override
public void compare(Apple a1, Apple a2) {
System.out.println("挑红的：");
if("红色".equals(a1.getColor())){
System.out.println(a1);
}
if("红色".equals(a2.getColor())){
System.out.println(a2);
}
}
}
class Worker{
public void pickApple(CompareAble c,Apple a1,Apple a2){
c.compare(a1, a2);
}
}第五题
模拟接待员接待用户，根据用户id，给用户分组。
定义用户类：
属性：用户类型，用户id
提供基本的构造方法和get方法，set方法
定义接口Filter：
提供抽象方法filterUser（User u）
定义实现类V1Filter，实现抽象方法，将用户设置为v1
定义实现类V2Filter，实现抽象方法，将用户设置为v2
定义实现类AFilter，实现抽象方法，将用户设置为A
定义接待员类Receptionist：
属性：接口Filter
提供基本的构造方法和get方法，set方法
成员方法：接待用户方法，设置用户类型。
测试类：
初始化15个User对象，id为1-15。
创建三个接待员对象。
第一个接待员，设置接待规则，将1-5号用户类型设置为v1。
第二个接待员，设置接待规则，将6-10号用户类型设置为v2。
第三个接待员，设置接待规则，将11-15号用户类型设置为A。
遍历数组，给用户分区。
-
代码实现，效果如图所示：
package com.atguigu.test05;
public class Test05 {
public static void main(String[] args) {
User[] all = new User[15];
for (int i = 0; i < all.length; i++) {
all[i] = new User(null,i+1);
}
V1Filter v1F = new V1Filter();
V2Filter v2F = new V2Filter();
AFilter aF = new AFilter();
Receptionist r1 = new Receptionist(v1F);
for (int i = 0; i < 5; i++) {
r1.recept(all[i]);
}
Receptionist r2 = new Receptionist(v2F);
for (int i = 5; i < 10; i++) {
r2.recept(all[i]);
}
Receptionist r3 = new Receptionist(aF);
for (int i = 10; i < 15; i++) {
r3.recept(all[i]);
}
for (int i = 0; i < all.length; i++) {
System.out.println(all[i]);
}
}
}
class User{
private String type;
private int id;
public User(String type, int id) {
super();
this.type = type;
this.id = id;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return id + "-" + type;
}
}
interface Filter{
void filterUser(User u);
}
class V1Filter implements Filter{
@Override
public void filterUser(User u) {
u.setType("v1");
}
}
class V2Filter implements Filter{
@Override
public void filterUser(User u) {
u.setType("v2");
}
}
class AFilter implements Filter{
@Override
public void filterUser(User u) {
u.setType("A");
}
}
class Receptionist{
private Filter filter;
public Receptionist(Filter filter) {
super();
this.filter = filter;
}
public Filter getFilter() {
return filter;
}
public void setFilter(Filter filter) {
this.filter = filter;
}
public void recept(User u){
if(u.getType() != null){
return ;
}
filter.filterUser(u);
}
}包装类代码题
第一题
public static void main(String[] args) {
Integer i1 = 128;
Integer i2 = 128;
int i3 = 128;
int i4 = 128;
System.out.println(i1 == i2);
System.out.println(i3 == i4);
System.out.println(i1 == i3);
}
public static void main(String[] args) {
Integer i1 = 128;
Integer i2 = 128;
int i3 = 128;
int i4 = 128;
System.out.println(i1 == i2);//false，比较地址，128超过Integer缓存对象
System.out.println(i3 == i4);//true，比较数据值
System.out.println(i1 == i3);//true，i1自动拆箱按照基本数据类型比较
//包装类对象与基本数据类型进行比较时，就会把包装类对象自动拆箱，按照基本数据类型的规则进行比较
}第二题
public static void main(String[] args) {
double a = 2.0;
double b = 2.0;
Double c = 2.0;
Double d = 2.0;
System.out.println(a == b);
System.out.println(c == d);
System.out.println(a == d);
}
public static void main(String[] args) {
double a = 2.0;
double b = 2.0;
Double c = 2.0;
Double d = 2.0;
System.out.println(a == b);//true，基本数据类型比较数据值
System.out.println(c == d);//false，对象比较地址值，Double没有缓存对象
System.out.println(a == d);//true,d自动拆箱，按照基本数据类型比较
}枚举编程题
第一题
案例：
1、声明颜色枚举类：
7个常量对象：赤、橙、黄、绿、青、蓝、紫。
2、在测试类中，使用枚举类，获取绿色对象，并打印对象。
package com.atguigu.test01;
public class Test01 {
public static void main(String[] args) {
Color c = Color.GREEN;
System.out.println(c);
}
}
enum Color{
RED,ORANGE,YELLOW,GREEN,CYAN,BLUE,PURPLE
}第二题
案例：
1、声明月份枚举类Month：
（1）创建：1-12月常量对象
（2）声明两个属性：value（月份值，例如：JANUARY的value为1），
description（描述，例如：JANUARY的description为1月份是一年的开始）。
（3）声明一个有参构造，创建12个对象
（4） 声明一个方法：public static Month getByValue(int value)
（5）重写toString()：返回对象信息，例如：1->JANUARY->1月份是一年的开始。
2、在测试类中，从键盘输入1个1-12的月份值，获取对应的月份对象，并打印对象
package com.atguigu.test02;
import java.util.Scanner;
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入月份值（1-12）：");
int m = input.nextInt();
Month month = Month.getByValue(m);
System.out.println(month);
input.close();
}
}
enum Month{
JANUARY(1,"1月份是一年的开始"),
FEBRUARY(2,"2月份是一年中最短的一个月"),
MARCH(3,"3月春暖花开"),
APRIL(4,"4月阳光明媚"),
MAY(5,"5月清凉初夏"),
JUNE(6,"6月骄阳似火"),
JULY(7,"7月下半年的第一个月"),
AUGUST(8,"8月人已晒干"),
SEPTEMBER(9,"秋风送爽"),
OCTOBER(10,"10月全国同欢"),
NOVEMBER(11,"11月寻找秋裤"),
DECMEBER(12,"12月冰天雪地");
private int value;
private String description;
private Month(int value,String description){
this.value = value;
this.description = description;
}
public static Month getByValue(int value){
return Month.values()[value-1];
}
public String toString(){
return value + "->" + name() + "->" + description;
}
}第三题
案例：
1、声明可支付接口Payable：
包含抽象方法：void pay();
2、声明支付枚举类Payment：
（1）创建常量对象：支付宝（ALIPAY），微信（WECHAT），信用卡（CREDIT_CARD），储蓄卡（DEPOSIT_CARD）
（2）枚举类Payment实现接口Payable
①支付宝/微信：对接口的实现是打印“扫码支付”
②信用卡/储蓄卡：对接口的实现是打印“输入卡号支付”
3、在测试类中，获取所有支付对象，并调用它们的pay()
package com.atguigu.test03;
public class Test03 {
public static void main(String[] args) {
Payment[] values = Payment.values();
for (int i = 0; i < values.length; i++) {
values[i].pay();
}
}
}
interface Payable{
void pay();
}
enum Payment implements Payable{
ALIPAY{
@Override
public void pay() {
System.out.println("扫码支付");
}
},WECHAT{
@Override
public void pay() {
System.out.println("扫码支付");
}
},CREDIT_CARD,DEPOSIT_CARD;
@Override
public void pay() {
System.out.println("输入卡号支付");
}
}
第十一章
代码阅读题
第一题
interface A{
int x = 0;
}
class B{
int x = 1;
}
class C extends B implements A{
public void printX(){
System.out.println(x);
}
public static void main(String[] args) {
new C().printX();
}
}
//编译不通过，因为在C类中x有歧义。
interface A{
int x = 0;
}
class B{
int x = 1;
}
class C extends B implements A{
public void printX(){
// System.out.println(x);//有歧义，要么写super.x，要么写A.x
}
public static void main(String[] args) {
new C().printX();
}
}第二题
public class Test10 {
public static void main(String[] args) {
Out.In in = new Out().new In();
in.print();
}
}
class Out {
private int age = 12;
class In {
private int age = 13;
public void print() {
int age = 14;
System.out.println("局部变量：" + age);//14
System.out.println("内部类变量：" + this.age);//13
System.out.println("外部类变量：" + Out.this.age);//12
}
}
}
//因为我们要创建内部类In对象时，需要外部类的对象。Out.this就表示哪个外部类对象。第三题
package com.atguigu.test11;
public class Test11 {
public static void main(String[] args) {
Out out = new Out();
out.Print(3);
}
}
class Out {
private int age = 12;
public void Print(final int x) {
class In {
public void inPrint() {
System.out.println(x);//3
System.out.println(age);//12
}
}
new In().inPrint();
}
}注解编程题
第四题
案例：
1、编写图形工具类：ShapTools
（1）声明方法1：public static void printRectangle()，打印5行5列*组成的矩形图形
（2）声明方法2：public static void printRectangle(int line, int column, String sign)，打印line行column列由sign组成的矩形图形
（3）给这个类加上文档注释：包含@author，@param等
（4）给方法1标记已过时注解
2、编写测试类Test04
在测试类中调用上面的两个方法测试，如果有警告，就在main方法上抑制警告
package com.atguigu.test04;
public class Test04 {
public static void main(String[] args) {
ShapTools.printRectangle();
ShapTools.printRectangle(3, 10, "#");
}
}
class ShapTools{
@Deprecated
public static void printRectangle(){
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
System.out.print("*");
}
System.out.println();
}
}
public static void printRectangle(int line, int column, String sign){
for (int i = 0; i < line; i++) {
for (int j = 0; j < column; j++) {
System.out.print(sign);
}
System.out.println();
}
}
}
第五题
案例：
1、声明自定义注解@Table
（1）加上String类型的配置参数value
（2）并限定@Table的使用位置为类上
（3）并指定生命周期为“运行时”
2、声明自定义注解@Column
（1）加上String类型的配置参数name，表示表格的列名
（2）加上String类型的配置参数type，表示表格的列数据类型
（3）并限定@Column的使用位置在属性上
（4）并指定生命周期为“运行时”
3、声明User类，
（1）属性：id, username, password, email
（2）在User类上，标记@Table注解，并为value赋值为"t_user"
（3）在User类的每一个属性上标记@Column，并为name和type赋值，例如：
id：name赋值为no，type赋值为int
username：name赋值为username，type赋值为varchar(20)
password：name赋值为pwd，type赋值为char(6)
email：name赋值为email，type赋值为varchar(50)
package com.atguigu.test05;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
String value();
}
package com.atguigu.test05;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
String name();
String type();
}
package com.atguigu.test05;
@Table("t_user")
public class User {
@Column(name="no",type="int")
private int id;
@Column(name="username",type="varchar(20)")
private String username;
@Column(name="pwd",type="char(6)")
private String password;
@Column(name="email",type="varchar(50)")
private String email;
public User(int id, String username, String password, String email) {
super();
this.id = id;
this.username = username;
this.password = password;
this.email = email;
}
public User() {
super();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "User [id=" + id + ", username=" + username + ", password=" + password + ", email=" + email + "]";
}
}内部类编程代码题
第六题
编写一个匿名内部类，它继承Object，并在匿名内部类中，声明一个方法public void test()打印尚硅谷。
请编写代码调用这个方法。
package com.atguigu.test06;
public class Test06 {
public static void main(String[] args) {
new Object(){
public void test(){
System.out.println("尚硅谷");
}
}.test();
}
}
第七题
案例：将第4题，改用匿名内部类实现实现接口，来代替CompareBig和CompareColor
package com.atguigu.test07;
public class Test07 {
public static void main(String[] args) {
Worker w = new Worker();
Apple a1 = new Apple(5, "青色");
Apple a2 = new Apple(3, "红色");
w.pickApple(new CompareAble(){}, a1, a2);
w.pickApple(new CompareAble(){
@Override
public void compare(Apple a1, Apple a2) {
System.out.println("挑红的：");
if("红色".equals(a1.getColor())){
System.out.println(a1);
}
if("红色".equals(a2.getColor())){
System.out.println(a2);
}
}
}, a1, a2);
}
}
class Apple{
private double size;
private String color;
public Apple(double size, String color) {
super();
this.size = size;
this.color = color;
}
public Apple() {
super();
}
public double getSize() {
return size;
}
public void setSize(double size) {
this.size = size;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return size + "-" + color;
}
}
interface CompareAble{
default void compare(Apple a1,Apple a2){
System.out.println("默认挑大的：");
if(a1.getSize() > a2.getSize()){
System.out.println(a1);
}else{
System.out.println(a2);
}
}
}
class Worker{
public void pickApple(CompareAble c,Apple a1,Apple a2){
c.compare(a1, a2);
}
}第八题
案例：将第5题，改用匿名内部类实现接口，来代替V1Filter、V2Filter、AFilter
package com.atguigu.test08;
public class Test08 {
public static void main(String[] args) {
User[] all = new User[15];
for (int i = 0; i < all.length; i++) {
all[i] = new User(null,i+1);
}
Receptionist r1 = new Receptionist(new Filter(){
@Override
public void filterUser(User u) {
u.setType("v1");
}
});
for (int i = 0; i < 5; i++) {
r1.recept(all[i]);
}
Receptionist r2 = new Receptionist(new Filter(){
@Override
public void filterUser(User u) {
u.setType("v2");
}
});
for (int i = 5; i < 10; i++) {
r2.recept(all[i]);
}
Receptionist r3 = new Receptionist(new Filter(){
@Override
public void filterUser(User u) {
u.setType("A");
}
});
for (int i = 10; i < 15; i++) {
r3.recept(all[i]);
}
for (int i = 0; i < all.length; i++) {
System.out.println(all[i]);
}
}
}
class User{
private String type;
private int id;
public User(String type, int id) {
super();
this.type = type;
this.id = id;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return id + "-" + type;
}
}
interface Filter{
void filterUser(User u);
}
class Receptionist{
private Filter filter;
public Receptionist(Filter filter) {
super();
this.filter = filter;
}
public Filter getFilter() {
return filter;
}
public void setFilter(Filter filter) {
this.filter = filter;
}
public void recept(User u){
if(u.getType() != null){
return ;
}
filter.filterUser(u);
}
}第九题
案例：
1、声明一个接口：Selector，包含抽象方法：
（1）boolean hasNext()
（2）Object next()
2、声明一个接口：Touchable，包含抽象方法：
（1）Selector select()
3、声明一个MyArrayList类，当做容器类使用，模拟动态数组数据结构的容器
（1）包含私有属性：
①Object[] all；用于保存对象，初始化长度为2
②int total；记录实际存储的对象个数
（2）包含方法：
①public void add(Object element)：用于添加一个元素到当前容器中，如果数组all已满，就扩容为原来的2倍
②public void remove(int index)：如果index<0或index>=total就打印“没有这个元素”并返回，否则删除index位置的元素
③public void set(int index, Object value)：如果index<0或index>=total就打印“没有这个元素”并返回，否则就替换index位置的元素为value
④public Object get(int index)：如果index<0或index>=total就打印“没有这个元素”并返回null，否则返回index位置的元素
⑤让类MyArrayList实现Touchable接口，并重写Selector select()方法，返回内部类MySelector的对象
⑥在类MyArrayList中声明private的内部类MySelector，实现Selector接口
A：在内部类MySelector声明一个属性：int cursor（游标）
B：MySelector实现Selector接口，并重写两个抽象方法，其中
boolean hasNext()实现为：return cursor != total
Object next()实现为：return all[cursor++]
4、在测试类Test06_01中，
（1）创建MyArrayList的对象list
（2）调用list的add方法，添加3个对象
（3）调用list的remove方法，删除[1]的对象
（4）调用list的set方法，替换[1]的对象
（5）调用list的get方法，获取[1]的对象
（6）调用list的select方法，获取Selector的对象，并调用hasNext()和next()遍历容器中所有的对象
5、在测试类Test06_02中，
（1）声明静态的MyArrayList类型的list类变量，
（2）声明public static void init()方法，
①在方法中创建MyArrayList类型对象，
②并调用list的add()方法，添加3个对象，
③并在init()方法上标记JUnit4的@BeforeClass注解
（3）声明public void before()方法，
①打印“该测试方法开始前list中的数据如下："
②调用list的select方法，获取Selector的对象，并调用hasNext()和next()遍历容器中所有的对象
③并在before()方法上标记JUnit4的@Before的注解
（4）声明public void after()方法，
①打印“该测试方法结束后list中的数据如下："
②调用list的select方法，获取Selector的对象，并调用hasNext()和next()遍历容器中所有的对象
③并在after()方法上标记JUnit4的@After的注解
（5）声明public void testAdd()方法，
①在方法中，打印“现在测试的是testAdd()方法"
②在方法中，再次调用list的add()方法往list容器对象中添加1个对象
③并在testAdd()方法上标记JUnit4的@Test的注解
（6）声明public void testRemove()方法，
①在方法中，打印“现在测试的是testRemove()方法"
②调用list的remove方法，删除[1]的对象
③并在testRemove()方法上标记JUnit4的@Test的注解
（7）声明public void testSet()方法
①在方法中，打印“现在测试的是testSet()方法"
②调用list的set方法，替换[1]的对象
③并在testSet()方法上标记JUnit4的@Test的注解
（8）声明public void testGet()方法
①在方法中，打印“现在测试的是testGet()方法"
②调用list的get方法，获取[1]的对象，并打印
③并在testGet()方法上标记JUnit4的@Test的注解
package com.atguigu.test06;
public interface Selector {
boolean hasNext();
Object next();
}
package com.atguigu.test06;
public interface Touchable {
Selector select();
}
package com.atguigu.test06;
import java.util.Arrays;
public class MyArrayList implements Touchable{
private Object[] all = new Object[2];
private int total;
public void add(Object element){
if(total>=all.length){
all = Arrays.copyOf(all, all.length*2);
}
all[total++] = element;
}
public void remove(int index){
if(index < 0 || index >= total){
System.out.println("没有这个元素");
return;
}
System.arraycopy(all, index+1, all, index, total-index-1);
all[--total]=null;
}
public void set(int index, Object value){
if(index < 0 || index >= total){
System.out.println("没有这个元素");
return;
}
all[index] = value;
}
public Object get(int index){
if(index < 0 || index >= total){
System.out.println("没有这个元素");
return null;
}
return all[index];
}
@Override
public Selector select() {
return new MySelector();
}
private class MySelector implements Selector{
private int cursor;
@Override
public boolean hasNext() {
return cursor != total;
}
@Override
public Object next() {
return all[cursor++];
}
}
}
package com.atguigu.test06;
public class Test06_01 {
public static void main(String[] args) {
MyArrayList list = new MyArrayList();
//---add()---
list.add("张三");
list.add("李四");
list.add("王五");
//---remove()---
list.remove(1);
//---set()---
list.set(1,"赵六");
//---get()---
Object obj = list.get(1);
System.out.println("[1] = " + obj);
//---select()---
Selector select = list.select();
while(select.hasNext()){
Object next = select.next();
System.out.println(next);
}
}
}
package com.atguigu.test06;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
public class Test06_02 {
private static MyArrayList list;
@BeforeClass
public static void init(){
list = new MyArrayList();
list.add("张三");
list.add("李四");
list.add("王五");
}
@Before
public void before(){
System.out.println("该测试方法开始前list中的数据如下：");
Selector select = list.select();
while(select.hasNext()){
Object next = select.next();
System.out.println(next);
}
}
@After
public void after(){
System.out.println("该测试方法结束后list中的数据如下：");
Selector select = list.select();
while(select.hasNext()){
Object next = select.next();
System.out.println(next);
}
}
@Test
public void testAdd(){
System.out.println("现在测试的是testAdd()方法");
list.add("柴林燕");
}
@Test
public void testRemove(){
System.out.println("现在测试的是testRemove()方法");
list.remove(1);
}
@Test
public void testSet(){
System.out.println("现在测试的是testSet()方法");
list.set(1,"赵六");
}
@Test
public void testGet(){
System.out.println("现在测试的是testGet()方法");
Object object = list.get(1);
System.out.println(object);
}
}第十二章
代码阅读题
第一题
public static void main(String[] args) {
int test = test(3,5);
System.out.println(test);//8
}
public static int test(int x, int y){
int result = x;
try{
if(x<0 || y<0){
return 0;
}
result = x + y;
return result;//(1)先把result的值8放到操作数栈中，（2）然后走finally（3）结束当前方法
}finally{
result = x - y;//这个result=-2的值，不会放到操作数栈中，因为没有return
}
}
/*
* （1）finally块中的代码是无论try中是否发生异常，也无论catch是否可以捕获异常，
* 也不管try和catch中是否有return语句，都会执行的部分
* （2）如果finally中有return语句，那么try...catch...finally结构
* 一定从finally中的return回去
* （3）如果finally中没有return语句，那么try...catch...finally结构
* 才会从try或catch中的return回去，但是finally值中代码不会影响最终的返回值
*/第二题
public class Test02 {
public static void main(String[] args) {
try{
return;
}finally{
System.out.println("finally");
}
}
}
/*
* finally块中的代码是无论try中是否发生异常，也无论catch是否可以捕获异常，
* 也不管try和catch中是否有return语句，都会执行的部分
*/第三题
public class Test03 {
{
System.out.println("a");
}
static{
System.out.println("b");
}
Test03(){
System.out.println("c");
}
public static String getOut(){
try{
return "1";
}catch(Exception e){
return "2";
}finally{
return "3";
}
}
public static void main(String[] args) {
System.out.println(getOut());
}
}
/*
* （1）main()执行之前，需要先完成所在类的初始化
* （2）类初始化由两部分代码组成：①静态变量的显式赋值代码②静态代码块
* （3）没有创建对象，不会执行实例初始化相关的代码
* （4）finally块中的代码是无论try中是否发生异常，也无论catch是否可以捕获异常，
* 也不管try和catch中是否有return语句，都会执行的部分
* （5）如果finally中有return语句，那么try...catch...finally结构
* 一定从finally中的return回去
*/第四题
public class Test04 {
static int i = 0;
public static void main(String[] args) {
System.out.println(test());
}
public static int test(){
try{
return ++i;//(1)先自增（2）把i的值放到操作数栈（3）走finally
}finally{
return ++i;//(4)再自增（5）又取i的值放到操作数栈（4）结束方法
}
}
}
/*
* （1）finally块中的代码是无论try中是否发生异常，也无论catch是否可以捕获异常，
* 也不管try和catch中是否有return语句，都会执行的部分
* （2）如果finally中有return语句，那么try...catch...finally结构
* 一定从finally中的return回去，但是try和catch中的return语句中返回值的表达式会执行。
* （3）如果finally中没有return语句，那么try...catch...finally结构
* 才会从try或catch中的return回去，但是finally值中代码不会影响最终的返回值
*/第五题
import java.io.IOException;
public class Test05 {
public static void main(String[] args) {
int a = -1;
try{
if(a>0){
throw new RuntimeException("");
}else if(a<0){
throw new IOException("");
}else{
return ;
}
}catch(IOException ioe){
System.out.println("IOException");
}catch(Throwable e){
System.out.println("Throwable");
}finally{
System.out.println("finally");
}
}
}
/*
* （1）throw用于手动抛出异常
* （2）无论是JVM抛出的异常还是throw抛出的异常都需要catch处理
* （3）catch是多分支结构，从上到下按顺序匹配，只会进入第一个匹配上的catch分支
* （4）finally块中的代码是无论try中是否发生异常，也无论catch是否可以捕获异常，
* 也不管try和catch中是否有return语句，都会执行的部分
*/第六题
public class Test06 {
public static int fun(){
int result = 5;
try{
result = result / 0;
return result;
}catch(Exception e){
System.out.println("Exception");
result = -1;
return result;//(1)先把-1放到操作数栈（2）走finally（3）结束
}finally{
result = 10;
System.out.println("I am in finally.");
}
}
public static void main(String[] args) {
int x = fun();
System.out.println(x);
}
}
/*
* （1）finally块中的代码是无论try中是否发生异常，也无论catch是否可以捕获异常，
* 也不管try和catch中是否有return语句，都会执行的部分
* （2）如果finally中有return语句，那么try...catch...finally结构
* 一定从finally中的return回去
* （3）如果finally中没有return语句，那么try...catch...finally结构
* 才会从try或catch中的return回去，但是finally值中代码不会影响最终的返回值
*/第七题
public static int aMethod(int i)throws Exception{
try{
return i / 10;
}catch(Exception ex){
throw new Exception("exception in aMethod");
}finally{
System.out.println("finally");
}
}
public static void main(String[] args) {
try {
aMethod(0);
} catch (Exception e) {
System.out.println("exception in main");
}
}
/*
* （1）finally块中的代码是无论try中是否发生异常，也无论catch是否可以捕获异常，
* 也不管try和catch中是否有return语句，都会执行的部分
* （2）throw用于手动抛出异常
* （3）throws用于将异常抛给调用者处理
*/代码编程题
第八题
案例：
在一款角色扮演游戏中,每一个人都会有名字和生命值，角色的生命值不能为负数。
要求：当一个人物的生命值为负数的时候需要抛出自定的异常
操作步骤描述：
（1）自定义异常类NoLifeValueException继承RuntimeException
①提供空参和有参构造
②在有参构造中，需要调用父类的有参构造，把异常信息传入
（2）定义Person类
①属性：名称(name)和生命值(lifeValue)
②提供空参构造
③提供有参构造：使用setXxx方法给name和lifeValue赋值
④提供setter和getter方法：
在setLifeValue(int lifeValue)方法中，首先判断，如果 lifeValue为负数,就抛出NoLifeValueException，异常信息为：生命值不能为负数：xx；
然后在给成员lifeValue赋值。
（3）定义测试类Test08
①使用满参构造方法创建Person对象，生命值传入一个负数
由于一旦遇到异常,后面的代码的将不在执行,所以需要注释掉上面的代码
②使用空参构造创建Person对象
调用setLifeValue(int lifeValue)方法,传入一个正数,运行程序
调用setLifeValue(int lifeValue)方法,传入一个负数,运行程序
③分别对①和②处理异常和不处理异常进行运行看效果
package com.atguigu.test08;
public class NoLifeValueException extends RuntimeException{
public NoLifeValueException() {
super();
}
public NoLifeValueException(String message) {
super(message);
}
}
package com.atguigu.test08;
public class Person {
private String name;
private int lifeValue;
public Person() {
super();
}
public Person(String name, int lifeValue) {
super();
setName(name);
setLifeValue(lifeValue);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getLifeValue() {
return lifeValue;
}
public void setLifeValue(int lifeValue) {
if(lifeValue<0){
throw new NoLifeValueException("生命值不能为负数：" + lifeValue);
}
this.lifeValue = lifeValue;
}
}
package com.atguigu.test08;
public class Test08 {
public static void main(String[] args) {
try {
Person p = new Person("白蛇",-1);
} catch (Exception e) {
e.printStackTrace();
}
try {
Person p2 = new Person();
p2.setLifeValue(10);
p2.setLifeValue(-10);
} catch (Exception e) {
e.printStackTrace();
}
}
}
第九题
请编写代码演示OOM错误
package com.atguigu.test09;
public class Test09_01 {
public static void main(String[] args) {
int[] arr = new int[Integer.MAX_VALUE];
}
}
package com.atguigu.test09;
import java.util.ArrayList;
/*
设置JVM参数
-verbose:gc
-Xms20M
-Xmx20M
-Xmn10M
-XX:+PrintGCDetails
-XX:SurvivorRatio=8
其中：
Xms:最小堆
Xmx:最大堆
Xmn:新生代的大小
PrintGCDetails：打印GC日志
SurvivorRatio：Eden区和Survivor比例
*/
public class Test09_02 {
public static void main(String[] args) {
ArrayList list=new ArrayList();
//通过不断的创建对象达到OOM
while (true){
list.add(new Object());
}
}
}
选择题
第十题
BC throws的异常类型要>=方法中抛出的异常类型 【修饰符】 返回值类型 方法名(【形参列表】)throws 异常列表{ }
第十一题
catch是多分支结构，从上到下按顺序匹配，只会进入第一个匹配上的catch分支
简答题
问题：
请描述异常的继承体系
请描述你对错误(Error)的理解
请描述你对异常(Expection的理解)
请描述你对运行时异常(RuntimeException)的理解
throw与throws的区别
异常处理方式有几种,分别是什么?详细阐述每种方式对异常是如何处理的
请列举常见异常，并说明产生原因。
6503
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
