头歌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+(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];
// 把所有的大写字母放进去 把所有的小写字母放进去 把0到9放进去
/********* Begin *********/
for(int i=0;i<26;i++)
{
pardStore[i]=(char)('A'+i);
pardStore[26+i]=(char)('a'+i);
}
for(int i=0;i<10;i++)
{
pardStore[52+i]= (char)('0' + i);
}
/********* End *********/
// 分别以1、2、3作为种子数 生成6位随机密码
Scanner sc = new Scanner(System.in);
int seed = sc.nextInt();
/********* Begin *********/
Random r=new Random(seed);
String str="";
int[] arr=r.ints(6,0,62).toArray();
for(int i=0;i<6;i++)
{
str+=pardStore[arr[i]];
}
System.out.print(str);
/********* End *********/
}
}
第5关：Date类和SimpleDateFormat类的用法
package case5;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class DateTest {
public static void main(String[] args) throws ParseException {
// 键盘录入你的出生年月日 格式为yyyy-MM-dd
// 把该字符串转换为一个日期
// 通过该日期得到一个毫秒值
// 获取2020年10月1日的毫秒值
// 两者想减得到一个毫秒值
// 把该毫秒值转换为天 打印输出
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
/********* Begin *********/
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Date d1=sdf.parse(line);
Date d2=sdf.parse("2020-10-01");
long diff=d2.getTime()-d1.getTime();
diff=diff/86400000;
System.out.println("你的出生日期距离2020年10月1日:"+diff+"天");
/********* End *********/
}
}
第6关：Math类
package case6;
import java.util.Scanner;
import java.lang.Math;
public class MathTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a1 = sc.nextInt();
int a2 = sc.nextInt();
int a3 = sc.nextInt();
int a4 = sc.nextInt();
double a5 = sc.nextDouble();
double a6 = sc.nextDouble();
double a7 = sc.nextDouble();
double a8 = sc.nextDouble();
double a9 = sc.nextDouble();
double a10 = sc.nextDouble();
double a11 = sc.nextDouble();
/********* Begin *********/
System.out.println(Math.sqrt(a1));
System.out.println(Math.cbrt(a2));
System.out.println(Math.pow(a3,a4));
System.out.println(Math.max(a5,a6));
System.out.println(Math.min(a5,a6));
System.out.println(Math.abs(a7));
System.out.println(Math.ceil(a8));
System.out.println(Math.floor(a9));
System.out.println(Math.rint(a10));
System.out.println(Math.round(a11));
/********* End *********/
}
}
第 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 *********/
}
}