头歌java 实训 答案 代码 java入门

头歌java 实训 答案 代码 java入门头歌java实训参考答案,文章附带目录,谢谢大家的支持。祝大家实训满分。

头歌java

头歌java实训代码 答案 完事记得给老师点五星

→头歌数据库MySQL答案点这里←

→头歌 编译原理答案点这里←

代码在下面,有问题的可以csdn私聊,下面评论都可以!!!谢谢大家的支持。如果能帮助到您,希望能点个赞哦!!!

第 1 章 Java入门之变量与表达式、

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

第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

Java入门 – 变量与数据类型

第1关:变量与常量

package chapter2.step1;

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


 /********* End *********/    
	}
}

第2关:变量的使用

package chapter2;

public class HelloVariable { 
   
	public static void main(String[] args) { 
   
		/********* Begin *********/
					//在这里定义变量 love 并赋初值为 我喜欢在educoder上学习
		/********* End *********/
		System.out.println("变量love的值为" + love);
		
		String userName = "张无忌";
		/********* Begin *********/
					//在这一行将userName的值改成李四
		/********* End *********/			
		System.out.println("重新赋值后变量userName的值为" + userName);
	}
}



第3关:变量测试题

BD
C

第4关:JAVA数据类型

package chapter2;

public class JavaDataType1 { 
   
	public static void main(String[] args) { 
   
		
		/********* Begin *********/
					String name="张无忌";//在本行定义字符串变量name
		
					int age=23;//在本行定义年龄变量 age
		
					char sex='男';//在本行定义性别变量 sex
		
					float score=66.6f;//在本行定义分数变量  score
		
		/********* End *********/


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

import java.util.Scanner;
public class HelloWorld{ 
   
	public static void main(String[] args){ 
   
	Scanner input = new Scanner(System.in);
	System.out.println("请录入嫦娥个人信息:");
	System.out.println("请输入姓名:");
	String name = input.next();
	System.out.println("请输入年龄:");
	int age = input.nextInt();
	System.out.println("请输入性别:");
	String i = input.next();
	System.out.println("请输入体重:");
	double t = input.nextDouble();
	System.out.println("请输入地址:");
	String d = input.next();
	System.out.println("请输入是否已婚:");
	String y = input.next();
	System.out.println("信息如下:");
	System.out.println("\t"+"姓名:"+name);
	System.out.println("\t"+"年龄:"+age+"岁");
	System.out.println("\t"+"性别:"+i);
	System.out.println("\t"+"体重:"+t+"kg");
	System.out.println("\t"+"地址:"+d);
	System.out.println("\t"+"婚否:"+y);
		/********* End *********/
	}
}

Java入门 – 运算符和表达式

第1关:算数运算符

package step1;
import java.util.Scanner;

public class Cal { 
   
	public static void main(String[] args) { 
   
		/*********start*********/
		Scanner input = new Scanner(System.in);
		System.out.println("请输入第一个整数");
		int a = input.nextInt();
		System.out.println("请输入第二个整数");
		int b = input.nextInt();
		int q =a+b;
		int w =a-b;
		int e =a*b;
		int r =a/b;
		int y =a%b;
		System.out.println("两数相加的结果为:"+q);
		System.out.println("两数相减的结果为:"+w);
		System.out.println("两数相乘的结果为:"+e);
		System.out.println("两数相除的结果为:"+r);
		System.out.println("两数取余数的结果为:"+y);
		/*********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<b="+(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(a&&b);
System.out.println(c||b);
System.out.println(a^b);
       
		/*********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%400==0)? true : false; 
        result=(year%4==0&&year%100!=0)? true : false;
        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关:选择自测题

B
A
C
C
A
A

第 2 章 Java入门之控制结构

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 score = input.nextInt();
		if (score >= 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);
		/******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******/
	}
}

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


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

Java入门 – 循环结构基础

第1关:Java循环结构之while循环

package step1;

public class HelloWorld { 
   
    public static void main(String[] args) { 
   
        
        /*****start*****/
        int F=0;
        while(F<6){ 
   
            F++;
            System.out.println("做了"+ F +"个俯卧撑");    
        }

        /*****end*****/
    
    }
}

第2关:Java循环结构之while循环练习

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

第3关: Java循环结构之do…while循环

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

第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 + "是偶数");
            }
            else { 
   
                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:");
        //获取输入的整数N
        int sum = 1;        
        /*****start*****/
        for(int N = sc.nextInt(); N>0; N--) { 
   
          sum=sum*N;
        }

        /*****end*****/
        
        System.out.println("自然数N的阶乘为" + sum);
        
    }
}

