普通网友

头歌 Java实训答案全ac代码请善用目录功能

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 *********/

}

第二关

package key;
/********* Begin /
public class HelloWorld {
public static void main(String[] args){
System.out.println(“hello eduCoder”);
}
}
/ End *********/

第三关

package chapter2;
/********* Begin *********/
public class HelloWorld {

String userName = "张三";

public static void main(String[] args){
	System.out.println("hello eduCoder");
}

}

/********* End *********/

第四关

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.net”);
//System.out.println(“.net”);
//System.out.println(“www”);
}
/ End *********/
}

变量与数据类型

第一关

package chapter2.step1;

public class HelloWorld{
public static void main(String[] args){
/********* Begin *********/

String love=“www.educoder.net”;
System.out.println(love);
/********* End *********/
}
}
第二关

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);
}
}

第三关

package chapter2;

public class JavaDataType1 {
public static void main(String[] args) {

    /********* Begin *********/
                String name ="张无忌";                 //在本行定义字符串变量name
    
                int age =23;//在本行定义年龄变量 age
    
                String sex="男";//在本行定义性别变量 sex
    
                float score= 66.6f; //在本行定义分数变量  score
    
    /********* End *********/


    System.out.println(name + age + "岁" + "性别：" + sex + "这次考了" + score + "分");
}

}

