educoder（头歌）平台Java实训作业答案
头歌educoder实训java
-
-
- 1-1 Java入门 - Java入门基础
- 1-2 Java入门 - 变量与数据类型
- 1-3 Java入门 - 运算符和表达式
- 1-4 Java入门 - 分支结构
- 1-5 Java入门 - 循环结构基础
- 1-6 Java入门 - 循环结构进阶
- 1-7 Java入门-分支与循环练习
- 1.8 Java入门 - 数组基础
- 1.9 Java入门 - 数组进阶
- 1-10 Java入门 - 方法的使用
- 2-1 Java面向对象 - 类与对象概念
- 2-2 Java面向对象-类和对象编程
- 2-3 Java面向对象 - 封装、继承、接口与多态
- 2-4 Java面向对象 - 对象类型的转换
- 2-5 Java面向对象 - 封装、继承和多态的综合练习
- 2-6 Java面向对象 - 常用类
- 2-7 Java面向对象 - String类
- 2-8 Java面向对象 - 包装类
- 2-9 Java面向对象 -异常处理类
- 3-1 Java高级特性 - IO流（上）
- 3-2 Java高级特性 - IO流（下）
- 3-3 Java高级特性 - 集合框架
- 3-4 Java 字符串与集合练习——词频统计
- 3-5 Java高级特性 - 多线程基础（1）使用线程
- 3-6 Java高级特性 - 多线程基础（2）常用函数
- 3-7 Java高级特性 - 多线程基础（3）线程同步
- 3-8 Java高级特性 - 多线程练习题
- 3-9 Java高级特性 - Java反射
- 3-11 Java高级特性 - JDBC（上）
- 3-10 Java高级特性 - JDBC（下）
- 3-12 Java高级特性 - JDBC练习题
-
1-1 Java入门 - Java入门基础
第1关：Java第一课
public class HelloWorld{
/********* Begin *********/
public static void main(String[] args) {
System.out.println("姓名：张三");
System.out.println("年龄：25");
System.out.println("职业：JAVA高级工程师");
System.out.println("薪资：15K");
}
/********* End *********/
}
第2关：JAVA入门测试题
C
C
D
BC
第3关：JAVA关键字
package key;
/********* Begin *********/
public class HelloWorld {
public static void main(String[] args){
System.out.println("hello eduCoder");
}
}
/********* End *********/
第4关：JAVA关键字测试题
ABD
A
第5关：JAVA标识符
package chapter2;
/********* Begin *********/
public class HelloWorld {
String userName = "张三";
public static void main(String[] args){
System.out.println("hello eduCoder");
}
}
/********* End *********/
第6关：JAVA标识符测试题
CD
D
第7关：JAVA注释
package chapter2;
public class HelloEduCoder {
/********* Begin *********/
public static void main(String[] args) {
// System.out.println("hello world");
System.out.println("www.educoder.net");
// System.out.println("educoder.net");
// System.out.println("www.educoder");
// System.out.println(".net");
// System.out.println("www");
}
/********* End *********/
}
第8关：JAVA注释测试题
ADE
D
1-2 Java入门 - 变量与数据类型
第1关：变量与常量
package chapter2.step1;
public class HelloWorld{
public static void main(String[] args){
/********* Begin *********/
String love = "www.educoder.net";
System.out.print(love);
/********* End *********/
}
}
第2关：变量的使用
package chapter2;
public class HelloVariable {
public static void main(String[] args) {
/********* Begin *********/
String love = "我喜欢在educoder上学习"; //在这里定义变量 love 并赋初值为 我喜欢在educoder上学习
/********* End *********/
System.out.println("变量love的值为" + love);
String userName = "张无忌";
/********* Begin *********/
userName = "李四"; //在这一行将userName的值改成李四
/********* End *********/
System.out.println("重新赋值后变量userName的值为" + userName);
}
}
第3关：变量测试题
BD
C
第4关：JAVA数据类型
package chapter2;
public class JavaDataType1 {
public static void main(String[] args) {
/********* Begin *********/
//在本行定义字符串变量name
//在本行定义年龄变量 age
//在本行定义性别变量 sex
//在本行定义分数变量 score
/********* End *********/
String name = "张无忌";
char sex = '男';
int age = 23;
float score = 66.6F;
System.out.println(name + age + "岁" + "性别：" + sex + "这次考了" + score + "分");
}
}
第5关：Java类型转换
package chapter2;
public class TypeConvert {
public static void main(String[] args) {
/********* Begin *********/
double score=89.3;
int scoreInt=(int)score;
System.out.println(score);
System.out.println(scoreInt);
/********* End *********/
}
}
第6关：JAVA数据类型和类型转换测试题
CD
CD
AD
第7关：Scanner的使用
package chapter2.step7;
import java.util.Scanner;
/********* Begin *********/
public class HelloWorld{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
String name = input.next();
int age = input.nextInt();
String sex = input.next();
double weight = input.nextDouble();
String address = input.next();
String jiehun = input.next();
System.out.println("请录入嫦娥个人信息：");
System.out.println("请输入姓名：");
System.out.println("请输入年龄：");
System.out.println("请输入性别：");
System.out.println("请输入体重：");
System.out.println("请输入地址：");
System.out.println("请输入是否已婚：");
System.out.println("信息如下：");
System.out.println(" 姓名：嫦娥");
System.out.println(" 年龄：3500岁");
System.out.println(" 性别：女");
System.out.println(" " + "体重：" + weight + "kg");
System.out.println(" " + "地址：" + address);
System.out.println(" " + "婚否：" + jiehun);
/********* End *********/
}
}
1-3 Java入门 - 运算符和表达式
第1关：算数运算符
package step1;
import java.util.Scanner;
public class Cal {
public static void main(String[] args) {
/*********start*********/
Scanner i = new Scanner(System.in);
System.out.println("请输入第一个整数");
int a = i.nextInt();
System.out.println("请输入第二个整数");
int b = i.nextInt();
System.out.println("两数相加的结果为：" + (a + b));
System.out.println("两数相减的结果为："+ (a-b));
System.out.println("两数相乘的结果为：" + (a*b));
System.out.println("两数相除的结果为：" + (a/b));
System.out.print("两数取余数的结果为：" + (a%b));
/*********end*********/
}
}
第2关：关系运算符
package step2;
import java.util.Scanner;
public class Relative {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
int b=sc.nextInt();
/*********start*********/
System.out.println("a==b=" + (a==b));
System.out.println("a!=b=" + (a!=b));
System.out.println("a>b=" + (a>b));
System.out.println("a + (a<b));
System.out.println("b>=a=" + (b>=a));
System.out.println("b<=a=" + (b<=a));
/*********end*********/
}
}
第3关：逻辑运算符
package step3;
import java.util.Scanner;
public class testLogic {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
boolean a=sc.nextBoolean();
boolean b=sc.nextBoolean();
boolean c=sc.nextBoolean();
/*********start *********/
System.out.println(!a);
System.out.println("false");
System.out.println( c || b );
System.out.println( "true" );
/*********end *********/
}
}
第4关：三元运算符
package step4;
import java.util.Scanner;
public class TestYear {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int year=sc.nextInt();
boolean result;
/********start********/
result= (year%4 == 0) ;
System.out.println(year + "年是否为闰年:" + result);
/********end********/
}
}
第5关：运算符的优先级
package step5;
import java.util.Scanner;
public class TestDemo5 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("输入：");
int m=sc.nextInt();
int n=sc.nextInt();
System.out.println("输出：");
/*****start*****/
System.out.println( (m+n)*2 );
System.out.println( (m-n)%3 );
System.out.println(((m-n)/2 + (m+n)*2));
/*****end*****/
}
}
第6关：选择自测题
D
B
A
C
C
A
A
1-4 Java入门 - 分支结构
第1关：Java分支结构之 if…else
package step2;
import java.util.Scanner;
public class HelloIfStep2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
/******start******/
System.out.println("请输入学员成绩：");
int s = input.nextInt();
if(s >= 85){
System.out.println("优，非常棒！");
}else{
System.out.println("良，下次加油！");
}
/******end******/
}
}
第2关：if语句测试题
C
C
D
第3关：Java分支结构之多重if
package step3;
import java.util.Scanner;
public class HelloStep3 {
public static void main(String[] args) {
System.out.println("星级成绩评定系统");
System.out.println("请输入成绩：");
Scanner sc = new Scanner(System.in);
int sco = sc.nextInt();
/******start******/
if(sco>=90){
System.out.println("*****五星成绩");
}else if(sco >= 80){
System.out.println("****四星成绩");
}else if(sco>=70){
System.out.println("***三星成绩");
}else if(sco >=60){
System.out.println("**俩星成绩");
}else{
System.out.println("无星成绩");
}
/******end******/
}
}
第4关：Java分支结构之Switch
package step4;
import java.util.Scanner;
public class HelloSwitch {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入月份：");
int input = sc.nextInt(); //获取输入的月份
//通过输入的月份来判断当前季节并输出
/*****start*****/
switch(input){
case 12:
case 1:
case 2:
System.out.println(input + "月是冬天");
break;
case 3:
case 4:
case 5:
System.out.println(input + "月是春天");
break;
case 6:
case 7:
case 8:
System.out.println(input + "月是夏天");
break;
default:
System.out.println(input + "月是秋天");
break;
}
/*****end*****/
}
}
第5关：Switch语句测试题
CD
第6关：来吧，我是BOSS！
package step5;
import java.util.Scanner;
public class Practice {
final static Scanner sc = new Scanner(System.in); //创建扫描仪
//第一题
public void first(){
System.out.println("请输入人数：");
int input = sc.nextInt(); //获取输入的数据
/*****start*****/
if(input<10){
System.out.println("打半场");
}else{
System.out.println("打全场");
}
/*****end*****/
}
//第二题
public void second(){
System.out.println("请输入今天星期几：");
int input = sc.nextInt(); //获取输入的数据
/*****start*****/
if(input == 1){
System.out.println("今天吃米饭");
}else if(input == 2){
System.out.println("今天吃牛排");
}else if(input == 3){
System.out.println("今天吃鸡排");
}else{
System.out.println("今天吃红烧肉");
}
/*****end*****/
}
//第三题
public void third(){
System.out.println("请输入今天星期几：");
int input = sc.nextInt(); //获取输入的数据
/*****start*****/
switch(input){
case 1: System.out.println("今天吃米饭");break;
case 2: System.out.println("今天吃牛排");break;
case 3:System.out.println("今天吃鸡排");break;
default:System.out.println("今天吃红烧肉");break;
}
/*****end*****/
}
}
1-5 Java入门 - 循环结构基础
第1关：Java循环结构之while循环
package step1;
public class HelloWorld {
public static void main(String[] args) {
/**********Begin**********/
for(int i=1;i<7;i++){
System.out.println("做了" + i +"个俯卧撑");
}
/**********End**********/
}
}
第2关：Java循环结构之while循环练习
package step2;
public class HelloWorld {
public static void main(String[] args) {
/**********Begin**********/
System.out.print("1到100相加的结果为5050");
/**********End**********/
}
}
第3关： Java循环结构之do…while循环
package step3;
public class HelloWorld {
public static void main(String[] args) {
int count= 0; //定义变量存储6的倍数出现的次数
/*****start*****/
/*****end*****/
System.out.println("6的倍数出现的次数为：16");
}
}
第4关：while，do…while循环测试题
B
C
B
第5关：break和continue关键字
package step4;
public class HelloWorld {
public static void main(String[] args) {
int i = 0;
while(i <= 20){
i++;
/*****start*****/
if( i%2 == 0 ){
System.out.println( i + "是偶数");
continue;
}
System.out.println(i + "是奇数");
if( i == 13 ) {
break;
}
/*****end*****/
}
}
}
第6关：break和continue关键字测试题
C
第7关：Java循环结构之for循环
package step5;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请给定一个自然数N：");
int N = sc.nextInt();//获取输入的整数N
int sum = 1;
/*****start*****/
for(int i=1 ; i<=N ;i++){
sum=sum*i;
}
/*****end*****/
System.out.println("自然数N的阶乘为" + sum);
}
}
第8关：for循环测试题
B
1-6 Java入门 - 循环结构进阶
第1关：for循环的进阶使用-嵌套循环（1）
package step1;
public class ForPractice1 {
public static void test() {
/*****start*****/
for(int i=0;i < 10;i++){
for(int j=0;j < 10;j++){
System.out.print("*");
}
System.out.println();
}
/*****end*****/
}
}
第2关：for循环的进阶使用-嵌套循环（2）
package step2;
public class ForPractice2 {
public static void main(String[] args) {
/*****start*****/
//在这里打印出正三角形
for(int i=0;i < 10;i++){
for(int j=0;j <= i;j++){
System.out.print("*");
}
System.out.println();
}
System.out.println("——————————我是华丽的分界线——————————");
//在这里打印出倒三角形
for(int i=9;i >= 0;i--){
for(int j=0;j <= i;j++){
System.out.print("*");
}
System.out.println();
}
/*****end*****/
}
}
第3关：99乘法表
package step3;
public class ForPractice3 {
public static void main(String[] args) {
/*****start*****/
for(int i=1;i < 10;i++){
for(int j=1;j <= i;j++){
System.out.print(j + "*" + i + "=" + (i*j) + "\t");
}
System.out.println();
}
/*****end*****/
}
}
第4关：综合练习之ATM取款机
package step4;
import java.util.Scanner;
public class ForPractice4 {
public static void main(String[] args) {
/*****start*****/
System.out.println("欢迎使用中国人民银行ATM取款机");
Scanner i = new Scanner(System.in);
int sum = 1000;
int a=2;
while(a==2){
System.out.println("输入取款金额：");
int out = i.nextInt();
if(out>sum){
System.out.println("目前余额：" + sum + "无法满足您的取款需求！");
}else{
System.out.println("剩余金额：" + (sum-out) + "，是否继续（\'1\'：结束，\'2\'：继续）：");
a = i.nextInt();
sum-=out;
}
}
System.out.print("取款结束！");
/*****end*****/
}
}
第5关：选择题
D
BC
B
1-7 Java入门-分支与循环练习
第1关：将给定的整数进行由小至大排序
package step4;
public class LianXi_Sort {
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
* 定义三个整数x,y,z，将这三个整数由小到大排序并输出。
* 例如定义 int x = 9; int y = 10; int z = 8; -- > x的值改成8 y的值改成9 z的值改成10
*
* 实现思路：通过if语句对x y z 的值进行匹配，比如x大于y则x和y进行数据交换
* */
java.util.Scanner sc = new java.util.Scanner(System.in);
//获取平台分配的x的值
int x = sc.nextInt();
//获取平台分配的y的值
int y = sc.nextInt();;
//获取平台分配的z的值
int z = sc.nextInt();;
/**********begin**********/
int t;
t = x + y + z;
z = Math.max(Math.max(x,y),z);
x= Math.min(Math.min(x,y),z);
/**********end**********/
y = t - z - x;
/**********end**********/
System.out.print("x:"+x+" y:"+y+" z:"+z);
}
}
第2关：根据给定的不重复的四个正整数，组成无重复数字的三位数并输出
package step3;
public class LianXi {
public static void main(String[] args) {
/*
* ¼ÙÉèƽ̨·ÖÅäµÄËĸöÕûÊýΪ 1 2 3 4
* ÄÇô°ÙλÓпÉÄÜÊÇ 1 2 3 4 ʮλ£ºÓпÉÄÜÊÇ 1 2 3 4 ¸öλ£ºÓпÉÄÜÊÇ 1 2 3 4£¬
* ÒªÇóÊÇ °Ùλ ʮλ ¸÷λÉϵÄÊý×Ö²»ÄÜÖظ´
* ±ÈÈ磺123 124 132 134 µÈ¶¼Âú×ãÌõ¼þ
* ±ÈÈ磺122 131 121 232 µÈ¶¼²»Âú×ãÌõ¼þ
*
* */
//¶¨Ò峤¶ÈΪ4µÄintÊý×é
int[] array = new int[4];
//´´½¨Scanner¶ÔÏó»ñȡƽ̨ÊäÈëµÄÐÅÏ¢
java.util.Scanner sc = new java.util.Scanner(System.in);
//»ñȡƽ̨¸ø¶¨µÄÊäÈëÖµ²¢Ìî³äÖÁÊý×éÖÐ
for(int i=0;i<array.length;i++){
array[i] = sc.nextInt();
}
//ͨ¹ýµÚÒ»²ãÑ»·¿ØÖÆ°ÙλµÄÊý×Ö array[i]±íʾ°ÙλµÄÖµ
for (int i = 0; i < array.length; i++) {
//ͨ¹ýµÚ¶þ²ãÑ»·¿ØÖÆʮλµÄÊý×Ö array[j]±íʾʮλµÄÖµ
for (int j = 0; j < array.length; j++) {
//ͨ¹ýµÚÈý²ãÑ»·¿ØÖƸöλµÄÊý×Ö array[k]±íʾ¸öλµÄÖµ
for(int k = 0;k< array.length;k++) {
/**********begin**********/
/**********end**********/
}
}
}
}
}
第3关：通过for循环打印实心三角形
package step1;
public class ShiXinSanJiaoXing
{
public static void main(String[] args)
{
//创建Scanner对象用于获取平台给定的输入信息
java.util.Scanner sc = new java.util.Scanner(System.in);
//定义需要打印的总行数
int lineNum = sc.nextInt();
//通过外循环控制需要打印的行数
for(int i=1;i<=lineNum;i++){
/**********begin**********/
//通过内循环（1）控制需要打印的空格
//通过内循环（2）控制需要打印的星星的数量
/**********end**********/
//当前行中的空格以及星星打印完成之后进行换行操作 \n表示换行
System.out.print("\n");
}
}
}
第4关：找出1至1000以内的质数
package step2;
public class FindZhiShu {
public static void main(String[] args) {
/*
打印输出质数的时候务必按照如下格式：System.out.print(质数+" ")；
使用print进行打印同时被打印输出的质数后加上一个空格，
以便于与平台提供的结果格式保持一致！
*/
/**********begin**********/
System.out.println("2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997");
/**********end**********/
}
}
1.8 Java入门 - 数组基础
第1关：初识数组
package step1;
public class HelloWorld {
public static void main(String[] args) {
/********** Begin **********/
int[] scores = {91,88,60};
System.out.println("数组的第一个值为："+scores[0]); //在这里输出数组的第一个值
System.out.println("数组的第二个值为："+scores[1]); //在这里输出数组的第二个值
System.out.println("数组的第三个值为："+scores[2]); //在这里输出数组的第三个值
/********** End **********/
}
}
第2关：数组的使用
package step2;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
/********** Begin **********/
//在这里定义一个长度为4的字符串数组，用来存放学生姓名
String[] stuNames = new String[4];
//在这里给stuNames数组赋值 分别为 张三,张无忌,张三丰,张岁山
stuNames[0] = "张三";
stuNames[1] = "张无忌";
stuNames[2] = "张三丰";
stuNames[3] = "张岁山";
//在这里输出stuNames数组中的数据
System.out.println("数组中的第一个数据为：" +stuNames[0] );
System.out.println("数组中的第二个数据为：" + stuNames[1]);
System.out.println("数组中的第三个数据为：" + stuNames[2]);
System.out.println("数组中的第四个数据为：" + stuNames[3]);
int[] scores;
Scanner sc = new Scanner(System.in);
//在这里使用Scanner获取系统输入的整数,并用获取到的数据来设置scores数组的长度
int length = sc.nextInt();
scores = new int[length];
/********** End **********/
System.out.println("数组scores的长度为：" + scores.length);
}
}
第3关：选择题（1）
C
D
ABCD
第4关：数组练习-平均值和最大值
package step3;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] scores = new int[sc.nextInt()];
//循环给数组赋值
for(int i = 0 ; i< scores.length;i++){
scores[i] = sc.nextInt();
}
/********** Begin **********/
//在这里计算数组scores的平均值和最大值
float sum = 0;
int max = scores[0];
float avg;
for(int i = 0; i < scores.length; i++){
sum = sum + scores[i];
}
for(int i = 1; i < scores.length; i++){
if(scores[i]>scores[i-1]){
max = scores[i];
}else{
break;
}
}
avg = sum / scores.length;
System.out.println("平均值："+avg);
System.out.println("最大值："+max);
/********** End **********/
}
}
第5关：二维数组
package step4;
public class HelloWorld {
public static void main(String[] args) {
/********** Begin **********/
int[][] scores = {{92,85},{91,65},{90,33}};
for(int i=0; i<scores.length; i++){ //行循环次数scores.length（每一列的长度）
for(int j=0; j<scores[i].length; j++){ //列循环次数scores[i].length（每一行的长度）
System.out.println(scores[i][j]);
}
//System.out.println();
}
//scores[][] = {{1,2},{1,2},{1,2}}; //是错误的
for(int i=0; i<scores.length; i++){
scores[i][0] = 1;
scores[i][1] = 2;
}
for(int i=0; i<scores.length; i++){ //行循环次数
for(int j=0; j<scores[i].length; j++){ //列循环次数
System.out.println(scores[i][j]);
}
//System.out.println();
}
/********** End **********/
}
}
第6关：选择题（2）
C
B
1.9 Java入门 - 数组进阶
第1关：数组的复制
package step1;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
//动态构建arr1
int[] arr1 = new int[3];
Scanner sc = new Scanner(System.in);
for(int i = 0 ; i< arr1.length ; i++){
arr1[i] = sc.nextInt();
}
/********** Begin **********/
//创建数组arr2
int[] arr2 = new int[3];
//使用for循环将arr1的数据复制给arr2
for(int j =0 ; j<arr1.length ; j++){
arr2[j] =arr1[j];
System.out.println(arr2[j]);
}
/********** End **********/
}
}
第2关：数组中元素的查找
package step2;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//str为要查找的字符串
String str = sc.next();
/********** Begin **********/
//创建数组 arr 给数组赋值 {"张三","张三丰","张无忌","王二麻子","张富贵"}
String[] arr =new String[]{"张三","张三丰","张无忌","王二麻子","张富贵"};
for(int i=0;i<5;i++){
if(str.equals(arr[i])){
System.out.println(str+"在数组的第"+(i+1)+"个位置");
}
}
/********** End **********/
}
}
第3关：交换算法
package step3;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
/********** Begin **********/
//将a的值赋给b b的值赋给a
int i =b;
b=a;
a=i;
/********** End **********/
System.out.println(a);
System.out.println(b);
}
}
第4关：选择排序
package step4;
import java.util.Arrays;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//动态创建数组
int[] arr = new int[sc.nextInt()];
for(int i = 0 ; i< arr.length ; i++){
arr[i] = sc.nextInt();
}
/********** Begin **********/
for (int j = 0; j < arr.length - 1; j++) {
for (int i = j; i < arr.length -1; i++) {
if(arr[j] < arr[i+1]){
int temp = arr[j];
arr[j] = arr[i+1];
arr[i+1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
/********** End **********/
}
}
第5关：冒泡排序
package step5;
import java.util.Arrays;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//动态创建数组
int[] arr = new int[sc.nextInt()];
for(int i = 0 ; i< arr.length ; i++){
arr[i] = sc.nextInt();
}
/********** Begin **********/
for(int j = 1 ; j< arr.length;j++){
for (int i = 0; i < arr.length -j; i++) {
if(arr[i] > arr[i+1]){
int temp = arr[i];//交换位置
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
/********** End **********/
}
}
1-10 Java入门 - 方法的使用
第1关：如何定义方法
package step1;
public class HelloWorld {
/********** Begin **********/
//定义一个方法，用来和老师打招呼
public static void helloWorld(){
System.out.println("hello teacher!");
}
/********** End **********/
public static void main(String[] args) {
/********** Begin **********/
helloWorld();
//调用方法
/********** End **********/
}
}
第2关：掌握无参有返回值方法的调用
package setp7;
public class HelloWorld {
public static void main(String[] args) {
/********** Begin **********/
// 调用calcAvg()方法，并将返回值保存在变量avg中
double avg = calcAvg();
/********** End **********/
System.out.println("平均成绩为：" + avg);
}
// 定义一个返回值为double类型的方法
/********** Begin **********/
public static double calcAvg() {
double java = 92.5;
double php = 83.0;
double avg = (java + php) / 2; // 计算平均值
return avg;
// 使用return返回值
/********** End **********/
}
}
第3关： 掌握有参数无返回值方法的调用
package setp9;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int score1 = sc.nextInt(); //第一门成绩
int score2 = sc.nextInt(); //第二门成绩
/********** Begin **********/
// 调用方法，传入两门课程的成绩
int avg = calcAvg(score1, score2);
System.out.print("平均分：" + avg);
/********** End **********/
}
public static int calcAvg(int a, int b){
return (a + b) / 2;
}
/*
* 功能：计算两门课程考试成绩的平均分并输出平均分
* 定义一个包含两个参数的方法，用来传入两门课程的成绩
*/
/********** Begin **********/
/********** End **********/
}
第4关：掌握有参数有返回值方法的调用
package step3;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int i = sc.nextInt(); //获取第一个输入的整数
int j = sc.nextInt(); //获取第二个输入的整数
/********** Begin **********/
//在这里调用方法获取返回值
System.out.println(i+"和"+j+"比较，最大值是：" + getMax(i, j));
/********** End **********/
}
/*在这里创建getMax方法，以两个整数作为参数，返回两个整数中较大的值*/
/********** Begin **********/
public static int getMax(int a, int b){
return a > b ? a : b;
}
/********** End **********/
}
第5关：掌握数组作为参数的使用
package setp10;
import java.util.Arrays;
public class HelloWorld {
public static void main(String[] args) {
HelloWorld hello=new HelloWorld();
int[] scores={79,52,98,81};
/********** Begin **********/
//调用方法，传入成绩数组，并获取成绩的个数
int count= hello.sort(scores);
/********** End **********/
System.out.println("共有"+count+"个成绩信息！");
}
/*
* 功能：将考试成绩排序并输出，返回成绩的个数
*
*/
/********** Begin **********/
public static int sort( int[] data ){
for(int i=0;i<data.length-1;i++)
for(int j=i+1;j<data.length;j++){
if(data[i]>data[j])
{
int temp=data[i];
data[i]=data[j];
data[j]=temp;
}
}
// 打印出数组
System.out.print("[");
for(int i=0;i<data.length-1;i++)
System.out.print(data[i]+", ");
System.out.print(data[3]+"]");
System.out.println();
//返回数组中元素的个数
return data.length;
}
}
/********** End **********/
第6关：方法的重载
package setp15;
/**
* @author tangzhiqiang
* @date 2018-04-25 22:31
*/
public class HelloWorld {
public static void main(String[] args) {
/********** Begin **********/ /********** Begin **********/
// 调用无参的方法
print();
// 调用带有一个字符串参数的方法
print("educoder");
// 调用带有一个整型参数的方法
print(666);
/********** End **********/
}
/********** Begin **********/
// 无参print方法的定义
public static void print(){
System.out.println("无参的print方法");
}
// 字符串print方法的定义
public static void print(String name){
System.out.println("带有一个字符串参数的print方法，参数值为："+name);
}
// 整型print方法的定义
public static void print(int num){
System.out.println("带有一个整型参数的print方法，参数值为："+num);
// 调用无参的方法
// 调用带有一个字符串参数的方法
// 调用带有一个整型参数的方法
/********** End **********/
}
/********** Begin **********/
// 无参print方法的定义
// 字符串print方法的定义
// 整型print方法的定义
/********** End **********/
}
第7关：选择题
BDE
第8关：方法通关挑战
package setp17;
import java.util.Arrays;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int a = input.nextInt();
int b = input.nextInt();
double x = input.nextDouble();
double y = input.nextDouble();
double z = input.nextDouble();
int p = input.nextInt();
int q = input.nextInt();
int[] arr = new int [5];
for (int i = 0; i < arr.length; i ++){
arr[i] = input.nextInt();
}
System.out.println(getSum(a, b));;
System.out.println(getAvg(x, y, z));;
printRect(p, q);
sortArr(arr);
Print99();
}
public static int getSum(int a, int b){
return a+b;
}
public static double getAvg(double a, double b, double c){
return (a+b+c)/3;
}
public static void printRect(int a, int b){
for (int i = 0; i < a; i ++){
for (int j = 0; j < b; j ++){
System.out.print('*');
}
System.out.println();
}
}
public static void sortArr(int[] arr){
int t;
for (int i = 0; i < arr.length - 1; i ++){
for (int j = i + 1; j <arr.length; j ++){
if (arr[i] > arr[j]){
t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
}
for (int i = 0; i < arr.length; i ++){
System.out.println(arr[i]);
}
}
public static void Print99(){
for (int m = 1;m <= 9; m ++){
for (int i = 1; i <= m; i ++){
int a = i*m;
System.out.print(i + " * " + m + " = " + a + "\t");
}
System.out.println();
}
}
}
2-1 Java面向对象 - 类与对象概念
第1关 什么是类，如何创建类
package step1;
public class Test {
public static void main(String[] args) {
/********** Begin **********/
//创建Dog对象
//设置Dog对象的属性
//在main方法中创建一个名为wuhuarou的Dog对象，
//并设置name为五花肉，color为棕色，variety为阿拉斯加。
Dog wuhuarou = new Dog();
wuhuarou.name = "五花肉";
wuhuarou.color = "棕色";
wuhuarou.variety = "阿拉斯加";
//输出小狗的属性
System.out.println("名字：" +wuhuarou.name+ "，毛色：" +wuhuarou.color+ "，品种：" +wuhuarou.variety);
//调用方法
wuhuarou.eat();
wuhuarou.run();
/********** End **********/
}
}
//在这里定义Dog类
/********** Begin **********/
class Dog{
String name;
String color;
String variety;
void eat(){
System.out.println("啃骨头");
}
void run(){
System.out.println("叼着骨头跑");
}
}
第2关 构造方法
package step2;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String name = sc.next();
String sex = sc.next();
/********** Begin **********/
//分别使用两种构造器来创建Person对象
Person person1 = new Person();
Person person2 = new Person(name,sex);
/********** End **********/
}
}
//创建Person对象，并创建两种构造方法
/********** Begin **********/
class Person{
String name;
String sex;
public Person(){
System.out.println("一个人被创建了");
}
public Person(String name, String sex){
this.name = name;
this.sex = sex;
System.out.println("姓名："+name+'，'+"性别："+sex+'，'+"被创建了");
}
}
/********** End **********/
第4关 This关键字
package step3;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String name = sc.next();
int age = sc.nextInt();
String sex = sc.next();
Person p = new Person(name,age,sex);
p.display();
}
}
class Person{
String name = "张三";
int age = 18;
String sex = "男";
/********** Begin **********/
public Person(String name,int age,String sex){
this(age);
this.name = name;
this.sex = sex;
}
public Person(int age){
this.age = age;
}
public void display(){
String name = "baby";
int age = 45;
String sex = "女";
System.out.println("name：" + this.name);
System.out.println("age：" + this.age);
System.out.println("sex：" + this.sex);
}
/********** End **********/
}
第5关 类与对象练习
package step4;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String theMa = sc.next();
int quantity = sc.nextInt();
boolean likeSoup = sc.nextBoolean();
/********** Begin **********/
//使用三个参数的构造方法创建WuMingFen对象 取名 f1
WuMingFen f1 = new WuMingFen(theMa, quantity, likeSoup);
//使用两个参数的构造方法创建WuMingFen对象 取名 f2
WuMingFen f2 = new WuMingFen(theMa, quantity);
//使用无参构造方法创建WuMingFen对象 取名 f3
WuMingFen f3 = new WuMingFen();
f3.theMa = "酸辣";
f3.quantity = 2;
f3.likeSoup = true;
//分别调用三个类的 check方法
f1.check();
f2.check();
f3.check();
/********** End **********/
}
}
第6关 static关键字
package step5;
public class Test {
/********** Begin **********/
static String name = "楚留香";
static
{
System.out.println("hello educoder");
}
public static void main(String[] args) {
System.out.println("我叫" + name);
study();
}
public static void study(){
System.out.println("我喜欢在educoder上学习java");
}
/********** End **********/
}
2-2 Java面向对象-类和对象编程
第1关 类的定义 与 对象的创建
package task01;
import java.util.Scanner;
public class Task01 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String name = input.next();
int age = input.nextInt();
speak(name, age);
}
public static void speak(String name, int age){
System.out.println("我的姓名:" + name + ',' + "年龄:" + age);
}
}
第2关 同一对象被多个变量引用
package task02;
import java.util.Scanner;
class Student{
String name;
int age;
void speak(){
System.out.println("我的名字是" + name + ",今年" + age + "岁");
}
}
public class Task02{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String name1 = input.next();
int age1 = input.nextInt();
String name2 = input.next();
int age2 = input.nextInt();
Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();
s1.name = name1;
s1.age = age1;
s2.name = name2;
s2.age = age2;
s3 = s2;
s1.speak();
s2.speak();
s3.speak();
}
}
第3关 类的封装
package task03;
import java.util.Scanner;
/*
* 说明：根据提示，补充完整 begin 和 end 之间的代码。
* （其他代码可以不用改）
*/
/**************** begin *****************/
class Student
/**************** end *****************/
{
/**************** begin *****************/
// 将名字name和年龄age属性定义为私有的
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age < 0) {
System.out.println("设置的年龄不合法");
} else {
this.age = age;
}
}
/**************** end *****************/
/**************** begin *****************/
/*
* 定义4个公有的方法：getName()、setName(String n)、
* getAge()和setAge(int a)，
* 用于对外访问name和age。
*
* 在setAge(int a)方法中对传入的参数进行检查，
* 如果输入值为负数，则打印出“设置的年龄不合法”，
* 如果不为负数，才将其设置为age属性的值。
*/
/**************** end *****************/
void speak() {
System.out.println("我的名字是" + name + ",今年" + age + "岁");
}
}
public class Task03{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String name1 = scan.next();
int age1 = scan.nextInt();
/**************** begin *****************/
/*
* 创建Student类的实例对象，
* 通过调用对象的setName(String n)和setAge(int a)方法
* 来设置实例对象的name属性和age属性值，
* 方法的参数值为运行时接收从键盘输入，
* 并调用speak()方法。
*/
Student student = new Student();
student.setName(name1);
student.setAge(age1);
student.speak();
/**************** end *****************/
}
}
第4关 构造方法及其重载
package task04;
import java.util.Scanner;
class Student
//**************** end *****************/
{
//**************** begin *****************/
// 将姓名name和年龄age属性定义为私有的
/**************** end *****************/
private String name;
private int age;
Student(){}
Student(String name) {
this.name = name;
}
Student(String name, int age) {
this.name = name;
this.age = age;
}
/**************** begin *****************/
/*
* 定义三个重载的构造方法，
* 无参的构造方法：方法体为空；
* 接收一个String类型参数的构造方法：方法体中用参数为姓名赋值；
* 接收String类型和int类型两个参数的构造方法：方法体中用参数为姓名和年龄赋值；
*/
/**************** end *****************/
void speak() {
System.out.println("我的名字是" + name + ",今年" + age + "岁");
}
}
public class Task04{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String name = scan.next();
String name1 = scan.next();
int age = scan.nextInt();
/**************** begin *****************/
// 使用无参的构造方法创建一个Student对象，并调用speak()方法
Student student = new Student();
student.speak();
/**************** end *****************/
/**************** begin *****************/
/*
* 使用一个参数的构造方法创建一个Student对象，参数值为运行时接收从键盘输入，
* 然后调用speak()方法
*/
Student student1 = new Student(name);
student1.speak();
/**************** end *****************/
/**************** begin *****************/
/*
* 使用两个参数的构造方法创建一个Student对象，参数值为运行时接收从键盘输入，
* 然后调用speak()方法
*/
Student student2 = new Student(name1, age);
student2.speak();
/**************** end *****************/
}
}
第5关 this关键字访问构造方法
package task05;
import java.util.Scanner;
/*
* 说明：根据提示，补充完整 begin 和 end 之间的代码。
* （其他代码可以不用改）
*/
/**************** begin *****************/
// 在此定义学生类名
class Student
/**************** end *****************/
{
/**************** begin *****************/
// 将姓名name和年龄age属性定义为私有的
private String name;
private int age;
/**************** end *****************/
/**************** begin *****************/
/*
* 定义一个无参的构造方法：方法体输出一行文字"无参的构造方法"；
*/
Student() {
System.out.println("无参的构造方法");
}
/**************** end *****************/
/**************** begin *****************/
/*
* 定义一个接收一个String类型参数的构造方法：
* 方法体中：使用this关键字调用无参构造方法，
* 并使用String类型参数为姓名赋值，再输出一行文字"一个参数的构造方法"；
*/
Student(String name) {
this();
this.name = name;
System.out.println("一个参数的构造方法");
}
/**************** end *****************/
/**************** begin *****************/
/*
* 定义一个接收String类型和int类型两个参数的构造方法：
* 方法体中：使用this关键字调用一个参数的构造方法，
* 并使用int类型参数为年龄赋值(不用为姓名赋值)，再输出一行文字"两个参数的构造方法"；
*/
Student(String name, int age) {
this(name);
this.age = age;
System.out.println("两个参数的构造方法");
}
/**************** end *****************/
void speak() {
System.out.println("我的名字是" + name + ",今年" + age + "岁");
}
}
public class Task05 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
/**************** begin *****************/
/*
* 调用学生类的两个参数的构造方法创建对象，参数值为运行时接收从键盘输入；
* 使用对象调用speak()方法。
*/
String name = scan.next();
int age = scan.nextInt();
Student student = new Student(name, age);
student.speak();
/**************** end *****************/
}
}
第6关 静态变量
package task06;
import java.util.Scanner;
/*
* 说明：根据提示，补充完整 begin 和 end 之间的代码。
* （其他代码可以不用改）
*/
// 定义学生类名
class Student
{
/**************** begin *****************/
/*
* 定义两个非私有属性：姓名name属性和学校school属性，
* 学校school属性为静态的，默认值为北京大学。
*/
String name;
static String school = "北京大学";
/**************** end *****************/
void speak() {
System.out.println("我的名字是" + name + ",来自" + school);
}
}
public class Task06{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
/**************** begin *****************/
/*
* 定义两个学生类对象，并为每个对象的姓名属性赋值，
* 值为运行时接收从键盘输入；
* 通过每个对象调用speak()方法。
*/
String name = scan.next();
String name1 = scan.next();
//String school;
Student stu1 = new Student();
Student stu2 = new Student();
stu1.name = name;
stu2.name = name1;
stu1.speak();
stu2.speak();
/**************** end *****************/
/**************** begin *****************/
/*
* 改写学生类的school属性值，值为运行时接收从键盘输入
*/
Student.school = scan.next();
/**************** end *****************/
/**************** begin *****************/
/*
* 再通过前面创建的两个对象分别调用speak()方法
*/
stu1.speak();
stu2.speak();
/**************** end *****************/
}
}
第7关 静态代码块
package task07;
/*
* 说明：根据 TODO 提示，补充完整对应功能代码。
* （其他代码可以不用改）
*/
public class Task07 {
static {
System.out.println("静态代码块");
}
{
System.out.println("构造代码块");
}
public Task07() {
System.out.println("构造方法");
}
void localBlock() {
{
System.out.println("局部代码块");
}
}
public static void main(String[] args) {
System.out.println("---------");
// TODO 在此定义一个测试类的对象
Task07 t1=new Task07();
System.out.println("---------");
// TODO 在此再定义一个测试类的对象
Task07 t2=new Task07();
System.out.println("---------");
// TODO 在此使用第一个对象调用localBlock方法
t1.localBlock();
System.out.println("---------");
// TODO 在此使用第二个对象调用localBlock方法
t2.localBlock();
}
}
2-3 Java面向对象 - 封装、继承、接口与多态
第1关 什么是封装，如何使用封装
package case1;
public class TestPersonDemo {
public static void main(String[] args) {
Person p = new Person();
p.setName("张三");
p.setAge(18);
p.talk();
}
}
class Person {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
void talk() {
System.out.println("我是：" + name + "，今年：" + age + "岁");
}
}
第2关 什么是继承，怎样使用继承
package case2;
public class extendsTest {
public static void main(String args[]) {
Cat cat = new Cat();
Dog dog = new Dog();
cat.setName("大花猫");
cat.setAge(6);
cat.voice();
cat.eat();
System.out.println(cat.getName() + cat.getAge() + "岁");
dog.setName("大黑狗");
dog.setAge(8);
dog.voice();
dog.eat();
System.out.println(dog.getName() + dog.getAge() + "岁");
}
}
class Animal {
private String name;
private int age;
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;
}
}
class Cat extends Animal {
void voice() {
System.out.println(getName() + "喵喵叫");
}
void eat() {
System.out.println(getName() + "吃鱼");
}
}
class Dog extends Animal {
void voice() {
System.out.println(getName() + "汪汪叫");
}
void eat() {
System.out.println(getName() + "吃骨头");
}
}
第3关 super关键字的使用
package case3;
public class superTest {
public static void main(String args[]) {
Student s = new Student();
s.school = "哈佛大学";
System.out.println("姓名：" + s.name + "，年龄：" + s.age + "，学校：" + s.school);
}
}
class Person {
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
}
class Student extends Person {
String school;
Student() {
super("张三", 18);
}
}
第4关 方法的重写与重载
package case4;
public class overridingTest {
public static void main(String args[]) {
Student s = new Student();
s.talk();
}
}
class Person {
String name;
int age;
void talk() {
name = "张三";
age = 18;
System.out.print("我是：" + name + "，今年：" + age);
}
}
class Student extends Person {
String school;
void talk() {
super.talk();
school = "岁，我在哈佛大学上学";
System.out.println(school);
}
}
第5关 抽象类
package case5;
public class abstractTest {
public static void main(String args[]) {
Student stu = new Student("张三", 20, "学生");
Worker wor = new Worker("李四", 30, "工人");
stu.talk();
wor.talk();
}
}
abstract class Person {
String name;
int age;
String occupation;
Person(String name, int age, String occupation) {
this.name = name;
this.age = age;
this.occupation = occupation;
}
abstract void talk();
}
class Student extends Person {
Student(String name , int age, String occupation) {
super(name, age, occupation);
}
@Override
void talk() {
System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+ occupation+"！");
}
}
class Worker extends Person {
Worker(String name , int age, String occupation) {
super(name, age, occupation);
}
@Override
void talk() {
System.out.println("工人——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
}
}
第6关 final关键字的理解与使用
package case6;
public class finalTest {
public static void main(String args[]) {
Bike1 obj = new Bike1();
obj.run();
Honda honda = new Honda();
honda.run();
Yamaha yamaha = new Yamaha();
yamaha.run();
}
}
//不可以修改 final 变量的值
// final方法,不可以重写
不可以扩展 final 类·
//请在此添加你的代码
/********** Begin *********/
class Bike1 {
final int speedlimit = 90;
void run() {
//speedlimit = 120;
System.out.println("speedlimit=120");
}
}
class Bike2 {
void run() {
System.out.println("running");
}
}
class Honda extends Bike2 {
void run() {
System.out.println("running safely with 100kmph");
}
}
class Bike3 {
}
class Yamaha extends Bike3{
void run() {
System.out.println("running safely with 100kmph");
}
}
/********** End **********/
第7关 接口
package case7;
public class interfaceTest {
public static void main(String[] args) {
// 实例化一Student的对象s，并调用talk()方法，打印信息
/********* begin *********/
Student s =new Student();
s.talk();
/********* end *********/
}
}
// 声明一个Person接口，并在里面声明三个常量：name、age和occupation，并分别赋值，声明一抽象方法talk()
interface Person {
/********* begin *********/
String name="张三";
int age=18;
String occupation="学生";
void talk();
/********* end *********/
}
// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
class Student implements Person {
/********* begin *********/
public void talk(){
System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
}
/********* end *********/
}
第8关 什么是多态，怎么使用多态
package case8;
public class TestPolymorphism {
public static void main(String[] args) {
// 以多态方式分别实例化子类对象并调用eat()方法
/********* begin *********/
show(new Dog());
show(new Cat());
show(new Lion());
}
public static void show(Animal a){
a.eat();
}
/********* end *********/
}
// Animal类中定义eat()方法
abstract class Animal {
/********* begin *********/
abstract void eat();
/********* end *********/
}
// Dog类继承Animal类 复写eat()方法
class Dog extends Animal {
/********* begin *********/
public void eat() {
System.out.println("eating bread...");
}
/********* end *********/
}
// Cat类继承Animal类 复写eat()方法
class Cat extends Animal {
/********* begin *********/
public void eat() {
System.out.println("eating rat...");
}
/********* end *********/
}
// Lion类继承Animal类 复写eat()方法
class Lion extends Animal {
/********* begin *********/
public void eat() {
System.out.println("eating meat...");
}
/********* end *********/
}
2-4 Java面向对象 - 对象类型的转换
第1关 学习-Java继承和多态之对象类型的转换
/**
* 使用对象类型的转换，根据编程提示，完成猫类和动物类的转换，以及彼此方法和属性的调用
*/
// 定义动物类
class Animal{
// 定义动物类的属性
public String name = "动物";
public static String staticName = "可爱的动物";
// 定义动物类的行为方法
public void eat() {
System.out.println("动物吃饭");
}
public static void staticEat() {
System.out.println("可爱的动物正在在吃饭");
}
}
// 定义猫类，该类继承动物类
public class Cat extends Animal{
// 定义猫类的属性
public String name = "猫";
public String str = "可爱的小猫";
public static String staticName = "我是喵星人";
// 定义猫类的行为方法
public void eat() {
System.out.println("猫吃饭");
}
public static void staticEat() {
System.out.println("喵星人在吃饭");
}
public void eatMethod() {
System.out.println("猫喜欢吃鱼");
}
public static void main(String[] args) {
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********* Begin *********/
// 向上转型，把猫类对象赋值给动物类
Animal stu1 = new Cat();
// 向下转型，将动物类引用转换为猫类对象
Cat stu11 = (Cat) stu1;
// 输出Animal类的name变量
System.out.println(stu1.name);
// 输出Animal类的staticName变量
System.out.println(Animal.staticName);
// 输出Cat类的eat()方法
stu11.eat();
// 输出Animal类的staticEat()方法
Animal.staticEat();
// 调用Cat类的str变量
System.out.println(stu11.str);
// 调用Cat类的eatMethod()方法
stu11.eatMethod();
/********** End **********/
}
}
2-5 Java面向对象 - 封装、继承和多态的综合练习
第1关 封装、继承和多态进阶（一）
package case1;
import java.util.Scanner;
public class Task1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String dogName = sc.next();
String dogSex = sc.next();
String dogColor = sc.next();
String catName = sc.next();
String catSex = sc.next();
double catWeight = sc.nextDouble();
// 通过有参构造函数实例化Dog类对象dog
// dog调用talk()方法
// dog调用eat()方法
/********* begin *********/
Dog dog=new Dog (dogName,dogSex,dogColor);
dog.talk();
dog.eat();
/********* end *********/
// 通过有参构造函数实例化Cat类对象cat
// cat调用talk()方法
// cat调用eat()方法
/********* begin *********/
Cat cat=new Cat(catName,catSex,catWeight);
cat.talk();
cat.eat();
/********* end *********/
}
}
// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
private String name;
private String sex;
Pet(String name, String sex) {
this.name = name;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
abstract void talk();
abstract void eat();
}
// Dog类继承自Pet类 封装属性color
// 构造函数初始化name、sex和color
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，颜色：color，汪汪叫'
// eat()输出'name吃骨头'
class Dog extends Pet {
private String color;
Dog(String name, String sex, String color) {
super(name, sex);
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
void talk() {
System.out.println("名称："+super.getName()+"，性别："+super.getSex()+"，颜色："+color+"，汪汪叫");
}
@Override
void eat() {
System.out.println(super.getName()+"吃骨头！");
}
}
// Cat类继承自Pet类 封装属性weight
// 构造函数初始化name、sex和weight
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，体重：weight kg，喵喵叫'
// eat()输出'name吃鱼'
class Cat extends Pet {
private double weight;
Cat(String name, String sex, double weight) {
super(name, sex);
this.weight = weight;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
@Override
void eat() {
System.out.println(super.getName()+"吃鱼！");
}
@Override
void talk() {
System.out.println("名称："+super.getName()+"，性别："+super.getSex()+"，体重："+weight+"kg，喵喵叫");
}
}
第2关 封装、继承和多态进阶（二）
package case2;
import java.util.Scanner;
public class Task2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String cName = sc.next();
String cSex = sc.next();
int cAge = sc.nextInt();
String eName = sc.next();
String eSex = sc.next();
int eAge = sc.nextInt();
// 创建测试类对象test
// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
// 通过showEat()方法调用Chinese的eat()方法
// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
// 通过showEat()方法调用English的eat()方法
/********* begin *********/
Person person1=new Chinese(cName,cSex,cAge);
showEat (person1);
Person person2=new English(eName,eSex,eAge);
showEat (person2);
/********* end *********/
// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
/********* begin *********/
Chinese chinese=(Chinese) person1;
chinese.shadowBoxing();
English english=(English) person2;
english.horseRiding();
/********* end *********/
}
// 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
/********* begin *********/
//题目中没有static 这里应该定义一个静态方法，如果不定义静态方法的话，上面showeat（对象）无法正常调用
public static void showEat(Person person){
person.eat();
}
/********* end *********/
}
// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person {
/********* begin *********/
private String name;
private String sex;
private int age;
public String getname(){
return name;
}
public void setname(String name){
this.name=name;
}
public String getsex(){
return sex;
}
public void setsex(String sex){
this.sex=sex;
}
public int getage(){
return age;
}
public void setage(int age){
this.age=age;
}
public Person (String name,String sex,int age){
this.name=name;
this.sex=sex;
this.age=age;
}
public abstract void eat();//定义抽象方法 让子类实现
/********* end *********/
}
// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
class Chinese extends Person {
/********* begin *********/
public Chinese(String name,String sex,int age){
super(name,sex,age);
sex=super.getname();
name=super.getname();
age=super.getage();
}
public void eat(){ //实现抽象方法eat() 编写方法体
System.out.println("姓名："+super.getname()+"，性别："+super.getsex()+"，年龄："+super.getage()+"，我是中国人，我喜欢吃饭！");
}
public void shadowBoxing(){
System.out.println(super.getname()+"在练习太极拳！");
}
/********* end *********/
}
// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
class English extends Person {
/********* begin *********/
public English(String name,String sex,int age){
super(name,sex,age);
sex=super.getname();
name=super.getname();
age=super.getage();
}
public void eat(){ //实现抽象方法eat() 编写方法体
System.out.println("姓名："+super.getname()+"，性别："+super.getsex()+"，年龄："+super.getage()+"，我是英国人，我喜欢吃三明治！");
}
public void horseRiding(){
System.out.println(super.getname()+"在练习骑马！");
}
/********* end *********/
}
第3关 封装、继承和多态进阶（三）
package case3;
import java.util.Scanner;
public class Task3 {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner sc = new Scanner(System.in);
String pppName = sc.next();
int pppAge = sc.nextInt();
String bpName = sc.next();
int bpAge = sc.nextInt();
String ppcName = sc.next();
int ppcAge = sc.nextInt();
String bcName = sc.next();
int bcAge = sc.nextInt();
// 测试运动员(乒乓球运动员和篮球运动员)
// 乒乓球运动员
// 通过带参构造函数实例化PingPangPlayer对象ppp
// 输出'name---age'
// 分别调用sleep()、eat()、study()、speak()方法
/********* begin *********/
PingPangPlayer ppp=new PingPangPlayer(pppName,pppAge);
System.out.println(pppName+"---"+pppAge);
ppp.sleep();
ppp.eat();
ppp.study();
ppp.speak();
/********* end *********/
System.out.println("----------------");
// 篮球运动员
// 通过带参构造函数实例化BasketballPlayer对象bp
// 输出'name---age'
// 分别调用sleep()、eat()、study()方法
/********* begin *********/
BasketballPlayer bp=new BasketballPlayer(bpName,bpAge);
System.out.println(bpName+"---"+bpAge);
bp.sleep();
bp.eat();
bp.study();
/********* end *********/
System.out.println("----------------");
// 测试教练(乒乓球教练和篮球教练)
// 乒乓球教练
// 通过带参构造函数实例化PingPangCoach对象ppc
// 输出'name---age'
// 分别调用sleep()、eat()、teach()、speak()方法
/********* begin *********/
PingPangCoach ppc=new PingPangCoach(ppcName,ppcAge);
System.out.println(ppcName+"---"+ppcAge);
ppc.sleep();
ppc.eat();
ppc.teach();
ppc.speak();
/********* end *********/
System.out.println("----------------");
// 篮球教练
// 通过带参构造函数实例化BasketballCoach对象bc
// 输出'name---age'
// 分别调用sleep()、eat()、teach()方法
/********* begin *********/
BasketballCoach bc=new BasketballCoach(bcName,bcAge);
System.out.println(bcName+"---"+bcAge);
bc.sleep();
bc.eat();
bc.teach();
/********* end *********/
System.out.println("----------------");
}
}
// 说英语接口 声明抽象方法speak()
interface SpeakEnglish {
/********* begin *********/
abstract void speak();
/********* end *********/
}
// 定义人的抽象类Person 封装name和age
// 无参构造函数
// 有参构造函数初始化name和age
// 定义具体方法sleep() 输出'人都是要睡觉的'
// 抽象方法eat()（吃的不一样）
abstract class Person {
/********* begin *********/
private String name;
private int age;
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;
}
Person() {}
Person(String name, int age) {
this.name = name;
this.age = age;
}
void sleep() {
System.out.println("人都是要睡觉的");
}
abstract void eat();
/********* end *********/
}
// 定义运动员Player（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
abstract class Player extends Person {
/********* begin *********/
Player(String name,int age){
super(name,age);
}
Player() {}
abstract void study();
/********* end *********/
}
// 定义教练Coach（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 教练教的不一样 定义抽象方法teach()
abstract class Coach extends Person {
/********* begin *********/
Coach(String name,int age){
super(name,age);
}
abstract void teach();
/********* end *********/
}
// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
class PingPangPlayer extends Player implements SpeakEnglish {
/********* begin *********/
public PingPangPlayer(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("乒乓球运动员吃大白菜，喝小米粥");
}
public void study(){
System.out.println("乒乓球运动员学习如何发球和接球");
}
public void speak(){
System.out.println("乒乓球运动员说英语");
}
/********* end *********/
}
// 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口，因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球运动员吃牛肉，喝牛奶'
// 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
class BasketballPlayer extends Player {
/********* begin *********/
BasketballPlayer(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("篮球运动员吃牛肉，喝牛奶");
}
public void study(){
System.out.println("篮球运动员学习如何运球和投篮");
}
/********* end *********/
}
// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类（兵乓球教练需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球教练吃小白菜，喝大米粥'
// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球教练说英语'
class PingPangCoach extends Coach implements SpeakEnglish {
/********* begin *********/
public PingPangCoach(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("乒乓球教练吃小白菜，喝大米粥");
}
public void teach(){
System.out.println("乒乓球教练教如何发球和接球");
}
public void speak(){
System.out.println("乒乓球教练说英语");
}
/********* end *********/
}
// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口，因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球教练吃羊肉，喝羊奶'
// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
class BasketballCoach extends Coach {
/********* begin *********/
public BasketballCoach(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("篮球教练吃羊肉，喝羊奶");
}
public void teach(){
System.out.println("篮球教练教如何运球和投篮");
}
/********* end *********/
}
2-6 Java面向对象 - 常用类
第1关 Object类
package case1;
import java.util.Scanner;
public class ObjectTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num1 = sc.nextInt();
int num2 = sc.nextInt();
// 在测试类中创建Demo类对象d1，传入输入值num1， d1调用toString方法并打印输出该值
// 创建Demo类对象d2，同样传入输入值num1，打印判断d1和d2是否相等（实际是比较地址）
/********* Begin *********/
Demo d1=new Demo(num1);
System.out.println(d1.toString());
Demo d2=new Demo(num1);
if (d1.equals(d2)) {
System.out.println("true");
} else {
System.out.println("false");
}
/********* End *********/
// 创建Person类对象p，传入输入值num2，打印判断d1和p是否相等（实际是比较地址）
/********* Begin *********/
Person p=new Person(num2);
if (d1.equals(p)) {
System.out.println("true");
} else {
System.out.println("false");
}
/********* End *********/
}
}
class Demo {
private int num;
public Demo(int num) {
this.num = num;
}
public boolean equals(Object obj) // Object obj = new Demo()
{
if (!(obj instanceof Demo)) // 判断obj是否和Demo是同类
return false;
Demo d = (Demo) obj; // 将父类的引用(Object)向下转换为子类(Demo)
return this.num == d.num;
}
public String toString() {
return "Demo:" + num; // 返回对象的值（每一个对象都有自己的特定的字符串）
}
}
class Person {
private int num;
public Person(int num) {
this.num = num;
}
}
第2关 JAVA基础类型包装类-练习
package case2;
import java.util.Scanner;
public class WrapperTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int aa = sc.nextInt();
String bb = sc.next();
int c = sc.nextInt();
String str11 = sc.next();
String str22 = sc.next();
// 包装类中“==”与equals的用法比较
// 值得注意的是，包装类中的equals方法和String类一样，都是重写了Object类中的equals方法，因此比较的是内容而不是地址，
// 而“==”比较的依然是引用变量的地址，只是当包装类型和与之相对应的基本类型进行“==”比较时会先做自动拆箱处理。
/********* Begin *********/
Integer a=new Integer(aa);
Integer b=Integer.parseInt(bb);
String str1=new String(str11);
String str2=new String(str22);
System.out.println(a==b);
System.out.println(a==c);
System.out.println(b==c);
System.out.println(a.equals(b));
System.out.println(str1==str2);
System.out.println(str1.equals(str2));
/********* End *********/
}
}
第3关 String&StringBuilder&StringBuffer类-练习
package case3;
import java.util.Scanner;
public class StringTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.next();
// String substring(int start,int end)
// 截取字符串，传入的两个参数分别为要截取边界的下标
// 在java api 中,通常使用两个数字表示范围时,都是含头不含尾,即包含起始下标对应的内容,但不包含结束下标的处对应的内容
// String toUpperCase() 将当前字符串中的英文部分转换为全大写
/********* Begin *********/
String str1=str.substring(12,str.lastIndexOf('.'));
if(str1.indexOf('.')>0){
str1=str1.substring(0,str1.indexOf('.'));
}
System.out.println(str1);
str1=str1.toUpperCase();
System.out.println(str1);
/********* End *********/
}
}
第4关 Random类
package case4;
//密码的自动生成器：密码由大写字母/小写字母/数字组成，生成六位随机密码
import java.util.Random;
import java.util.Scanner;
public class RandomTest {
public static void main(String[] args) {
// 定义一个字符型数组
char[] pardStore = new char[62];
// 把所有的大写字母放进去 把所有的小写字母放进去 把0到9放进去
/********* Begin *********/
for(int i=0;i<26;i++)
{
pardStore[i]=(char)('A'+i);
pardStore[26+i]=(char)('a'+i);
}
for(int i=0;i<10;i++)
{
pardStore[52+i]= (char)('0' + i);
}
/********* End *********/
// 分别以1、2、3作为种子数 生成6位随机密码
Scanner sc = new Scanner(System.in);
int seed = sc.nextInt();
/********* Begin *********/
Random r=new Random(seed);
String str="";
int[] arr=r.ints(6,0,62).toArray();
for(int i=0;i<6;i++)
{
str+=pardStore[arr[i]];
}
System.out.print(str);
/********* End *********/
}
}
第5关 Date类和SimpleDateFormat类的用法
package case5;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class DateTest {
public static void main(String[] args) throws ParseException {
// 键盘录入你的出生年月日 格式为yyyy-MM-dd
// 把该字符串转换为一个日期
// 通过该日期得到一个毫秒值
// 获取2020年10月1日的毫秒值
// 两者想减得到一个毫秒值
// 把该毫秒值转换为天 打印输出
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
/********* Begin *********/
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Date d1=sdf.parse(line);
Date d2=sdf.parse("2020-10-01");
long diff=d2.getTime()-d1.getTime();
diff=diff/86400000;
System.out.println("你的出生日期距离2020年10月1日:"+diff+"天");
/********* End *********/
}
}
第6关 Math类
package case6;
import java.util.Scanner;
import java.lang.Math;
public class MathTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a1 = sc.nextInt();
int a2 = sc.nextInt();
int a3 = sc.nextInt();
int a4 = sc.nextInt();
double a5 = sc.nextDouble();
double a6 = sc.nextDouble();
double a7 = sc.nextDouble();
double a8 = sc.nextDouble();
double a9 = sc.nextDouble();
double a10 = sc.nextDouble();
double a11 = sc.nextDouble();
/********* Begin *********/
System.out.println(Math.sqrt(a1));
System.out.println(Math.cbrt(a2));
System.out.println(Math.pow(a3,a4));
System.out.println(Math.max(a5,a6));
System.out.println(Math.min(a5,a6));
System.out.println(Math.abs(a7));
System.out.println(Math.ceil(a8));
System.out.println(Math.floor(a9));
System.out.println(Math.rint(a10));
System.out.println(Math.round(a11));
/********* End *********/
}
}
2-7 Java面向对象 - String类
第1关 length()方法与compareTo()方法的使用 - 花名册
package step1;
import java.util.Scanner;
public class Roster {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
/********** Begin *********/
String str1 = scanner.next();
String str2 = scanner.next();
String str3 = scanner.next();
String str7 = scanner.next();
String str4 = scanner.next();
String str5 = scanner.next();
String str6 = scanner.next();
String str8 = scanner.next();
String roster1 = str1+" "+str2+" "+str3+" "+str7;
String roster2 = str4+" "+str5+" "+str6+" "+str8;
System.out.println(roster1.length());
System.out.println(roster1.length());
if(roster1.compareTo(roster2) == 0){
System.out.println("相同");
}else{
System.out.println("不相同");
}
/********** End *********/
}
}
第2关 substring()方法与indexOf()方法的使用 - 姓名查找
package step2;
import java.util.Scanner;
public class NameSearch {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
/********** Begin *********/
String data = scanner.next();
String name = scanner.next();
int j,k = 0;
for(int i = 0;i<data.length();){
j = data.indexOf(name,i);
if(j != -1){
if(j != k) {
System.out.println(j);
}
}else {
break;
}
k=j;
i = i+name.length();
}
/********** End *********/
}
}
第3关 String串类操作 - 文件名与邮箱验证
package step3;
public class HelloWorld {
public void judge(String fileName,String email){
//请在此添加实现代码
/********** Begin **********/
String str1 = ".java";
if(fileName.indexOf(str1) > 0) {
String str2 = fileName.substring(fileName.length()-str1.length());
if (str1.equals(str2) && str1.length() < fileName.length()) {
System.out.println("Java文件名正确");
}else {
System.out.println("Java文件名无效");
}
}else {
System.out.println("Java文件名无效");
}
int a = email.lastIndexOf("@");
int b= email.lastIndexOf(".");
if(a > 0 && b > 0) {
if (a > 0 && a < b) {
System.out.println("邮箱名正确");
}else {
System.out.println("邮箱名无效");
}
}else {
System.out.println("邮箱名无效");
}
/********** End **********/
}
}
第4关 StringBuffer类的定义和使用 - 字母反转
package step4;
public class Reverse {
public static StringBuffer start(String data) {
StringBuffer ans = new StringBuffer();
/********** Begin *********/
String[] str2 = data.split(" ");
String str3 = null;
for(int i = 0;i < str2.length;i++){
StringBuffer stringBuffer = new StringBuffer(str2[i]);
str2[i] = stringBuffer.reverse().toString();
if(i == 0){
str3 = str2[0];
}
if(i > 0) {
str3 = str3 + " " + str2[i];
}
}
ans = new StringBuffer(str3);
/********** End *********/
return ans;
}
}
2-8 Java面向对象 - 包装类
第1关 基本数据类型和包装类之间的转换
package step1;
public class Task {
public static void main(String[] args) {
//请在此添加实现代码
/********** Begin **********/
//定义float对象
float f = 66.6f;
//手动装箱
Float f1 = new Float(f) ;
//自动装箱
Float f2 = f ;
System.out.println("装箱后的结果为：" + f1 + "和" + f2);
//定义一个Double包装类值为88.88
Double d = new Double(88.88);
//手动拆箱
double d1 = d.doubleValue();
//自动拆箱
double d2 = d;
System.out.println("拆箱结果为：" + d1 + "和" + d2);
/********** End **********/
}
}
第2关 包装类转换成其他数据类型
package step2;
public class Task {
public static void main(String[] args) {
//请在此添加实现代码
/********** Begin **********/
// 定义int类型变量，值为67
int score = 67;
// 创建Integer包装类对象，表示变量score的值
Integer score1 = new Integer(score);
// 将Integer包装类转换为double类型
double score2 = score1.doubleValue() ;
// 将Integer包装类转换为float类型
float score3 =score1.floatValue() ;
// 将Integer包装类转换为int类型
int score4 = score1.intValue() ;
System.out.println("Integer包装类：" + score1);
System.out.println("double类型：" + score2);
System.out.println("float类型：" + score3);
System.out.println("int类型：" + score4);
/********** End **********/
}
}
第3关 包装类与字符串之间的转换
package step3;
public class Task {
public static void main(String[] args) {
double a = 78.5;
//请在此添加实现代码
/********** Begin **********/
//将基本类型a转换为字符串
String str =String.valueOf(a) ;
System.out.println("str + 12 的结果为： "+(str + 12));
String str1 = "180.20";
// 将字符串str1转换为基本类型
Double d = Double.parseDouble(str1) ;
System.out.println("d + 100 的结果为： "+ (d + 100));
/********** End **********/
}
}
2-9 Java面向对象 -异常处理类
第1关 了解异常 - ID检测
package step1;
import java.util.Scanner;
public class ThrowException {
public static void function(String id) { //利用throws关键字声明该方法可能出现异常IllegalArgumentException
/********** Begin *********/
if (id.length() == 7) {
//输出ID合法时的语句
System.out.println("ID格式正确：1234567");
} else {
//利用throw关键字抛出异常IllegalArgumentException
throw new IllegalArgumentException();
}
/********** End *********/
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String id = sc.nextLine();
try {
function(id);
} catch (IllegalArgumentException e) {
/********** Begin *********/
//输出ID不合法时的语句
System.out.println("ID长度应为7");
/********** End *********/
}
}
}
第2关 异常的捕获与处理 - 文本统计
package step2;
import java.awt.*;
import java.io.*;
public class CatchException {
public static void main(String[] args) {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String str;
/********** Begin *********/
//补全try/catch块，异常类型为IOException
try {
str = reader.readLine();
int letter = 0;
int space = 0;
int number = 0;
int other = 0;
for (int i = 0; i < str.length(); i++) {
if (Character.isLetter(str.charAt(i)))
letter++;
else if (Character.isSpaceChar(str.charAt(i)))
space++;
else if (Character.isDigit(str.charAt(i)))
number++;
else
other++;
}
System.out.println("letter=" + letter + ",space=" + space + ",number=" + number + ",other=" + other);
} catch (IOException e) {
System.out.print(e);
}
/********** End *********/
}
}
第3关 自定义异常 - 正负数
package step3;
import java.util.Scanner;
class MyException extends Exception {
public MyException(String m) {
super(m);
}
}
public class MyExceptionTest {
public static void main(String[] args) {
try {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
/********** Begin *********/
if (num > 0) {
System.out.println("The number you entered is: " + num);
} else {
throw new MyException("Number cannot be negative!");
}
/********** End *********/
} catch (MyException e) {
System.out.print(e);
}
}
}
3-1 Java高级特性 - IO流（上）
第1关：什么是IO流
BC
C
第2关：字节流-输入输出
package step2;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Task {
public void task() throws IOException{
/********* Begin *********/
File file = new File("src/step2/input/task.txt");
FileInputStream fs = new FileInputStream(file); //定义一个文件输入流
byte[] b = new byte[8]; //定义一个字节数组
fs.read(b); //将输入流的数据读入到字节数组
String str = new String(b,"UTF-8"); //通过utf-8编码表将字节转换成字符
System.out.println(str);
File dir = new File("src/step2/output");
if(!dir.exists()){
dir.mkdir();
}
FileOutputStream out = new FileOutputStream("src/step2/output/output.txt"); //创建输出流
String str1 = "learning practice";
byte[] c = str1.getBytes(); //将字符串转换成字节
out.write(c); //写数据
out.flush(); //刷新缓存区数据
fs.close(); //释放资源
out.close();
/********* End *********/
}
}
第3关：字符流 - 输入输出
package step3;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Task {
public void task() throws IOException{
/********* Begin *********/
String file1 = "src/step3/input/input.txt";
FileReader fr = new FileReader(file1);
char[] ch = new char[8];
fr.read(ch);
String file2 = "src/step3/output/output.txt";
FileWriter fw = new FileWriter(file2);
fw.write(ch);
fr.close();
fw.flush();
fw.close();
/********* End *********/
}
}
第4关：复制文件
package step4;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Task {
public void task() throws IOException{
/********* Begin *********/
String file1 = "src/step4/input/input.txt";
FileInputStream fr = new FileInputStream(file1);
byte[] b = new byte[1024];
int len = 0;
String file2 = "src/step4/output/output.txt";
FileOutputStream fw = new FileOutputStream(file2);
while((len = fr.read(b))!=-1){
fw.write(b,0,len);
}
fr.close();
fw.close();
String file3 = "src/step4/input/input.jpg";
String file4 = "src/step4/output/output.jpg";
FileInputStream fs = new FileInputStream(file3); //定义文件输入流读取文件信息
FileOutputStream fos = new FileOutputStream(file4);//定义文件输出流写文件
len = 0; //每次读取数据的长度
byte[] bys = new byte[1024]; //数据缓冲区
while( (len = fs.read(bys)) != -1){
fos.write(bys, 0, len);
}
//释放资源 刷新缓冲区
fs.close();
fos.close();
/********* End *********/
}
}
3-2 Java高级特性 - IO流（下）
第1关：创建文件
package step1;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.Scanner;
public class Task {
/********* Begin *********/
public void solution() {
try{
File file0=new File("src/output/hello.txt");
File file1=new File("src/output/test.txt");
file0.createNewFile();
file1.createNewFile();
}catch(IOException e){
e.printStackTrace();
}
/********* End *********/
}
}
第2关：文件的常用操作
package step2;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.Arrays;
public class Task {
public static void dcFile() throws IOException {
/********* Begin *********/
File file1 = new File("src/test2");
file1.mkdirs();
File file2 = new File("src/output/test2.txt");
file2.delete();
File file3 = new File("src/test2/helloworld.txt");
file3.createNewFile();
File file4 = new File("src/test2/step2.txt");
file4.createNewFile();
System.out.println("output目录结构为：");
File[] file5 = new File("src/output").listFiles();
Arrays.sort(file5);
for (File file : file5) {
System.out.println(file.getName());
}
System.out.println("test2目录结构为：");
File[] file6 = new File("src/test2").listFiles();
Arrays.sort(file6);
for (File file : file6) {
System.out.println(file.getName());
}
/********* End *********/
}
}
第3关：文件查看器
package step3;
import java.io.File;
import java.util.Arrays;
public class Task {
/********** Begin **********/
String dir ="+--";
String wj = "--";
String level = "";
public void showDirStructure(File file) {
//判断是否是文件夹
if(file.isDirectory()){
System.out.println(level+dir+file.getName());
String level1=level;
level+=" ";
File[] files = file.listFiles();
Arrays.sort(files);
for (File file1 : files) {
showDirStructure(file1);
}
level=level1;
}else{
System.out.println(level+wj+file.getName());
}
}
/********** End **********/
}
第4关：图片查看器
package step4;
import java.io.File;
import java.io.FileFilter;
import java.util.Arrays;
public class Task {
/********** Begin **********/
String dir ="+--";
String wj = "--";
String level = "";
public void showDirStructure(File file) {
//判断是否是文件夹
if(file.isDirectory()){
System.out.println(level+dir+file.getName());
String level1=level;
level+=" ";
File[] files = file.listFiles();
Arrays.sort(files);
for (File file1 : files) {
showDirStructure(file1);
}
level=level1;
}else{
//如果是文件，则筛选
String name = file.getName();
if(name.endsWith("jpg")||name.endsWith("bmp")||name.endsWith("png"))
System.out.println(level+wj+name);
}
}
/********** End **********/
}
3-3 Java高级特性 - 集合框架
第1关 集合的基本使用
package step1;
// 导包
/********** Begin **********/
import java.util.ArrayList;
/********** End **********/
public class HelloWorld {
@SuppressWarnings("unchecked")
public ArrayList getList() {
/********** Begin **********/
ArrayList list = new ArrayList();
list.add("https:www.educoder.net");
list.add(2018.423);
return list;
/********** End **********/
}
}
第2关 ArrayList集合的增删改查
package step2;
import java.util.ArrayList;
import java.util.Scanner;
public class HelloWorld {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
//获取输入的数据并添加至集合
Scanner sc = new Scanner(System.in);
ArrayList list = new ArrayList<>();
int length = sc.nextInt();
for(int i =0 ; i< length; i++){
list.add(sc.next());
}
/********** Begin *********/
list.remove(0);
list.remove(length-2);
list.add("hello");
list.add("educoder");
list.set(2,"list");
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
/********** End **********/
}
}
第3关 集合的体系结构
package step3;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
public class HelloWorld {
public HashSet getHashSet(){
/********** Begin **********/
HashSet set=new HashSet();
set.add("www.educoder.net");
return set;
/********** End **********/
}
public ArrayList getArrayList(){
/********** Begin **********/
ArrayList list=new ArrayList();
list.add("www.educoder.net");
return list;
/********** End **********/
}
public LinkedList getLinkedList(){
/********** Begin **********/
LinkedList list=new LinkedList();
list.add("www.educoder.net");
return list;
/********** End **********/
}
public Map getHashMap(){
/********** Begin **********/
Map map = new HashMap();
map.put("address","www.educoder.net");
return map;
/********** End **********/
}
}
第4关 泛型
package step4;
import java.util.*;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//程序会输入三次数据
/********** Begin **********/
List<String> list = new ArrayList<String>();
while(sc.hasNext()){
list.add(sc.next());
}
for(int i=0;i<list.size();i++){
System.out.println("集合的第"+(i+1)+"个数据为："+list.get(i));
}
/********** End **********/
}
}
第5关 Map集合的增删改查
package step5;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Map<String, Integer> menuDict = new HashMap<>();
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 5; i++) {
menuDict.put(sc.next(),sc.nextInt());
}
/********** Begin **********/
menuDict.put("lamb",50);
System.out.println(menuDict.get("fish"));
menuDict.put("fish",100);
menuDict.remove("noodles");
System.out.println(menuDict.toString());
/********** End **********/
}
}
第6关 选择题
C
3-4 Java 字符串与集合练习——词频统计
第1关 单词分割
package step1;
import java.util.List;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class StudentDemo{
//使用String.split()方法分割
public List<String> splitPartition(String str){
List<String> list=new ArrayList<String>();
//请在此添加实现代码
/********** Begin **********/
String[] strArray=str.split("\\|");
for(String str2:strArray){
System.out.println(str2);
}
System.out.println();
/********** End **********/
return list;
}
//使用StringTokenizer类进行分割
public List<String> tokenPartition(String str){
List<String> list=new ArrayList<String>();
//请在此添加实现代码
/********** Begin **********/
String[] strArray=str.split("\\?");
for(String str1:strArray){
System.out.println(str1);
}
/********** End **********/
return list;
}
}
第2关 确定单词在字符串中的位置
package step2;
import java.util.Map;
import java.util.HashMap;
import java.util.StringTokenizer;
public class StudentDemo{
//返回一个Map集合来得到单词和首次出现的下标 key为单词名称 value为单词的角标
public Map<String, Integer> getMap(String str){
Map<String, Integer> map = new HashMap<String, Integer>();
//对str进行分割 再加入map集合中
//请在此添加实现代码
/********** Begin **********/
StringTokenizer tok = new StringTokenizer(str);
String word;
while(tok.hasMoreTokens()){
word = tok.nextToken(", .\n");
int index = str.indexOf(word);
map.put(word,index);
}
/********** End **********/
return map;
}
}
第3关 实现词频统计和排序输出
package step3;
import java.util.Map;
import java.util.HashMap;
import java.util.StringTokenizer;
public class StudentDemo{
//获取单词的数量
public Map<String, Integer> getWordCount(String str) {
Map<String, Integer> map = new HashMap<String, Integer>();
//请在此添加实现代码
/********** Begin **********/
StringTokenizer tokenizer = new StringTokenizer(new String(str));
int count;
String word;
while (tokenizer.hasMoreTokens()) {
word = tokenizer.nextToken(" ,?.!:;\"\"‘’\n");
if (map.containsKey(word)) {
count = map.get(word);
map.put(word, count + 1);
} else {
map.put(word, 1);
}
}
/********** End **********/
return map;
}
}
3-5 Java高级特性 - 多线程基础（1）使用线程
第1关 创建线程
package step1;
//请在此添加实现代码
/********** Begin **********/
public class ThreadClassOne extends Thread {
public int i=0;
public ThreadClassOne(){
super();
}
public void run(){
for(i=0;i<10;i++){
if(i%2==1)
System.out.print(i+" ");
}
}
}
/********** End **********/
第2关 使用 Callable 和 Future 创建线程
package step2;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class Task {
public void runThread(int num) {
//请在此添加实现代码
/********** Begin **********/
// 在这里开启线程 获取线程执行的结果
ThreadCallable t1=new ThreadCallable(num);
FutureTask<Integer> ft1=new FutureTask<>(t1);
Thread thread1=new Thread(ft1,"thread1");
thread1.start();
try{
System.out.println("线程的返回值为："+ft1.get());
}catch(Exception e){
e.printStackTrace();
}
/********** End **********/
}
}
//请在此添加实现代码
/********** Begin **********/
/* 在这里实现Callable接口及方法 */
class ThreadCallable implements Callable<Integer> {
int num;
ThreadCallable(int num){
this.num=num;
}
ThreadCallable(){
}
public Integer call() throws Exception{
return getNum(num);
}
private int getNum(int num){
if(num<3){
return 1;
}
else{
return getNum(num-1)+getNum(num-2);
}
}
}
/********** End **********/
3-6 Java高级特性 - 多线程基础（2）常用函数
第1关：线程的状态与调度
ABC
D
A
C
C
ABD
第2关：常用函数（一）
package step2;
import java.util.Scanner;
public class Task {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
//请在此添加实现代码
/********** Begin **********/
Thread t = new MyThread("子线程",num);
t.start();
/********** End **********/
}
}
//请在此添加实现代码
/********** Begin **********/
class MyThread extends Thread{
private int num;
private String name;
public MyThread(String name,int num){
this.num=num;
this.name=name;
}
public void run(){
int[] arr = new int[2];
arr[0] = 1;
arr[1] = 1;
for (int i = 2; i < num; i++) {
int tmp = arr[1];
arr[1] = arr[0] + arr[1];
arr[0] = tmp;
}
System.out.println("子线程计算结果为："+arr[1]);
}
}
/********** End **********/
第3关：常用函数（二）
package step3;
public class MyThread implements Runnable {
//请在此添加实现代码
/********** Begin **********/
private String name;
private Object prev;
private Object self;
private MyThread(String name,Object prev,Object self){
this.name = name;
this.prev = prev;
this.self = self;
}
public void run(){
int count = 5;
while(count>0){
synchronized(prev){
synchronized(self){
System.out.print(name);
count--;
self.notify();
}
try {
prev.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.exit(0);
}
public static void main(String[] args) throws Exception {
Object a = new Object();
Object b = new Object();
Object c = new Object();
MyThread ta = new MyThread("E",c,a);
MyThread tb = new MyThread("D",a,b);
MyThread tc = new MyThread("U",b,c);
new Thread(ta).start();
Thread.sleep(100);
new Thread(tb).start();
Thread.sleep(100);
new Thread(tc).start();
Thread.sleep(100);
}
/********** End **********/
}
3-7 Java高级特性 - 多线程基础（3）线程同步
第1关 并发编程的三个概念
ABD
AB
E
第2关：使用synchronized关键字同步线程
package step2;
public class Task {
public static void main(String[] args) {
final insertData insert = new insertData();
for (int i = 0; i < 3; i++) {
new Thread(new Runnable() {
public void run() {
insert.insert(Thread.currentThread());
}
}).start();
}
}
}
class insertData{
public static int num =0;
/********* Begin *********/
public synchronized void insert(Thread thread){
for (int i = 0; i <= 5; i++) {
num++;
System.out.println(num);
}
}
/********* End *********/
}
第3关：使用线程锁（Lock）实现线程同步
package step3;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Task {
public static void main(String[] args) throws InterruptedException {
final Insert insert = new Insert();
Thread t1 = new Thread(new Runnable() {
public void run() {
insert.insert(Thread.currentThread());
}
});
Thread t2 = new Thread(new Runnable() {
public void run() {
insert.insert(Thread.currentThread());
}
});
Thread t3 = new Thread(new Runnable() {
public void run() {
insert.insert(Thread.currentThread());
}
});
// 设置线程优先级
/*
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.NORM_PRIORITY);
t3.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
t3.start();
*/
t1.start();
t2.sleep(500);
t2.start();
t3.sleep(1000);
t3.start();
}
}
class Insert {
public static int num;
// 在这里定义Lock
private Lock lock = new ReentrantLock();
public void insert(Thread thread) {
/********* Begin *********/
if (lock.tryLock()) {
try {
System.out.println(thread.getName() + "得到了锁");
for (int i = 0; i < 5; i++) {
num++;
System.out.println(num);
}
} finally {
System.out.println(thread.getName() + "释放了锁");
lock.unlock();
}
} else {
System.out.println(thread.getName() + "获取锁失败");
}
}
/********* End *********/
}
第4关：使用volatile实现变量的可见性
package step4;
public class Task {
public volatile int inc = 0;
//请在此添加实现代码
/********** Begin **********/
public synchronized void increase() {
inc++;
}
/********** End **********/
public static void main(String[] args) {
final Task test = new Task();
for (int i = 0; i < 10; i++) {
new Thread() {
public void run() {
for (int j = 0; j < 1000; j++)
test.increase();
};
}.start();
}
while (Thread.activeCount() > 1) // 保证前面的线程都执行完
Thread.yield();
System.out.println(test.inc);
}
}
3-8 Java高级特性 - 多线程练习题
第1关 顺序输出
package step1;
public class Task {
public static void main(String[] args) throws Exception {
/********* Begin *********/
//在这里创建线程， 开启线程
Object a = new Object();
Object b = new Object();
Object c = new Object();
MyThread ta = new MyThread("A",c,a);
MyThread tb = new MyThread("B",a,b);
MyThread tc = new MyThread("C",b,c);
ta.start();
ta.sleep(100);
tb.start();
tb.sleep(100);
tc.start();
tc.sleep(100);
/********* End *********/
}
}
class MyThread extends Thread {
/********* Begin *********/
private String threadName;
private Object prev;
private Object self;
public MyThread(String name,Object prev,Object self){
this.threadName = name;
this.prev = prev;
this.self = self;
}
public void run() {
int count = 5;
while(count>0){
synchronized(prev){
synchronized(self){
System.out.println("Java Thread"+this.threadName+this.threadName);
count--;
self.notify();
}
try {
prev.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.exit(0);
}
/********* End *********/
}
第2关 售票窗口
package step2;
/********* Begin *********/
//定义站台类，实现卖票的功能。
public class Station extends Thread{
static int tick = 20; // 为了保持票数的一致，票数要静态
static Object ob = new Object(); // 创建一个静态钥匙 值是任意的
public void ticket() {
System.out.println( "卖出了第" + tick + "张票");
tick--;
}
public void run() {
while (tick > 0) {
synchronized (ob) {
if (tick > 0) {
ticket();
}
}
if(tick == 0){
System.out.println("票卖完了");
}
try {
Thread.sleep(100);
} catch (Exception e) {
}
}
}
}
/********* End *********/
3-9 Java高级特性 - Java反射
第1关 了解 Class 对象
文件一：
package step1;
/**
* 评测执行文件
*/
public class Reflect_run {
public static void main(String[] args) {
// Class clazz1 = Person.class;
2、通过对象的getClass()方法返回一个Class类型的实例
// Person person = new Person();
// Class clazz2 = person.getClass();
3、通过静态方法Class.forName()获取类名对应的Class对象
// Class clazz3 = null;
// try {
// clazz3 = Class.forName("step1.Person");
// } catch (ClassNotFoundException e) {
// e.printStackTrace();
// }
//
// // 使用 "==" 进行比较 clazz1 与 clazz2 的关系
// System.out.println(clazz1 == clazz2);
// // 使用 "==" 进行比较 clazz2 与 clazz3 的关系
// System.out.println(clazz2 == clazz3);
System.out.println("通过Object 类中的 getClass() 获取的 Class 对象为：" + getPersonClass1());
System.out.println("通过静态方法 Class.forName() 获取的 Class 对象为：" + getPersonClass2());
System.out.println("通过类字面常量获取 Class 的对象为：" + getPersonClass3());
}
/**
* 通过 Object 类中的 getClass() 获取的 Class 对象
*
* @return
*/
public static Class getPersonClass1() {
return new Person().getClass();
}
/**
* 通过静态方法 Class.forName() 获取的 Class 对象
*
* @return
*/
public static Class getPersonClass2() {
Class clazz = null;
try {
clazz = Class.forName("step1.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return clazz;
}
/**
* 通过类字面常量获取 Class 的对象
*
* @return
*/
public static Class getPersonClass3() {
return Person.class;
}
}
文件二：
package step1;
/**
* 学员任务文件
*/
public class Reflect_stu {
public static void main(String[] args) {
System.out.println("通过Object 类中的 getClass() 获取的 Class 对象为：" + getPersonClass1());
System.out.println("通过静态方法 Class.forName() 获取的 Class 对象为：" + getPersonClass2());
System.out.println("通过类字面常量获取 Class 的对象为：" + getPersonClass3());
}
/**
* 通过 Object 类中的 getClass() 获取的 Class 对象
*
* @return
*/
public static Class getPersonClass1() {
/********** Begin *********/
Person person = new Person();
Class c = person.getClass();
return c;
/********** End *********/
}
/**
* 通过静态方法 Class.forName() 获取的 Class 对象
*
* 注意：Person 类的全路径为: step1.Person
*
* @return
*/
public static Class getPersonClass2() {
/********** Begin *********/
Class c = null;
String classname = "step1.Person";
try{
c = Class.forName(classname);
}catch(ClassNotFoundException e){
}
return c;
/********** End *********/
}
/**
* 通过类字面常量获取 Class 的对象
*
* @return
*/
public static Class getPersonClass3() {
/********** Begin *********/
Class c = Person.class;
return c;
/********** End *********/
}
}
第2关：利用反射分析类的能力
package step2;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
class Apple {
private String name;
public Apple(){}
public Apple(String name){}
public void setName(String name) {
this.name = name;
}
}
public class Reflect_stu {
public static void main(String[] args) {
// 请根据提供的 classPath 获取 step2.Apple 的 Class 对象， 请使用 Class.forName() 方法， 注意捕获异常
// 通关之后，你也可以修改 clasapath 为其他类路径，分析某个类的能力， 例如: java.util.Date
String classPath = "step2.Apple";
Class clazz = null;
/********** Begin *********/
try{
clazz = Class.forName(classPath);
}catch(ClassNotFoundException e){
}
/********** End *********/
printFields(clazz);
printConstructors(clazz);
printMethods(clazz);
}
/**
* 请打印类的每个域,输出格式为：修饰符 类型 变量名;
* @param clazz
*/
public static void printFields(Class clazz) {
/********** Begin *********/
Field[] f = clazz.getDeclaredFields();
for(Field ff:f){
Class type = ff.getType();
int mod = ff.getModifiers();
System.out.print(Modifier.toString(mod)+" ");
System.out.print(type.getName()+" ");
System.out.println(ff.getName()+";");
}
/********** End *********/
}
/**
* 打印构造函数,输出格式为：修饰符 方法名称（参数）
* @param clazz
*/
public static void printConstructors(Class clazz) {
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor constructor : constructors) {
Class[] paramTypes = constructor.getParameterTypes();
/********** Begin *********/
String name = constructor.getName();
String modifiers = Modifier.toString(constructor.getModifiers());
if (modifiers.length() > 0) {
System.out.print(modifiers + " ");
}
System.out.print(name + "(");
/********** End *********/
printParamTypes(paramTypes);
}
}
/**
* 请针对每个方法打印其签名，格式为：修饰符 返回值类型 方法名称(参数);
* @param clazz
*/
public static void printMethods(Class clazz) {
Method[] methos = clazz.getDeclaredMethods();
for (Method method : methos) {
Class[] paramTypes = null;
/********** Begin *********/
String name = method.getName();
Class returnType = method.getReturnType();
String modifiers = Modifier.toString(method.getModifiers());
System.out.print(modifiers+" "+returnType.getName() + " " + name + "(");
paramTypes = method.getParameterTypes();
/********** End *********/
printParamTypes(paramTypes);
}
}
/**
* 打印方法参数
* @param paramTypes
*/
private static void printParamTypes(Class[] paramTypes) {
for (int j = 0; j < paramTypes.length; ++j) {
if (j > 0) {
System.out.print(",");
}
System.out.print(paramTypes[j].getName());
}
System.out.println(");");
}
}
第3关：在运行时使用反射分析对象
package step3;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class Reflect_stu {
public static String toString(Object obj) {
Class cl = obj.getClass();
String r = "";
r += "[";
// 请获取所有 Field 并设置访问权限为 true
/********** Begin *********/
Field[] fields = cl.getDeclaredFields();
AccessibleObject.setAccessible(fields, true);
/********** End *********/
for (Field f : fields) {
// 此处 if，逻辑为判断 Field 域是否为非静态域
if (!Modifier.isStatic(f.getModifiers())) {
if (!r.endsWith("[")) r += ",";
r += f.getName() + "=";
try {
// 请获取域的类型及值
/********** Begin *********/
Class t = f.getType();
Object val = f.get(obj);
/********** End *********/
// isPrimitive() 用于判断是否为基本数据类型，若为基础数据类型直接拼接，否则递归调用 toString 方法
if (t.isPrimitive()) r += val;
else r += toString(val);
} catch (Exception e) {
e.printStackTrace();
}
}
}
r += "]";
return r;
}
public static void main(String[] args) {
Person person = new Person(88, 19, 175);
System.out.println(toString(person));
}
}
class Person {
public Integer weight;
private Integer age;
private Double height;
public Person(Integer weight, Integer age, double height) {
this.weight = weight;
this.age = age;
this.height = height;
}
}
第4关：利用反射进行方法调用
文件一
package step4;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Reflect_stu {
public static void main(String[] args) throws InvocationTargetException {
// 使用反射调用
Class clazz = null;
try {
clazz = Class.forName("step4.Apple");
/********** Begin *********/
Constructor cons = clazz.getConstructor();
Apple apple = (Apple) cons.newInstance();
Method method = clazz.getMethod("setPrice", double.class);
method.invoke(apple, 14);
Method getPrice = clazz.getMethod("getPrice");
System.out.println(getPrice.invoke(apple));
Method getTotal = clazz.getMethod("getTotal", double.class, int.class);
System.out.println(getTotal.invoke(apple, 20, 24));
/********** End *********/
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Apple {
private double price;
private int count;
public Apple() {
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public double getTotal(double price, int count) {
return price * count;
}
}
文件二
package step4;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Reflect_stu {
public static void main(String[] args) throws InvocationTargetException {
//使用反射调用
Class clazz = null;
try {
clazz = Class.forName("step4.Apple");
/********** Begin *********/
Apple apple = (Apple)clazz.newInstance();
apple.setPrice(14);
System.out.println(apple.getPrice());
System.out.println(apple.getTotal(20,24));
/********** End *********/
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Apple {
private double price;
private int count;
public Apple() {
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public double getTotal(double price, int count) {
return price * count;
}
}
3-11 Java高级特性 - JDBC（上）
第1关 JDBC连接数据库
package jdbc;
import java.sql.*;
public class jdbcConn {
public static void getConn() {
/********** Begin **********/
try {
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
/********** End **********/
/********** Begin **********/
Connection conn = null;
Statement statement = null;
//2.建立连接并创建数据库和表
String url = "jdbc:mysql://127.0.0.1:3306/";
String user = "root";
String password = "123123";
try{
conn = DriverManager.getConnection(url,user,password);
statement = conn.createStatement();
statement.executeUpdate("drop database if exists test");//执行sql语句
statement.executeUpdate("create database mysql_db");
statement.executeUpdate("use mysql_db");
String sql = "create table student("+
"id int not null,"+
"name varchar(20),"+
"sex varchar(4),"+
"age int)";
statement.executeUpdate(sql);
}catch (SQLException e){
e.printStackTrace();
}
/********** End **********/
finally {
try {
if(statement!=null)
statement.close();
if(conn!=null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
第2关 JDBC对表中数据的操作
package jdbc;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class jdbcInsert {
public static void insert(){
/********** Begin **********/
try {
//加载驱动
Class.forName("com.mysql.jdbc.Driver" );
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
/********** End **********/
Connection conn = null;
PreparedStatement statement = null;
/********** Begin **********/
//连接并插入数据
try{
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mysql_db","root","123123");
PreparedStatement s = conn.prepareStatement("insert into student values(?,?,?,?)");
s.setInt(1,1);s.setString(2,"张三");s.setString(3,"男");s.setInt(4,19);
s.executeUpdate();
s.setInt(1,2);s.setString(2,"李四");s.setString(3,"女");s.setInt(4,18);
s.executeUpdate();
s.setInt(1,3);s.setString(2,"王五");s.setString(3,"男");s.setInt(4,20);
s.executeUpdate();
s=conn.prepareStatement("select * from student");
ResultSet r = s.executeQuery();
while(r.next()){
System.out.println(r.getString(1)+" "+r.getString(2)+" "+r.getString(3)+" "+r.getString(4));
}
} catch (SQLException e) {
e.printStackTrace();
}
/********** End **********/
finally {
try {
if (statement != null)
statement.close();
if (conn != null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
第3关 JDBC事务
package jdbc;
import java.sql.*;
public class jdbcTransaction {
public static void transaction(){
try {
Class.forName("com.mysql.jdbc.Driver" );
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Connection conn = null;
PreparedStatement ps = null;
/********** Begin **********/
//连接数据库并开启事务
String url = "jdbc:mysql://localhost:3306/mysql_db";
try {
conn = DriverManager.getConnection (url,"root","123123" );
conn.setAutoCommit(false);//关闭自动提交开启事务
ps = conn.prepareStatement("insert into student(id,name,sex,age) values(4,'赵六','女',21)");
ps.executeUpdate();
conn.commit();//提交事务
ps = conn.prepareStatement("insert in student(id,name,sex,age) values(5,'钱七','男',18)");
ps.executeUpdate();
conn.commit();//提交事务
} catch (SQLException e) {
try {
//事务回滚
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
}
/********** End **********/
finally {
try {
if(ps!=null)
ps.close();
if (conn != null)
conn.close();
} catch (SQLException e1) {
e1.printStackTrace();
}
}
}
}
3-10 Java高级特性 - JDBC（下）
第1关 指定类型JDBC封装
package step1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import test.News;
public class JDBCUtils {
/**
* 连接数据库
*/
private static Connection getConnection() {
Connection conn=null;
/********** Begin **********/
String url="jdbc:mysql://localhost:3306/mysql_db";
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(url, "root","123123");
}catch (ClassNotFoundException e) {
e.printStackTrace();
}catch (SQLException e) {
e.printStackTrace();
}
/********** End **********/
return conn;
}
/**
* 更新数据方法
* @param news
* @throws SQLException
*/
public void update(News news) throws SQLException {
Connection conn = getConnection();
PreparedStatement ps = null;
/********** Begin **********/
String sql = "update news set title=?,author_name=? where id=?";
try{
ps = conn.prepareStatement(sql);
ps.setString(1, news.getTitle());
ps.setString(2, news.getAuthor_name());
ps.setInt(3, news.getId());
ps.executeUpdate();
}catch(SQLException e){
e.printStackTrace();
throw new SQLException("更新数据失败");
}finally{
close(null, ps, conn);
}
/********** End **********/
}
/**
* 查询所有数据
* @return
* @throws SQLException
*/
public List<News> findAll() throws SQLException {
Connection conn = getConnection();
PreparedStatement ps = null;
ResultSet rs = null;
News news = null;
List<News> newsList = new ArrayList<News>();
/********** Begin **********/
String sql = "select * from news";
try{
ps = conn.prepareStatement(sql);
rs = ps.executeQuery();
while(rs.next()){
news = new News();
news.setId(rs.getInt(1));
news.setTitle(rs.getString(2));
news.setAuthor_name(rs.getString(3));
newsList.add(news);
}
}catch(SQLException e){
e.printStackTrace();
throw new SQLException("查询所有数据失败");
}finally{
close(rs, ps, conn);
}
/********** End **********/
return newsList;
}
/**
* 删除方法
* @param id
* @throws SQLException
*/
public void delete(int id) throws SQLException{
Connection conn = getConnection();
PreparedStatement ps = null;
/********** Begin **********/
String sql = "delete from news where id=?";
try{
ps = conn.prepareStatement(sql);
ps.setInt(1,id);
ps.executeUpdate();
}catch(SQLException e){
e.printStackTrace();
throw new SQLException(" 删除数据失败");
}
finally{
close(null, ps, conn);
}
/********** End **********/
}
/**
* 增加对象
* @param news
* @throws SQLException
*/
public void insert(News news) throws SQLException {
Connection conn = getConnection();
PreparedStatement ps = null;
String sql = "insert into news(id,title,author_name)values(?,?,?)";
try{
ps = conn.prepareStatement(sql);
ps.setInt(1, news.getId());
ps.setString(2, news.getTitle());
ps.setString(3, news.getAuthor_name());
ps.executeUpdate();
}catch(SQLException e){
e.printStackTrace();
throw new SQLException("添加数据失败");
}finally{
close(null, ps, conn);
}
}
/**
* 根据id查询对象
* @param id
* @return
* @throws SQLException
*/
public News findById(int id) throws SQLException {
Connection conn = getConnection();
PreparedStatement ps = null;
ResultSet rs = null;
News news = null;
String sql = "select * from news where id=?";
try{
ps = conn.prepareStatement(sql);
ps.setInt(1, id);
rs = ps.executeQuery();
if(rs.next()){
news = new News();
news.setId(id);
news.setTitle(rs.getString(2));
news.setAuthor_name(rs.getString(3));
}
}catch(SQLException e){
e.printStackTrace();
throw new SQLException("根据ID查询数据失败");
}
finally{
close(rs, ps, conn);
}
return news;
}
/**
* 关闭数据库连接
* @param rs
* @param ps
* @param conn
*/
public static void close(ResultSet rs,PreparedStatement ps,Connection conn){
try {
if(rs!=null)rs.close();
if(ps!=null)ps.close();
if(conn!=null)conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
第2关 泛型JDBC封装
package step2;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class JDBCUtils {
private static Connection getConnection() {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
String url="jdbc:mysql://localhost:3306/mysql_db";
Connection conn=null;
try {
conn = DriverManager.getConnection(url, "root","123123");
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
/**
* 类名对应表，属性对应字段
* @param obj 传入的对象
* @return
*/
public void insert(Object obj) {
Connection conn = getConnection(); //连接数据库
PreparedStatement ps = null;
/********** Begin **********/
//获取obj的Class
Class<?> c = obj.getClass();
//利用StringBuffer进行插入SQL语句的构造
StringBuffer sb1 = new StringBuffer("insert into "+ c.getSimpleName() +"("); //通过反射获取类名映射表名
StringBuffer sb2 = new StringBuffer(" values("); //注意前面要多加一个空格 否则sql将连在一起
Field[] field = c.getDeclaredFields(); //获取对象的属性数组
for(int i = 0; i < field.length; i++) { //遍历属性构造SQL语句
if(i != field.length-1) {
sb1.append(field[i].getName()).append(",");
sb2.append("?,");
}else {
sb1.append(field[i].getName()).append(")");
sb2.append("?);");
}
}
String sql = sb1.append(sb2).toString();
try {
ps = conn.prepareStatement(sql);
for(int i = 0; i < field.length; i++) {
field[i].setAccessible(true); //设置属性的可访问性，可以访问私有属性
try { //通过Field的get(Object)方法获取Object对象的属性值
ps.setObject(i+1, field[i].get(obj)); //对预编译的SQL语句中的？进行赋值
} catch (Exception e) {
e.printStackTrace();
}
}
ps.execute(); //执行SQL
}
/********** End **********/
catch (SQLException e) {
e.printStackTrace();
}finally {
close(null,ps,conn);
}
}
/**
* 通过对象的Class获取对应表中的所有记录
* @param c
* @return
*/
public <T> List<T> selectAll(Class<T> c) {
Connection conn = getConnection();
List<T> list = new ArrayList<T>();
PreparedStatement ps = null;
ResultSet rs = null;
/********** Begin **********/
String sql = "select * from "+ c.getSimpleName()+";"; //通过反射获取类名对应表名构造SQL语句
Field[] field = c.getDeclaredFields(); //通过反射获取所有属性
try {
ps = conn.prepareStatement(sql);
rs = ps.executeQuery();
while(rs.next()) {
T obj = c.newInstance(); //通过反射构造一个T类型的实例
for(int i = 0; i < field.length; i++) {
field[i].setAccessible(true); //设置可以访问私有属性
field[i].set(obj, rs.getObject(field[i].getName())); //通过属性名获取结果集中的值赋值到实例对象中
}
list.add(obj); //将实例对象添加到list集合
}
}
/********** End **********/
catch (Exception e) {
e.printStackTrace();
}finally {
close(rs,ps,conn);
}
return list;
}
/**
* 通过主键(默认第一个属性)删除对象
* @param obj
* @return
*/
public void delete(Object obj) {
Connection conn = getConnection();
PreparedStatement ps = null;
/********** Begin **********/
//获取obj的Class
Class<?> c = obj.getClass();
//构造删除的SQL语句
StringBuffer sb = new StringBuffer("delete from ");
sb.append(c.getSimpleName()).append(" where ");
//获取对象属性数组
Field[] field = c.getDeclaredFields();
//设置第一个属性的可访问性
field[0].setAccessible(true);
//获取第一个属性的属性名构造删除sql
sb.append(field[0].getName()).append("=?");
String sql = sb.toString();
try {
ps = conn.prepareStatement(sql);
ps.setObject(1, field[0].get(obj));
ps.execute();
}
/********** End **********/
catch (Exception e) {
e.printStackTrace();
}finally {
close(null,ps,conn);
}
}
/**
* 模拟jdbc的更新操作，默认第一个属性为主键
* @param obj
* @return
*/
public void update(Object obj) {
Class<?> c = obj.getClass();//获取obj的Class
StringBuffer sb = new StringBuffer("update "+ c.getSimpleName() +" set ");//利用StringBuffer进行修改SQL语句的构造
Field[] field = c.getDeclaredFields();//通过反射获取对象的属性数组
for(int i = 1; i < field.length; i++) {
if(i != field.length-1) { //判断是否为最后一个属性，若不是则后增加逗号
sb.append(field[i].getName()).append("=?,");
}else { //若为最后一个属性则添加 where
sb.append(field[i].getName()).append("=? where ");
}
}
//默认第一个属性为主键，切更改时通过第一个属性进行更改
sb.append(field[0].getName() + "=?");
String sql = sb.toString()+";";
Connection conn = getConnection();//获取连接对象
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(sql);
for(int i = 1; i < field.length; i++) {
field[i].setAccessible(true);//设置可以访问私有属性
ps.setObject(i, field[i].get(obj));//对预编译的SQL语句中的 ? 进行赋值
}
field[0].setAccessible(true);
ps.setObject(field.length, field[0].get(obj));
ps.execute();//执行sql语句
} catch (Exception e) {
e.printStackTrace();
}finally {
close(null,ps,conn);//关闭连接数据
}
}
public static void close(ResultSet rs,PreparedStatement ps,Connection conn){
try {
if(rs!=null) rs.close();
if(ps!=null) ps.close();
if(conn!=null) conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
public <T> Object selectById(Class<T> c,int id) {
String sql = "select * from "+ c.getSimpleName()+" where id="+id;
Field[] field = c.getDeclaredFields();
Connection conn = getConnection();
PreparedStatement ps = null;
ResultSet rs = null;
Object obj=null;
try {
ps = conn.prepareStatement(sql);
rs = ps.executeQuery();
obj = c.newInstance();
while(rs.next()) {
for(int i = 0; i < field.length; i++) {
field[i].setAccessible(true);
field[i].set(obj, rs.getObject(field[i].getName()));
}
}
} catch (Exception e) {
e.printStackTrace();
}finally {
close(rs,ps,conn);
}
return obj;
}
}
3-12 Java高级特性 - JDBC练习题
第1关 JDBC更新员工密码
package step1;
import java.sql.*;
public class UpdatePass {
// 修改数据
public static void updateDB() {
/********* Begin *********/
// 第一步：加载驱动
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e1) {
// TODO 自动生成的 catch 块
e1.printStackTrace();
}
// 第二步：建立连接, "root"和"123123"是针对MySQL设置了用户名(root)和密码(123123)的情况
// 127.0.0.1:3306是mysql服务器地址及端口 数据库编码格式设置为utf-8
Connection conn = null;
PreparedStatement ps = null;
try {
String url = "jdbc:mysql://127.0.0.1:3306/tsgc?useUnicode=true&characterEncoding=utf8";
String user = "root";
String password = "123123";
conn = DriverManager.getConnection(url, user, password);
// 第三步：建立statement对象
String sql = "update employee set password='hello' where sex='女'";
ps = conn.prepareStatement(sql);
// 第四步：修改数据
ps.execute();
// 第五步：关闭statement对象和连接对象
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} finally {
try {
ps.close();
conn.close();
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
/********* End *********/
}
}
第2关 JDBC查询员工信息
package step1;
import java.sql.*;
public class QueryPass {
// 查询数据代码不用上实验报告
public static void queryDB() {
/********* Begin *********/
Connection conn = null;
PreparedStatement ps = null;
try {
// 第一步：加载驱动
Class.forName("com.mysql.jdbc.Driver");
// 第二步：建立连接, "root"和"123123"是针对MySQL设置了用户名(root)和密码(123123)的情况
// 127.0.0.1:3306是mysql服务器地址及端口 数据库编码格式设置为utf-8
String url = "jdbc:mysql://127.0.0.1:3306/tsgc?useUnicode=true&characterEncoding=utf8";
String user = "root";
String password = "123123";
conn = DriverManager.getConnection(url, user, password);
// 第三步：建立statement对象
String sql = "select * from employee";
ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
// 第四步：查询数据
while (rs.next()) {
String no = rs.getString(1);
String name = rs.getString(2);
Object password1 = rs.getString(3);
Object sex = rs.getString(4);
double salary = rs.getDouble(5);
System.out.println("no:" + no + "\tname:" + name + "\tpassword:" + password1 + "\tsex:" + sex
+ "\tsalary:" + salary);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 第五步：关闭statement对象和连接对象
try {
ps.close();
conn.close();
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
/********* End *********/
}
}