第8关:for循环测试题

B

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

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



第5关:选择题

第一题D

第二题BC

第三题B

第 3 章 Java入门之数组

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

Java入门 – 数组进阶

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

第 4 章 Java入门之方法

Java入门 – 方法的使用

第1关:如何定义方法

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


第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) { 
   
        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 **********/

}


第4关:掌握有参数有返回值方法的调用

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


第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 **********/
        // 调用无参的方法
        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 **********/
}


第7关:选择题

BDE

第8关:方法通关挑战

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 + "\t");
            }
            System.out.println();
        }
    }
    /********** End **********/
}    


第 5 章 Java 面向对象之类和对象

Java面向对象 – 类与对象

第1关:什么是类,如何创建类

package step1;

public class Test { 
   
	public static void main(String[] args) { 
   
		/********** Begin **********/
		//创建Dog对象
		//设置Dog对象的属性
		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("叼着骨头跑");
	}

}


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

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

第3关:选择题(一)

C
CD

第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();
        //分别调用三个类的 check方法
        f1.check();
        f2.check();
        f3.check();
        /********** End **********/    
    }
}
文件二

```lua
/********** Begin **********/
//在这里添加包名  step4
package step4;   
//创建类 添加属性和方法
public class WuMingFen{ 
   
    String theMa = "酸辣";
    int quantity = 2;
    boolean likeSoup = false;
    public WuMingFen() { 
   
        likeSoup = true;
    }
    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 );
    }
}
/********** End **********/    
第6关:static关键字

```lua
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 **********/
}


第7关:选择题(二)

D
EG
B

Java面向对象 – 封装、继承和多态

第1关:什么是封装,如何使用封装

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

第2关:什么是继承,怎样使用继承

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

第3关:super关键字的使用

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

第4关:方法的重写与重载

package case4;

public class overridingTest { 
   
	public static void main(String[] args) { 
   
		// 实例化子类对象s,调用talk()方法打印信息
		/********* begin *********/
		Student s=new Student("张三",18,"哈佛大学");
		s.talk();
		/********* end *********/
		
	}
}

class Person { 
   
	/********* begin *********/
	public String name;
	public int age;
	void talk(){ 
   
		System.out.println("我是:"+name+",今年:"+age+"岁");
	}
	/********* end *********/
}

class Student extends Person { 
   
	/********* begin *********/
	String school;
	Student(String name,int age,String school){ 
   
		this.name=name;
		this.age=age;
		this.school=school;
	}
	void talk(){ 
   
		System.out.println("我是:"+name+",今年:"+age+"岁,我在"+school+"上学");
	}
	/********* end *********/
}

第5关:抽象类

package case5;

public class abstractTest { 
   
	public static void main(String[] args) { 
   
		/********* begin *********/
		// 分别实例化Student类与Worker类的对象,并调用各自构造方法初始化类属性。
		Student s=new Student("张三",20,"学生");
		Worker w=new Worker("李四",30,"工人");
		s.talk();
		w.talk();
		// 分别调用各自类中被复写的talk()方法 打印信息。
		/********* end *********/
	}
}

// 声明一个名为Person的抽象类,在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
abstract class Person { 
   
	/********* begin *********/
	String name;
	int age;
	String occupation;
	abstract void talk();
	/********* end *********/
}

// Student类继承自Person类,添加带三个参数的构造方法,复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person { 
   
	/********* begin *********/
	Student(String name,int age,String occupation){ 
   
		this.name=name;
		this.age=age;
		this.occupation=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){ 
   
		this.name=name;
		this.age=age;
		this.occupation=occupation;
	}
	void talk(){ 
   
		System.out.println("工人——>姓名:"+name+",年龄:"+age+",职业:"+occupation+"!");
	}
	/********* end *********/
}

第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 { 
   
	final void run() { 
   
		System.out.println("running");
	}
}

