头歌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注释测试题
ADEJava入门 - 变量与数据类型
第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循环测试题
BJava入门 - 循环结构进阶
第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 BJava入门 - 数组进阶
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 BJava面向对象 - 封装、继承和多态
第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 *********/ } }说真的，这两年看着身边一个个搞Java、C++、前端、数据、架构的开始卷大模型，挺唏嘘的。大家最开始都是写接口、搞Spring Boot、连数据库、配Redis，稳稳当当过日子。
结果GPT、DeepSeek火了之后，整条线上的人都开始有点慌了，大家都在想：“我是不是要学大模型，不然这饭碗还能保多久？”
先给出最直接的答案：一定要把现有的技术和大模型结合起来，而不是抛弃你们现有技术！掌握AI能力的Java工程师比纯Java岗要吃香的多。
即使现在裁员、降薪、团队解散的比比皆是……但后续的趋势一定是AI应用落地！大模型方向才是实现职业升级、提升薪资待遇的绝佳机遇！
Java与大模型结合的技术优势
推理环节的核心地位
大模型训练依赖Python生态的高性能计算资源，而Java在推理阶段（模型部署、性能优化、系统集成）具有独特优势。其“编写一次，处处运行”的特性，使其能无缝集成到微服务、分布式系统等企业级架构中，高效处理高并发请求。例如，某电商平台通过Java构建的大模型API网关，支撑每日千万级请求的稳定运行，响应时间缩短50%。生态成熟与性能稳定
Java拥有Spring Boot、Spring Cloud等成熟框架，可快速实现服务注册、负载均衡、熔断降级等生产级能力。JVM的垃圾回收机制和即时编译技术，使其在长连接、高并发场景下表现优于脚本语言。例如，某金融系统采用Java实现大模型推理服务，系统可用率长期保持99.99%以上。兼容性与工程化能力
Java与现有业务系统的兼容性极强，可降低大模型落地的集成成本。例如，某制造企业通过Java将大模型与ERP系统对接，实现生产流程的智能优化，故障率降低30%。同时，Java在代码规范、测试流程、版本管理等方面的积累，能大幅降低大模型项目的研发成本和维护难度。
因此捕获AI，掌握技术是关键，让AI成为我们最便利的工具.
一定要把现有的技术和大模型结合起来，而不是抛弃你们现有技术！掌握AI能力的Java工程师比纯Java岗要吃香的多。
即使现在裁员、降薪、团队解散的比比皆是……但后续的趋势一定是AI应用落地！大模型方向才是实现职业升级、提升薪资待遇的绝佳机遇！
如何学习AGI大模型？
作为一名热心肠的互联网老兵，我决定把宝贵的AI知识分享给大家。 至于能学习到多少就看你的学习毅力和能力了 。我已将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。
因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取
2025最新版CSDN大礼包：《AGI大模型学习资源包》免费分享**
一、2025最新大模型学习路线
一个明确的学习路线可以帮助新人了解从哪里开始，按照什么顺序学习，以及需要掌握哪些知识点。大模型领域涉及的知识点非常广泛，没有明确的学习路线可能会导致新人感到迷茫，不知道应该专注于哪些内容。
我们把学习路线分成L1到L4四个阶段，一步步带你从入门到进阶，从理论到实战。
L1级别:AI大模型时代的华丽登场
L1阶段：我们会去了解大模型的基础知识，以及大模型在各个行业的应用和分析；学习理解大模型的核心原理，关键技术，以及大模型应用场景；通过理论原理结合多个项目实战，从提示工程基础到提示工程进阶，掌握Prompt提示工程。
L2级别：AI大模型RAG应用开发工程
L2阶段是我们的AI大模型RAG应用开发工程，我们会去学习RAG检索增强生成：包括Naive RAG、Advanced-RAG以及RAG性能评估，还有GraphRAG在内的多个RAG热门项目的分析。
L3级别：大模型Agent应用架构进阶实践
L3阶段：大模型Agent应用架构进阶实现，我们会去学习LangChain、 LIamaIndex框架，也会学习到AutoGPT、 MetaGPT等多Agent系统，打造我们自己的Agent智能体；同时还可以学习到包括Coze、Dify在内的可视化工具的使用。
L4级别：大模型微调与私有化部署
L4阶段：大模型的微调和私有化部署，我们会更加深入的探讨Transformer架构，学习大模型的微调技术，利用DeepSpeed、Lamam Factory等工具快速进行模型微调；并通过Ollama、vLLM等推理部署框架，实现模型的快速部署。
整个大模型学习路线L1主要是对大模型的理论基础、生态以及提示词他的一个学习掌握；而L3 L4更多的是通过项目实战来掌握大模型的应用开发，针对以上大模型的学习路线我们也整理了对应的学习视频教程，和配套的学习资料。
二、大模型经典PDF书籍
书籍和学习文档资料是学习大模型过程中必不可少的，我们精选了一系列深入探讨大模型技术的书籍和学习文档，它们由领域内的顶尖专家撰写，内容全面、深入、详尽，为你学习大模型提供坚实的理论基础。（书籍含电子版PDF）
三、大模型视频教程
对于很多自学或者没有基础的同学来说，书籍这些纯文字类的学习教材会觉得比较晦涩难以理解，因此，我们提供了丰富的大模型视频教程，以动态、形象的方式展示技术概念，帮助你更快、更轻松地掌握核心知识。
四、大模型项目实战
学以致用，当你的理论知识积累到一定程度，就需要通过项目实战，在实际操作中检验和巩固你所学到的知识，同时为你找工作和职业发展打下坚实的基础。
五、大模型面试题
面试不仅是技术的较量，更需要充分的准备。
在你已经掌握了大模型技术之后，就需要开始准备面试，我们将提供精心整理的大模型面试题库，涵盖当前面试中可能遇到的各种技术问题，让你在面试中游刃有余。
因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取
2025最新版CSDN大礼包：《AGI大模型学习资源包》免费分享