第四关

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 *********/
}
```
}
第五关

package chapter2.step7;
/********* Begin *********/
import java.util.Scanner;

public class HelloWorld{
public static void main(String[] args){
System.out.println(“请录入嫦娥个人信息：”);
System.out.println(“请输入姓名：”);
Scanner input = new Scanner(System.in);
String name = input.next();
System.out.println(“请输入年龄：”);
int age = input.nextInt();
System.out.println(“请输入性别：”);
String sex = input.next();
System.out.println(“请输入体重：”);
double weight = input.nextDouble();
System.out.println(“请输入地址：”);
String address = input.next();
System.out.println(“请输入是否已婚：”);
String hun = input.next();
System.out.println(“信息如下：”);
System.out.println(" “+“姓名：”+name);
System.out.println(” “+“年龄：”+age+“岁”);
System.out.println(” “+“性别：”+sex);
System.out.println(” “+“体重：”+weight+“kg”);
System.out.println(” “+“地址：”+address);
System.out.println(” "+“婚否：”+hun);
```
	/********* End *********/
}
```
}

运算符和表达式

第一关

package step1;
import java.util.Scanner;

public class Cal {
public static void main(String[] args) {
/start/
Scanner sc= new Scanner(System.in);
int a,b;
System.out.print("请输入第一个整数
");
a=sc.nextInt();
System.out.print("请输入第二个整数
");
b=sc.nextInt();
System.out.println(“两数相加的结果为：”+(a+b));
System.out.println(“两数相减的结果为：”+(a-b));
System.out.println(“两数相乘的结果为：”+(a*b));
System.out.println(“两数相除的结果为：”+(a/b));
System.out.println(“两数取余数的结果为：”+(a%b));
sc.close();
```
    /*********end*********/
}
```
}

第二关

package step2;
import java.util.Scanner;

public class Relative {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);

    /*********start*********/        
    int a=sc.nextInt();
    int b=sc.nextInt();
    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>a));
    System.out.println("b<=a="+(b

 
    第三关
 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(a && b);  
    
    System.out.println( c || b );    
    
    System.out.println( a^b  );        
    /*********end  *********/
}
 }
  
    第四关
 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 && year % 100 != 0) || (year % 400 == 0)) ? true : false;
    
    System.out.println(year + "年是否为闰年:" + result);
    
    /********end********/
}
 }
  
    第五关
 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*****/
}
 }

 
   
   
  分支结构 
   
    第一关
 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 score = input.nextInt();
 if (score >= 85){
 System.out.println(“优，非常棒！”);
 }
 else {
 System.out.println(“良，下次加油！”);
 }
 	/******end******/
}
 }
  
    第二关
 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);
 /start/
 int score = sc.nextInt();
 if (score >= 90){
 System.out.println(“*****五星成绩”);
 }
 else if (score >= 80 && score < 90){
 System.out.println(“****四星成绩”);
 }
 else if (score >= 70 && score < 80){
 System.out.println(“***三星成绩”);
 }
 else if (score >= 60 && score < 70){
 System.out.println(“**俩星成绩”);
 }
 else{
 System.out.println(“无星成绩”);
 }
 	/******end******/
}
 }
  
    第三关
 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 3:
        System.out.println(input+"月是春天");
        break;
        case 4:
        System.out.println(input+"月是春天");
        break;
        case 5:
        System.out.println(input+"月是春天");
        break;
        case 6:
        System.out.println(input+"月是夏天");
        break;
        case 7:
        System.out.println(input+"月是夏天");
        break;
        case 8:
        System.out.println(input+"月是夏天");
        break;
        case 9:
        System.out.println(input+"月是秋天");
        break;
        case 10:
        System.out.println(input+"月是秋天");
        break;
        case 11:
        System.out.println(input+"月是秋天");
        break;
        case 12:
        System.out.println(input+"月是冬天");
        break;
        case 1:
        System.out.println(input+"月是冬天");
        break;
        case 2:
        System.out.println(input+"月是冬天");
        break;
        default :
        System.out.println("输入错误");
        break;
    }

	
	/*****end*****/
	
}
 }
  
    第四关
 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*****/
	}
 }
  
   
   
   
  循环结构基础 
   
    第一关
 package step1;
 public class HelloWorld {
 public static void main(String[] args) {
     /*****start*****/
    int F=0;
    while(F<6){
        F++;
        System.out.println("做了"+ F +"个俯卧撑");    
    }

    /*****end*****/

}
 }
  
    第二关
 package step2;
 public class HelloWorld {
 public static void main(String[] args) {
     /*****start*****/
    int sum=0;
    int n=0; 
    while(n<100) {
         n++;
         sum+=n; 
         }
    
    System.out.println("1到100相加的结果为"+sum);
    /*****end*****/

}
 }
  
    第三关
 package step3;
 public class HelloWorld {
 public static void main(String[] args) {
 int count= 0; //定义变量存储6的倍数出现的次数
 /start/
 int i=1;
 do{
 if(i%6==0){
 count++;
 i++;
 }i++;
 }while(i<=100);
 /end/
 System.out.println(“6的倍数出现的次数为：” + count);
 }
 }
  
    第四关
 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 + "是偶数");
        }
        else {
            System.out.println(i + "是奇数");
        }    
        if( i == 13 ) {
            break;
        }
        
        /*****end*****/
    }
    
}
 }
  
    第五关
 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：”);
 //获取输入的整数N
 int sum = 1;
 /start/
 for(int N = sc.nextInt(); N>0; N–) {
 sum=sum*N;
 }
     /*****end*****/
    
    System.out.println("自然数N的阶乘为" + sum);
    
}
 }
  
   
   
   
  循环结构进阶 
   
    第一关
 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/
 }
 }
  
    第二关
 package step2;
 public class ForPractice2 {
 public static void main(String[] args) {
 /start/
 //在这里打印出正三角形
 for(int x=0;x<10;x++){
 for(int y=0;y<=x;y++){
 System.out.print(““);
 }
 System.out.println();
 }
 System.out.println(”——————————我是华丽的分界线——————————“);
 //在这里打印出倒三角形
 for(int x=10;x>0;x–){
 for(int y=x;y>0;y–){
 System.out.print(””);
 }
 System.out.println();
 }
 /end/
 }
 }
  
    第三关
 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+”="+ij+” ");
 }
 System.out.println();
 }
 /end/
 }
 }
  
    第四关
 package step4;
 import java.util.Scanner;
 public class ForPractice4 {
 public static void main(String[] args) {
 /start/
 int money = 1000;
 int cash = 0;
 int isornot = 0;
 Scanner input =new Scanner(System.in);
 System.out.println(“欢迎使用中国人民银行ATM取款机”);
 do {
 System.out.println(“输入取款金额：”);
 cash = input.nextInt();
 if(money >=cash)
 {
 money=money-cash;
 }
 else {
 System.out.println(“目前余额：”+money+“无法满足您的取款需求！”);
 continue;
 }
 System.out.println(“剩余金额：”+money+“，是否继续（‘1’：结束，‘2’：继续）：”);
 isornot=input.nextInt();
 if(isornot==1)
 {
 break;}
 }while(money>0);
 System.out.println(“取款结束！”);
     /*****end*****/
}
 }
  
   
   
   
  Java循环与分支语句编程练习 
   
    第一关
 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 temp;
	if (x > y) {
		temp = y;
		y = x;
		x = temp;
	}
	if (x > z) {
		temp = z;
		z = x;
		x = temp;
	}
	if (y > z) {
		temp = z;
		z = y;
		y = temp;
	}


    /**********end**********/
	System.out.print("x:"+x+" y:"+y+" z:"+z);
	
}
 }
  
    第二关
 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
 }
 
 
    第三关
 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();
 	/*
	 i（行号）      空格数量（lineNum－i）　   星星数量 （２＊i　－１）    
		1                    5                      1
		2                    4                      3
		3                    3                      5
		4                    2                      7
		5                    1                      9
		6                    0                      11

	
	*/

	//通过外循环控制需要打印的行数
	for(int i=1;i<=lineNum;i++){

      /**********begin**********/
        
	
	  //通过内循环（1）控制需要打印的空格   
		for(int j=1;j<=lineNum - i;j++){
          System.out.print(" ");
      }
      //通过内循环（2）控制需要打印的星星的数量
      for(int j=1;j<= 2*i - 1;j++){
         System.out.print("*");
      }
	  


      /**********end**********/

	  //当前行中的空格以及星星打印完成之后进行换行操作 
 表示换行
 System.out.print("
 ");
 	}


	
}
 }
  
    第四关
 package step2;
 public class FindZhiShu {
 public static void main(String[] args) {
	   /*
	     打印输出质数的时候务必按照如下格式：System.out.print(质数+" ")；
	     使用print进行打印同时被打印输出的质数后加上一个空格，
	     以便于与平台提供的结果格式保持一致！
        */

	   /**********begin**********/
 System.out.print("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**********/	
}
 }
  
  
 
   
   
  数组基础 
   
    第一组
 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 **********/
}
 }
  
    第二关
 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);
}
 }
  
    第三关
 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 **********/
}
 }
  
    第四关
 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
 }
 
 
  
 
   
   
  数组进阶 
   
    第一关
 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
 }
 
 
    第二关
 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 **********/
}
 }
  
    第三关
 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);
}
 }
  
    第四关
 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 **********/
 }
 }
  
    第五关
 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 **********/
 }
 }
  
  
 
   
   
  方法的使用 
   
    第一关
 package step1;
 public class HelloWorld {
 /********** Begin **********/
 //定义一个方法，用来和老师打招呼

/********** End **********/	
public static void main(String[] args) {
    helloEducoder();
}
public static void helloEducoder() {

        System.out.println("hello teacher!");
    }

	/********** Begin **********/	
	
    //调用方法 

	/********** End **********/
 }
  
    第二关
 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 **********/
}
 }
  
    第三关
 package setp9;
 import java.util.Scanner;
 public class HelloWorld {
 public static void main(String[] args) {
 HelloWorld hello = new HelloWorld();
 Scanner sc = new Scanner(System.in);
 int score1 = sc.nextInt(); //第一门成绩
 int score2 = sc.nextInt(); //第二门成绩
 /********** Begin /
 // 调用方法，传入两门课程的成绩
 hello.calcAvg(score1,score2);
 / End **********/
 }
 /*
 * 功能：计算两门课程考试成绩的平均分并输出平均分
 * 定义一个包含两个参数的方法，用来传入两门课程的成绩
 */

/********** Begin **********/
public static void calcAvg(int score1,int score2){
 int avg=(score1+score2)/2;
 System.out.print("平均分："+avg);
}
/********** End **********/
 }
  
    第四关
 package step3;
 import java.util.Scanner;
 public class HelloWorld {
 public static void main(String[] args) {
 HelloWorld hello=new HelloWorld();
 Scanner sc = new Scanner(System.in);
 int i = sc.nextInt(); //获取第一个输入的整数
 int j = sc.nextInt(); //获取第二个输入的整数
 int max = hello.getMax(i,j);
 /********** Begin **********/
 //在这里调用方法获取返回值
     System.out.println( i+"和"+j+"比较，最大值是："  + max  );
	/********** End **********/
}

/*在这里创建getMax方法，以两个整数作为参数，返回两个整数中较大的值*/

/********** Begin **********/
public static int getMax(int i,int j){
    if(i>j) return i;
    else return j;
       }


/********** End **********/
 }
  
    第五关
 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 for(int j=i+1;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 System.out.print(data[i]+“, “);
 System.out.print(data[3]+”]”);
 System.out.println();
 //返回数组中元素的个数
 return data.length;
 }
/********** End **********/
 }
  
    第六关
 package setp15;
 /** 
     
      @author tangzhiqiang
  
      @date 2018-04-25 22:31
 */
 public class HelloWorld {
 public static void main(String[] args) {
  /********** 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 id){
 System.out.println(“带有一个整型参数的print方法，参数值为：”+id);
 }
 /********** End **********/
 }
  
    第七关
 package setp17;
 import java.util.Arrays;
 import java.util.Scanner;
 public class HelloWorld {
 /********** Begin /
 /
 * 第一题：定义一个方法 接收两个整数类型的参数 a和b，返回两个数的和 返回值类型为int 方法名为：getSum
 /
 public static int getSum(int a ,int b){
 int sum = a + b;
 return sum;
 }
 /
 * 第二题： 定义一个方法 接收三个double类型参数a，b，c， 返回这三个数的平均值 返回值类型为double 方法名为：getAvg
 /
 public static double getAvg(double a ,double b,double c){
 double avg = (a + b + c) / 3;
 return avg;
 }
 /
 * 第三题： 定义一个方法 接收两个参数 a 和b 打印a行 b列的一个矩形 不需要返回值 方法名为：printRect
 /
 public static void printRect(int a , int b){
 for (int i = 1 ; i <= a ;i++) {
 for (int k = 1 ; k <= b;k++){
 System.out.print("");
 }
 System.out.println();
 }
 }
 /
 * 第四题：定以一个方法，接收整形数组 为参数 对这个数组进行升序排序 最后输出该数组 不需要返回值 方法名为 sortArr
 /
 public static void sortArr(int[] arr){
 for(int i = 0; i< arr.length-1;i++){
 for(int j = i+1; j< arr.length;j++){
 if(arr[i] > arr[j]){
 int tmp = arr[i];
 arr[i] = arr[j];
 arr[j] = tmp;
 }
 }
 }
 for(int i = 0; i< arr.length;i++){
 System.out.println(arr[i]);
 }
 }
 /
 * 第五题
 * 你只需要实现for 循环括号的内容就可 ，打印语句系统已经给你完成
 /
 public static void Print99() {
 for (int i = 1 ; i<=9;i++) {
 for (int j = 1;j <= i ;j++) {
 System.out.print(j + " * " + i + " = " + i * j + " ");
 }
 System.out.println();
 }
 }
 /****** End **********/
 }
  
   
   
   
  类与对象 
   
    第一关
 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(“叼着骨头跑”);
 }
 }
  
    第二关
 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 **********/
  
    第三关
 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 **********/
 }
  
    第四关
  
   
  文件一 
  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 **********/	
	}
}
 
  文件二 
  /********** Begin **********/
//在这里添加包名  step4
package step4;
//创建类 添加属性和方法
public class WuMingFen{
    String theMa;
    int quantity;
    boolean likeSoup;
    public WuMingFen(){
 
    }
public WuMingFen(String theMa, int quantity, boolean likeSoup){
    this.theMa = theMa;
    this.quantity = quantity;
    this.likeSoup = likeSoup;
}
public WuMingFen(String theMa, int quantity){
    this.theMa = theMa;
    this.quantity = quantity;
}
public void check(){
    System.out.println("面码：" + theMa + "，粉的份量：" + quantity + "两，是否带汤：" + likeSoup);
}
}
 
   
    第五关
 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 **********/
 }
  
   
   
   
  封装继承多态 
   
    第一关
 package case1;
 public class TestPersonDemo {
 public static void main(String[] args) {
 /********* begin /
 // 声明并实例化一Person对象p
 Person p = new Person();
 // 给p中的属性赋值
 p.setName(“张三”);
 p.setAge(18);
 // 调用Person类中的talk()方法
 p.talk();
 / end /
 }
 }
 // 在这里定义Person类
 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;
 }
 void talk() {
 System.out.println(“我是：” + name + “，今年：” + age + “岁”);
 }
 / end *********/
 }
  
    第二关
 package case2;
 public class extendsTest {
 public static void main(String args[]) {
 // 实例化一个Cat对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
 /********* begin /
 Cat cat= new Cat();
 cat.name=“大花猫”;
 cat.age=6;
 cat.voice();
 cat.eat();
 System.out.println(cat.name+cat.age+“岁”);
 / end *********/
     // 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
    /********* begin *********/
     Dog dog= new Dog();
      dog.name="大黑狗";
      dog.age=8;
      dog.voice();
      dog.eat();
      System.out.println(dog.name+dog.age+"岁");
    /********* end *********/

}
 }
 class Animal {
 /********* begin *********/
 protected String name;
 protected 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 ;
 }
/********* end *********/
 }
 class Cat extends Animal {
 // 定义Cat类的voice()和eat()方法
 /********* begin /
 public void voice(){
 System.out.println(name+“喵喵叫”);
 }
 public void eat(){
 System.out.println(name+“吃鱼”);
 }
 / end *********/
 }
 class Dog extends Animal {
 // 定义Dog类的voice()和eat()方法
 /********* begin /
 public void voice(){
 System.out.println(name+“汪汪叫”);
 }
 public void eat(){
 System.out.println(name+“吃骨头”);
 }
 / end *********/
 }
  
    第三关
 package case3;
 public class superTest {
 public static void main(String[] args) {
 // 实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出信息
 /********* begin *********/
 Person p= new Person();
 p.setName(“张三”);
 p.setAge(18);
 p.talk();
 Student stu= new Student();
    stu.school="哈佛大学";
   
   System.out.println("，学校："+stu.school);

    /********* end *********/
}
 }
 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;
 }

 public void talk(){
     System.out.print("姓名："+name+"，年龄："+age);
 }
/********* end *********/
 }
 class Student extends Person {
 /********* begin *********/
 public String school;
 public String getSchool(){
 return school;
 }
 public void setSchool(String name){
    this.school= school;
}
/********* end *********/
 }
  
    第四关
 package case4;
 public class overridingTest {
 public static void main(String[] args) {
 // 实例化子类对象s，调用talk()方法打印信息
 /********* begin /
 Student stu=new Student();
 stu.talk(“张三”,18,“哈佛大学”);
 / end *********/
 }
 }
 class Person {
 /********* begin /
 String name;
 int age;
 protected void talk(String name, int age){
 this.name=name;
 this.age=age;
 System.out.print(“我是：”+this.name+“，今年：”+this.age);
 }
 / end *********/
 }
 class Student extends Person {
 /********* begin *********/
 String school;

public void talk(String name,int age,String school){
    
        super.talk("张三",18);
        
    this.school=school;
    System.out.println("岁，我在"+this.school+"上学");
}
/********* end *********/
 }
  
    第五关
 package case5;
 public class abstractTest {
 public static void main(String[] args) {
 /********* begin /
 // 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
 Student stu=new Student(“张三”,20,“学生”);
 Worker wor=new Worker(“李四”,30,“工人”);
 // 分别调用各自类中被复写的talk()方法 打印信息。
 stu.talk();
 wor.talk();
 / end *********/
 }
 }
 // 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
 abstract class Person {
 /********* begin /
 protected String name;
 protected int age;
 protected String occupation;
 Person(String name,int age,String occupation){
 this.name=name;
 this.age=age;
 this.occupation=occupation;
 }
 abstract void talk();
 / end *********/
 }
 // Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
 class Student extends Person {
 /********* begin *********/
    Student(String name,int age,String occupation) { 
     super(name,age,occupation);
   }
 void talk(){
     System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+ occupation+"！");
 }
/********* end *********/
 }
 // Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
 class Worker extends Person {
 /********* begin *********/
     Worker(String name,int age,String occupation) { 
     super(name,age,occupation);
   }
     
 void talk(){
     System.out.println("工人——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
 }
/********* end *********/
 }
  
    第六关
 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方法,不可以重写
 class Bike1 {
 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”);
 }
 }
  
    第七关
 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=“学生”;
 abstract void talk();
 / end *********/
 }
 // Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
 class Student implements Person {
 /********* begin /
 public void talk(){
 System.out.println(“学生——>姓名：”+name+“，年龄：”+age+“，职业：”+occupation+“！”);
 }
 / end *********/
 }
  
    第八关
 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();
    if(a instanceof Dog){
        
    }else if(a instanceof Cat){
        
    }else{
        
    }
}
    /********* 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 *********/
 }
  
   
   
   
  封装继承多态的综合练习 
   
    第一关
 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 {
 /********* begin /
 public abstract void talk();
 public abstract void eat();
 private String name;
 private String 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;
 }
 public Pet(String name,String sex){
 this.name=name;
 this.sex=sex;
 }
 / end *********/
 }
 // Dog类继承自Pet类 封装属性color
 // 构造函数初始化name、sex和color
 // 实现自己的talk()方法和eat()方法
 // talk()输出’名称：name，性别：sex，颜色：color，汪汪叫’
 // eat()输出’name吃骨头’
 class Dog extends Pet {
 /********* begin *********/
 private String color;
 public String getcolor(){
 return color;
 }
 public void setcolor(String color){
 this.color=color;
 }
 public Dog(String name,String sex,String color){
 super(name,sex);
 sex=super.getname();
 name=super.getname();
 this.color=color;
 }
 public void talk(){
 System.out.println(“名称：”+super.getname()+“，性别：”+super.getsex()+“，颜色：”+color+“，汪汪叫”);
 }
 public void eat(){
 System.out.println(super.getname()+“吃骨头！”);
 }
 /********* end *********/
 }
 // Cat类继承自Pet类 封装属性weight
 // 构造函数初始化name、sex和weight
 // 实现自己的talk()方法和eat()方法
 // talk()输出’名称：name，性别：sex，体重：weight kg，喵喵叫’
 // eat()输出’name吃鱼’
 class Cat extends Pet {
 /********* begin /
 / begin *********/
 private double weight;
 public double getweight(){
 return weight;
 }
 public void setweight(double weight){
 this.weight=weight;
 }
 public Cat(String name,String sex,double weight){
 super(name,sex);
 sex=super.getname();
 name=super.getname();
 this.weight=weight;
 }
 public void talk(){
 System.out.println(“名称：”+super.getname()+“，性别：”+super.getsex()+“，体重：”+weight+“kg，喵喵叫”);
 }
 public void eat(){
 System.out.println(super.getname()+“吃鱼！”);
 }
 /********* end *********/
 }
  
    第二关
 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 *********/
 }
  
    第三关
 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 /
 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;
 }
 public Person(String name,int age){
 this.name=name;
 this.age=age;
 }
 public void sleep(){
 System.out.println(“人都是要睡觉的”);
 }
 abstract void eat();
 / end *********/
 }
 // 定义运动员Player（抽象类）继承自Person类
 // 无参构造函数
 // 有参构造函数初始化name和age
 // 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
 abstract class Player extends Person {
 /********* begin /
 public Player(String name,int age){
 super(name,age);
 name=super.getname();
 age=super.getage();
 }
 abstract void study();
 / end *********/
 }
 // 定义教练Coach（抽象类）继承自Person类
 // 无参构造函数
 // 有参构造函数初始化name和age
 // 教练教的不一样 定义抽象方法teach()
 abstract class Coach extends Person {
 /********* begin /
 public Coach(String name,int age){
 super(name,age);
 name=super.getname();
 age=super.getage();
 }
 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);
 name=super.getname();
 age=super.getage();
 }
 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 /
 public BasketballPlayer(String name,int age){
 super(name,age);
 name=super.getname();
 age=super.getage();
 }
 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);
 name=super.getname();
 age=super.getage();
 }
 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);
 name=super.getname();
 age=super.getage();
 }
 public void eat(){
 System.out.println(“篮球教练吃羊肉，喝羊奶”);
 }
 public void teach(){
 System.out.println(“篮球教练教如何运球和投篮”);
 }
 / end *********/
 }
  
   
   
   
  Java中的异常 
   
    第一关
 package step2;
 import java.util.Scanner;
 public class Task {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int num1 = sc.nextInt();
 int num2 = sc.nextInt();
 /********* Begin *********/
 try{
 System.out.println(num1/num2);
 }catch(ArithmeticException e){
 System.out.print(“除数不能为0”);
 }
 	/********* End *********/
}
 }
  
    第二关
 package step3;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 public class Task {
 /********* Begin /
 //请在合适的部位添加代码
 public static void main(String[] args)throws FileNotFoundException { 
 test();
 }
 public static void test() throws FileNotFoundException {
 File file = new File(“abc”);
 if(!file.exists()){ //判断文件是否存在
 //文件不存在，则 抛出 文件不存在异常
 throw new FileNotFoundException(“该文件不存在”);
 }else{
 FileInputStream fs = new FileInputStream(file);
 }
 }
 / End *********/
 }
  
    第三关
 package step4;
 import java.util.Scanner;
 public class Task {
 /********* Begin /
 public static void main(String[] args)throws MyException {
 Scanner sc = new Scanner(System.in);
 String username = sc.next();
 //判断用户名
 if(username.length()❤️){
 throw new MyException(“用户名小于三位Exception”);
 }
 else{
 System.out.println(“用户名格式正确”);
 }
 }
 }
 class MyException extends Exception{
 public MyException(){}
 public MyException(String msg){
 super(msg);
 }
 }
 / End *********/
  
   
   
   
  String类 
   
    第一关
 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 *********/
}
 }
  
    第二关
 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
 }
 
 
    第三关
 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 **********/
 }
 }
  
    第四关
 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;
 }
 }
  
  
 
   
   
  常用类 
   
    第一关
 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§) {
 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;
 }
 }
  
    第二关
 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(ab);
 System.out.println(ac);
 System.out.println(bc);
 System.out.println(a.equals(b));
 System.out.println(str1==str2);
 System.out.println(str1.equals(str2));
 /********* End *********/
 }
 }
  
    第三关
 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 *********/
 }
 }
  
    第四关
 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 *********/
 }
 }
  
    第五关
 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 *********/
 }
 }
  
    第六关
 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 *********/
 }
 }
  
   
   
   
  包装类 
   
    第一关
 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 **********/
 }
 }
  
    第二关
 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 **********/ 
 }
 }
  
    第三关
 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 **********/
 }
 }
  
   
   
   
  集合框架（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 **********/
 }
 }
  
    第二关
 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 System.out.println(list.get(i));
 } 
 /* End **********/
 }
 }
  
    第三关
 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 **********/
 } 
 }
  
    第四关
 package step4;
 import java.util.;
 public class HelloWorld {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 //程序会输入三次数据
 /********* Begin /
 List list = new ArrayList();
 while(sc.hasNext()){
 list.add(sc.next());
 }
 for(int i=0;i System.out.println(“集合的第”+(i+1)+“个数据为：”+list.get(i));
 }
 / End **********/
 }
 }
  
    第五关
 package step5;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Scanner;
 public class HelloWorld {
 public static void main(String[] args) {
 Map 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 **********/
 } 
 }
  
   
   
   
  Java 字符串与集合练习——词频统计 
   
    第一关
 package step1;
 import java.util.List;
 import java.util.ArrayList;
 import java.util.StringTokenizer;
 public class StudentDemo{
 //使用String.split()方法分割
 public List splitPartition(String str){
 List list=new ArrayList(); 
 //请在此添加实现代码
 /********** Begin /
 String[] strArray=str.split(“|”);
 for(String str2:strArray){
 System.out.println(str2);
 }
 System.out.println();
 / End /
 return list;
 }
 //使用StringTokenizer类进行分割
 public List tokenPartition(String str){
 List list=new ArrayList();
 //请在此添加实现代码
 / Begin /
 String[] strArray=str.split(“?”);
 for(String str1:strArray){
 System.out.println(str1);
 }
 / End **********/ 
 return list;
 }
 }
  
    第二关
 package step2;
 import java.util.Map;
 import java.util.HashMap;
 import java.util.StringTokenizer;
 public class StudentDemo{
 //返回一个Map集合来得到单词和首次出现的下标 key为单词名称 value为单词的角标
 public Map getMap(String str){
 Map map = new HashMap();
 //对str进行分割 再加入map集合中
 //请在此添加实现代码
 /********** Begin /
 StringTokenizer tok = new StringTokenizer(str);
 String word;
 while(tok.hasMoreTokens()){
 word = tok.nextToken(", .
 ");
 int index = str.indexOf(word);
 map.put(word,index);
 }
 / End **********/
 return map;
 }
 }
  
    第三关
 package step3;
 import java.util.Map;
 import java.util.HashMap;
 import java.util.StringTokenizer;
 public class StudentDemo{
 //获取单词的数量
 public Map getWordCount(String str) {
 Map map = new HashMap();
 //请在此添加实现代码
 /********** Begin /
 StringTokenizer tokenizer = new StringTokenizer(new String(str));
 int count;
 String word;
 while (tokenizer.hasMoreTokens()) {
 word = tokenizer.nextToken(" ,?.!:;“”‘’
 ");
 if (map.containsKey(word)) {
 count = map.get(word);
 map.put(word, count + 1);
 } else {
 map.put(word, 1);
 }
 }
 / End **********/
 return map;
 }
 }
  
   
   
   
  多线程基础（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 **********/
 
  文件二 
  package step1;
//请在此添加实现代码
/********** Begin **********/
public class ThreadClassTwo implements Runnable    {
	public int i=0;
	private Thread mythread;
	public void run(){
		for(i=0;i<11;i++){
			if(i%2==0)
				System.out.print(i+" ");
		}
	}
}
/********** End **********/
 
   
    第二关
 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 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 {
 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 **********/
  
   
   
   
  多线程基础（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 **********/
  
    第二关
 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）线程同步 
   
    第一关
 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 *********/
 }
  
    第二关
 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 *********/
 }
  
    第三关
 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);
 }
 }
  
   
   
   
  多线程练习题 
   
    第一关
 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 *********/
 }
  
    第二关
 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 *********/
  
   
   
   
  网络编程 
   
    第一关
 package step1;
 import java.net.ServerSocket;
 import java.net.Socket;
 public class Server {
 public ServerSocket serverSocket;
 public Socket socket;
 public void start() {
 try {
 Client client = new Client();
 /********** Begin /
 serverSocket = new ServerSocket(6000);
 client.start(); //启动客户端
 socket = serverSocket.accept();
 serverSocket.close();
 socket.close();
 /* End *********/
 client.stop(); //关闭客户端
 }
 catch(Exception e) {
 e.printStackTrace();
 }
 }
 }
  
    第二关
 package step2;
 import java.io.OutputStream;
 import java.net.Socket;
 public class Client {
 private Socket socket;
 private OutputStream socketOutputStream;
 public void start() {
 try {
 socket = new Socket(“localhost”,6000);
 /********** Begin *********/
 socketOutputStream = socket.getOutputStream();
 socketOutputStream.write(“I am Client!”.getBytes());
 		/********** End *********/
		socket.shutdownOutput();
	}
	catch(Exception e) {
		e.printStackTrace();
	}
}
public void stop() {
	try{
		socket.close();
	}
	catch(Exception e) {
		e.printStackTrace();
	}
}
 }
  
    第三关
 package step3;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.Socket;
 public class Client {
 private Socket socket;
 private OutputStream socketOutputStream;
 private InputStream socketInputStream;
 public void relation() {
 try{
 /********** Begin *********/
 socketInputStream = socket.getInputStream();
 byte[] bytes = new byte[1000];
 int length = socketInputStream.read(bytes);
 String serverData = new String(bytes,0,length);
 System.out.print("Client has recevied: " + serverData);
 		/********** End *********/
		socket.shutdownInput();
	}
	catch(IOException e) {
		e.printStackTrace();
	}
}
public void start() {
	try {
		socket = new Socket("localhost",6000);
		/********** Begin *********/

        socketOutputStream = socket.getOutputStream();
        socketOutputStream.write("I am Client!".getBytes());

		/********** End *********/
		socket.shutdownOutput();
	}
	catch(Exception e) {
		e.printStackTrace();
	}
}
public void stop() {
	try {
		socket.close();
	}
	catch(Exception e) {
		e.printStackTrace();
	}
}
 }
  
   
   
   
  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();
        }
    }
}
 }
  
    第二关
 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();
        }
    }
}
 }
  
    第三关
 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();
 }
 }
 }
 }
  
   
   
   
  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 findAll() throws SQLException {
 Connection conn = getConnection();
 PreparedStatement ps = null;
 ResultSet rs = null;
 News news = null;
 List newsList = new ArrayList();
 /* 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();
 }
 }
 }
  
    第二关
 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 List selectAll(Class c) { Connection conn = getConnection(); List list = new ArrayList(); 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 Object selectById(Class 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;
 }
 }
  
   
   
   
  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 *********/

}
 }
  
    第二关
 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 + "	name:" + name + "	password:" + password1 + "	sex:" + sex
					+ "	salary:" + salary);
		}
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		// 第五步：关闭statement对象和连接对象

		try {
			ps.close();
			conn.close();
		} catch (SQLException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}

	/********* End *********/
}
 }
  
   
   
   
  IO流 
   
    第一关
 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 *********/
}
 }
  
    第二关
 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 *********/		
}
 }
  
    第三关
 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 *********/		
}
 }
  
   
   
   
  文件类 
   
    第一关
 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 *********/
}
 }
  
    第二关
 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 *********/
}
 }
  
    第三关
 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 **********/
 }
  
    第四关
 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 **********/
 }

头歌 Java实训答案 全ac代码 请善用目录功能

Java初体验

变量与数据类型

运算符和表达式

分支结构

循环结构基础

循环结构进阶

Java循环与分支语句编程练习

数组基础

数组进阶

方法的使用

类与对象

封装继承多态

封装继承多态的综合练习

Java中的异常

String类

常用类

包装类

集合框架（1）

Java 字符串与集合练习——词频统计

多线程基础（1）使用线程

多线程基础（2）常用函数

多线程基础（3）线程同步

多线程练习题

网络编程

JDBC（上）

JDBC（下）

JDBC基础编程练习

IO流

文件类

你可能感兴趣的:(面试,学习路线,阿里巴巴,java,开发语言,intellij-idea,后端,web安全)

头歌 Java实训答案全ac代码请善用目录功能