class Honda extends Bike2 { 
   
	void run() { 
    
		System.out.println("running safely with 100kmph");
	}

}

final 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();
		System.out.println(s.talk());
		/********* end *********/
	}
}

// 声明一个Person接口,并在里面声明三个常量:name、age和occupation,并分别赋值,声明一抽象方法talk()
interface Person { 
   
	/********* begin *********/
	final String name="张三";
	final int age=18;
	final String occupation="学生";
	public abstract String talk();
	/********* end *********/
}

// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
class Student implements Person { 
   
	/********* begin *********/
	public String talk() { 
   
        return "学生——>姓名:" + this.name + ",年龄:" + this.age + ",职业:"
                + this.occupation + "!";
	}
	/********* end *********/
}

第8关:什么是多态,怎么使用多态

package case8;

public class TestPolymorphism { 
   
	public static void main(String[] args) { 
   
		// 以多态方式分别实例化子类对象并调用eat()方法
		/********* begin *********/
		Animal a=new Dog();
		a.eat();
		Animal b=new Cat();
		b.eat();
		Animal c=new Lion();
		c.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 *********/
}

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 { 
   
	/********* begin *********/
    String name;
    String sex;
    public abstract void talk();
    public abstract void eat();

	/********* end *********/
}

// Dog类继承自Pet类 封装属性color
// 构造函数初始化name、sex和color
// 实现自己的talk()方法和eat()方法
// talk()输出'名称:name,性别:sex,颜色:color,汪汪叫'
// eat()输出'name吃骨头'
class Dog extends Pet { 
   
	/********* begin *********/
    String color;
    public Dog(String name,String sex,String color){ 
   
		this.name=name;
		this.sex=sex;
		this.color=color;
	}
	public void talk(){ 
   
		System.out.println("名称:"+name+",性别:"+sex+",颜色:"+color+",汪汪叫");
	}
	public void eat(){ 
   
		System.out.println(name+"吃骨头!");
	}
	/********* end *********/
}

// Cat类继承自Pet类 封装属性weight
// 构造函数初始化name、sex和weight
// 实现自己的talk()方法和eat()方法
// talk()输出'名称:name,性别:sex,体重:weight kg,喵喵叫'
// eat()输出'name吃鱼'
class Cat extends Pet { 
   
	/********* begin *********/
    double weight;
	Cat(String name,String sex,double weight){ 
   
		this.name=name;
		this.sex=sex;
		this.weight=weight;
	}
	public void talk(){ 
   
		System.out.println("名称:"+name+",性别:"+sex+",体重:"+weight+"kg,喵喵叫");
	}
	public void eat(){ 
   
		System.out.println(name+"吃鱼!");
	}

	/********* end *********/
}

第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 test;
		// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
		Person person1=new Chinese(cName,cSex,cAge);
		// 通过showEat()方法调用Chinese的eat()方法
		showEat(person1);
		// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
		Person person2=new English(eName,eSex,eAge);
		// 通过showEat()方法调用English的eat()方法
		showEat(person2);
		/********* begin *********/

		/********* end *********/
		// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
		Chinese d=(Chinese)person1;
		d.shadowBoxing();
		// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
		English e=(English)person2;
		e.horseRiding();
		/********* begin *********/

		/********* end *********/
	}

	// 定义showEat方法,使用父类作为方法的形参,实现多态,传入的是哪个具体对象就调用哪个对象的eat()方法
	/********* begin *********/
	
	public static void showEat(Person p){ 
   
        p.eat();
    }
	/********* end *********/
}

// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person { 
   
	/********* begin *********/
	public String name;
	public String sex;
	public int age;
	abstract void eat();
	/********* end *********/
}

// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是中国人,我喜欢吃饭!'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳!'
class Chinese extends Person { 
   
	/********* begin *********/
	public String name;
	public String sex;
	public int age;
	Chinese(String name,String sex,int age){ 
   
		this.name=name;
		this.sex=sex;
		this.age=age;
	}
	void eat(){ 
   
		System.out.println("姓名:"+name+",性别:"+sex+",年龄:"+age+",我是中国人,我喜欢吃饭!");
	}
	void shadowBoxing(){ 
   
		System.out.println(name+"在练习太极拳!");
	}
	/********* end *********/
}

// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是英国人,我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马!'
class English extends Person { 
   
	/********* begin *********/
	public String name;
	public String sex;
	public int age;
	English(String name,String sex,int age){ 
   
		this.name=name;
		this.sex=sex;
		this.age=age;
	}
	void eat(){ 
   
		System.out.println("姓名:"+name+",性别:"+sex+",年龄:"+age+",我是英国人,我喜欢吃三明治!");
	}
	void horseRiding(){ 
   
		System.out.println(name+"在练习骑马!");

	}
	/********* end *********/
}

第3关:封装、继承和多态进阶(三)

package case3;

import java.util.Scanner;

public class Task3 { 
   
	public static void main(String[] args) { 
   
		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 *********/
	String name;
	int age;
	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);
	}
	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 *********/
	PingPangPlayer(String name,int age){ 
   
		super(name,age);
	}
	void eat(){ 
   
		System.out.println("乒乓球运动员吃大白菜,喝小米粥");
	}
	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);
	}
	void eat(){ 
   
		System.out.println("篮球运动员吃牛肉,喝牛奶");
	}
	void study(){ 
   
		System.out.println("篮球运动员学习如何运球和投篮");
	}
	/********* end *********/
}

// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类(兵乓球教练需要说英语)
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球教练吃小白菜,喝大米粥'
// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球教练说英语'
class PingPangCoach extends Coach implements SpeakEnglish { 
   
	/********* begin *********/
	PingPangCoach(String name,int age){ 
   
		super(name,age);
	}
	void eat(){ 
   
		System.out.println("乒乓球教练吃小白菜,喝大米粥");
	}
	void teach(){ 
   
		System.out.println("乒乓球教练教如何发球和接球");
	}
	public void speak(){ 
   
		System.out.println("乒乓球教练说英语");
	}
	/********* end *********/
}

// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口,因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球教练吃羊肉,喝羊奶'
// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
class BasketballCoach extends Coach { 
   
	/********* begin *********/
	BasketballCoach(String name,int age){ 
   
		super(name,age);
	}
	void eat(){ 
   
		System.out.println("篮球教练吃羊肉,喝羊奶");
	}
	void teach(){ 
   
		System.out.println("篮球教练教如何运球和投篮");
	}
	/********* end *********/
}

第 6 章 Java面向对象之常用类

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



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


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];
		// 把所有的大写字母放进去 把所有的小写字母放进去 把09放进去
		/********* 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 *********/
		// 分别以123作为种子数 生成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
		// 把该字符串转换为一个日期
		// 通过该日期得到一个毫秒值
		// 获取2020101日的毫秒值
		// 两者想减得到一个毫秒值
		// 把该毫秒值转换为天 打印输出
		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 *********/
	}
}


第 7 章 Java面向对象之异常类与文件类

Java面向对象 – Java中的异常

第1关:Java 中的异常处理机制

B
ACE
D

第2关:捕获异常

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

}


第3关:抛出异常

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


第4关:自定义异常

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()<3){ 
   
			throw new MyException("用户名小于三位Exception");
		}
		else{ 
   
			System.out.println("用户名格式正确");
		}
	}
}
class MyException extends Exception{ 
   
	public MyException(){ 
   }
	public MyException(String msg){ 
   
		super(msg);
	}
}
/********* End *********/



Java面向对象 – 文件类

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


第 8 章 集合框架

Java高级特性 – 集合框架(1)

第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

第 9 章 反射

Java高级特性 – Java反射

第1关:了解 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 对象
     * <p>
     * 注意: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 *********/
            Method setPriceMethod = clazz.getMethod("setPrice", double.class);
            Constructor appleConstructor = clazz.getConstructor();
            Object apple = appleConstructor.newInstance();
            setPriceMethod.invoke(apple, 14);
            Method getPriceMethod = clazz.getMethod("getPrice");
            System.out.println(getPriceMethod.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;
    }
}

第 10 章 JDBC

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


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

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

第 11 章 Java IO

学习-Java输入输出之字节缓冲IO流之复制文件

第1关:学习-Java输入输出之字节缓冲IO流之复制文件

import java.io.*;
import java.util.Scanner;
public class FileTest { 
   
    public static void main(String[] args) throws IOException { 
   
        Scanner scanner = new Scanner(System.in);     // 获取给定字符串
        String s = scanner.nextLine();
         // 请在Begin-End间编写完整代码
        /********** Begin **********/
        // 切割给定字符串,获取源文件路径和目标文件路径
        String[] split = s.split(",");       
        String  folder= split[0];     // 源文件路径
        String fileName = split[1];     // 目标文件路径
        // 创建缓冲流对象,实现文件复制
         File file = new File(split[1]);
        try(               
            BufferedOutputStream bfout= new BufferedOutputStream(new FileOutputStream(file,true));
            BufferedInputStream bfin= new BufferedInputStream(new FileInputStream(split[0]))) { 
   
            int read;
            while((read=bfin.read())!=-1){ 
   
                bfout.write(read);
            }
        }
        // 输出目标文件长度
        System.out.println("文件长度:"+file.length());
        /********** End **********/
    }
}

学习-Java输入输出之文件字符IO流之文件加密

第1关

import java.io.*;

import static java.lang.Character.isLetterOrDigit;

import java.util.Scanner;

public class FileTest { 
   
    public static void main(String[] args) throws IOException { 
   
        // 请在Begin-End间编写完整代码

        // 接收给定字符串,获取相关路径

        Scanner sc = new Scanner(System.in);

        String strs = sc.next();  

        String [] str = strs.split(",");

        // 读取源文件

        File file1 = new File(str[0]);

        FileReader fis = new FileReader(file1);

        char[] buffs = new char[(int)file1.length()];

        fis.read(buffs);

        // 加密

        jiami(buffs);

        // 把加密后的内容保存到目标文件

        File file2 = new File(str[1]);

        FileWriter fos = new FileWriter(file2);

            if(str[1].equals("/test/b.txt")){ 
   
                fos.write(buffs,0,(int)file1.length());  

                fis.close();

                fos.close();

                System.exit(0);

        }

        fos.write(buffs,0,(int)file1.length());

        fos.flush();

        fis.close();

        fos.close();

}

        // 定义加密方法

        public static void jiami(char[] ch){ 
   
            for(int i=0;i<ch.length;i++){ 
   
                if(ch[i]>='0'&&ch[i]<'9'){ 
   
                    ch[i]++;

                }

                else if(ch[i]=='9'){ 
   
                    ch[i]='0';

                }

                else if((ch[i]>='a'&&ch[i]<'z')||(ch[i]>='A'&&ch[i]<'Z')){ 
   
                    ch[i]++;

                }

                else if(ch[i]=='z'){ 
   
                    ch[i]='a';

                }

                else if(ch[i]=='Z'){ 
   
                    ch[i]='A';

                }

            }        

        }

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

}

学习-Java输入输出之对象IO流之序列化一个对象

第1关
myproject/src/step 1/File Testjava

import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
public class FileTest { 
   
 
    public static void main(String[] args) throws IOException, ClassNotFoundException { 
   
        // 接收给定的数据
        Scanner scanner = new Scanner(System.in);
        String filedir = scanner.next();
        String name = scanner.next();
        int age = scanner.nextInt();
 
        // 请在此编写代码
        /********** Begin **********/
        // 创建Student对象
        Student stu = new Student(name,age);
        // 给对象属性赋值
        File file = new File(filedir);
        // 序列化对象到文件中,并通过反序列化读取文件内容,最后打印对象的所有属性
        ObjectOutputStream oos = new ObjectOutputStream(new  FileOutputStream(file));
        
        oos.writeObject(stu);
 
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
 
        System.out.print(ois.readObject());
        /********** End **********/
 
    }
}

myproject/src/step 1/Student.java

import java.io.Serializable;
 
public class Student implements Serializable { 
   
    public String name;
    public int age;
    public Student(String name,int age){ 
   
        this.name=name;
        this.age=age;
    }
    public String toString (){ 
   
       return this.name+"\n"+this.age;
    }
}
 

学习-Java输入输出之随机IO流之向文件中追加内容

第1关

import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
public class FileTest { 
   
    public static void main(String[] args) throws IOException { 
   
        // 请在Begin-End间编写完整代码
        /********** Begin **********/
        // 接收给定的字符串
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        // 切割字符串
        String[] split = str.split(",");
        // 通过文件对象创建RandomAccessFile对象
        File file = new File(split[0]);
        try(
                RandomAccessFile randomAccessFile = new RandomAccessFile(file,"rw");
        ){ 
   
        // 移动指针位置
        randomAccessFile.seek(randomAccessFile.length());
        // 追加给定内容
        randomAccessFile.write(split[1].getBytes());
        // 打印追加内容后的文件指针位置
        System.out.print(randomAccessFile.getFilePointer());
        }
        /********** End **********/
    }
}

学习-Java输入输出之数组IO流之将给定整数转换为字符串

第1关

import java.io.*;
import java.util.Scanner;
public class FileTest { 
   
    public static void main(String[] args) throws IOException { 
   
        // 请在此编写代码
        /********** Begin **********/
        // 创建ByteArrayOutputStream对象
        try (
            ByteArrayOutputStream bOutput = new ByteArrayOutputStream();) { 
   
            // 获取给定数据并写入ByteArrayOutputStream流中
            Scanner scanner = new Scanner(System.in);
            while(!scanner.hasNext("%")){ 
   
            bOutput.write(scanner.nextInt());
            }
            // 从流中取出数据
            byte b[] = bOutput.toByteArray();
            // 将数据转换为字符串,并输出结果
            System.out.println(new String(b));
        }
            /********** End **********/
    }
}

学习-Java输入输出之数据IO流之向文件中写入数字并读取

第1关

import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
public class FileTest { 
   
    public static void main(String[] args) throws IOException { 
   
        // 接收给定的数据
        Scanner scanner = new Scanner(System.in);
        String filedir = scanner.next();
        int num1 = scanner.nextInt();
        int num2 = scanner.nextInt();
        int num3 = scanner.nextInt();
        // 请在此编写代码
        /********** Begin **********/
        // 将数字写入文件中
        try (
                // 通过文件字节输出流创建DataOutputStream对象
                DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(filedir));
                // 通过文件字节输入流创建DataInputStream对象
                DataInputStream dataInputStream = new DataInputStream(new FileInputStream(filedir));) { 
   
                dataOutputStream.writeInt(num1);
                dataOutputStream.writeInt(num2);
                dataOutputStream.writeInt(num3);
         // 从文件中读取数字,并输出结果
                for(int n=0;n<3;n++){ 
   
                    int num = dataInputStream.readInt();
                    System.out.println("读取的数字为:"+num);
                }
        }
        /********** End **********/
    }
}


Java高级特性 – IO流

第1关

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 *********/
        FileInputStream fs = new FileInputStream("src/step2/input/task.txt");
        byte[] b = new byte[8];
        fs.read(b);
        String str = new String(b);
        System.out.println(str);
        File dir = new File("src/step2/output/");
        if(!dir.exists()){ 
   
            dir.mkdir();
        }
        FileOutputStream fos = new FileOutputStream("src/step2/output/output.txt");
        String out = "learning practice";
        byte[] outByte = out.getBytes();    //将字符串转换成字节
        fos.write(outByte);                    //写数据
        //释放资源
        fs.close();
        fos.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 *********/
		FileReader fr = new FileReader("src/step4/input/input.txt");
		FileWriter fw = new FileWriter("src/step4/output/output.txt");
		int len = 0;
		char[] cha = new char[1024];
		while ( (len = fr.read(cha) ) != -1) 
		{ 
   
			fw.write(cha , 0 , len);
		}
		fr.close();
		fw.flush();
		fw.close();
		
		FileInputStream fs = new FileInputStream("src/step4/input/input.jpg");
		FileOutputStream fo = new FileOutputStream("src/step4/output/output.jpg");
		int le = 0;
		byte[] bt = new byte[1024];
		while ( (le = fs.read(bt) ) != -1)
		{ 
   
			fo.write (bt , 0 , le);
		}
		fs.close();
		fo.flush();
		fo.close();		
		/********* End *********/		
	}
}

今天的文章头歌java 实训 答案 代码 java入门分享到此就结束了,感谢您的阅读,如果确实帮到您,您可以动动手指转发给其他人。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/29292.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注