第一部分 常量&变量

1.1

1. 步骤：
   1. 定义类 Test1
   2. 定义 main方法
   3. 控制台输出5行字符串类型常量值
   4. 控制台输出5行字符类型常量值
2. 实现：

    public class Test1 {public static void main(String[] args) {// 控制台输出任意5行字符串类型常量值System.out.println("善学如春起之苗");System.out.println("不见其增,日有所长");System.out.println("假学如磨刀之石");System.out.println("不见其损,年有所亏");System.out.println("加油吧！少年");// 控制台输出任意5行字符类型常量值System.out.println('J');System.out.println('A');System.out.println('V');System.out.println('A');System.out.println('!');}}

1.2

1. 步骤：
   1. 定义类 Test2
   2. 定义 main方法
   3. 控制台输出5行整数类型常量值
   4. 控制台输出5行小数类型常量值
2. 实现：

    public class Test2 {public static void main(String[] args) {// 控制台输出任意5行整数类型常量值System.out.println(-2147483648);System.out.println(-100);System.out.println(0);System.out.println(100);System.out.println(2147483647);// 控制台输出任意5行小数类型常量值System.out.println(-100.0);System.out.println(-10.0);System.out.println(0.0);System.out.println(10.9);System.out.println(100.9);}}

1.3

1. 步骤:
   1. 定义类 Test3
   2. 定义 main方法
   3. 控制台输出所有布尔类型常量值
2. 实现：

    public class Test3 {public static void main(String[] args) {// 控制台输出所有布尔类型常量值System.out.println(true);System.out.println(false);}}

1.4

1. 步骤:
   1. 定义类 Test4
   2. 定义 main方法
   3. 定义2个 byte类型变量,分别赋byte类型范围内最大值和最小值,并输出在控制台.
   4. 定义2个 short类型变量,分别赋short类型范围内的值,并输出在控制台.
   5. 定义2个 int类型变量,分别赋int类型范围内的值,并输出在控制台.
   6. 定义2个 long类型变量,分别赋超过int类型范围的值,并输出在控制台.
2. 实现：

    public class Test4 {public static void main(String[] args) {// 定义2个 byte类型变量,分别赋byte类型范围内最大值和最小值,并输出在控制台.byte num1 = -128;byte num2 = 127;System.out.println(num1);System.out.println(num2);// 定义2个 short类型变量,分别赋short类型范围内的值,并输出在控制台.short num3 = -32768;short num4 = 32767;System.out.println(num3);System.out.println(num4);// 定义2个 int类型变量,分别赋int类型范围内的值,并输出在控制台.int num5 = -2147483648;int num6 = 2147483647;System.out.println(num5);System.out.println(num6);// 定义2个 long类型变量,分别赋超过int类型范围的值,并输出在控制台.long num7 = -2147483649L;long num8 = 2147483648L;System.out.println(num7);System.out.println(num8);}  }

1.5

1. 步骤:
   1. 定义类 Test5
   2. 定义 main方法
   3. 定义2个 float类型变量,分别赋值,并输出在控制台.
   4. 定义2个 double类型变量,分别赋值,并输出在控制台.
2. 实现：

    public class Test5 {public static void main(String[] args) {// 定义2个 float类型变量,分别赋值,并输出在控制台.float num1 = -3.14F;float num2 = 3.14F;System.out.println(num1);System.out.println(num2);// 定义2个 double,分别赋值,并输出在控制台.double num3 = -3.4;double num4 = 3.4;System.out.println(num3);System.out.println(num4);}}

1.6

1. 步骤:
   1. 定义类 Test6
   2. 定义 main方法
   3. 定义5个 char类型变量,分别赋值,并输出在控制台.
   4. 定义2个 boolean类型变量,分别赋值,并输出在控制台.
2. 实现：

    public class Test6 {public static void main(String[] args) {// 定义5个 char类型变量,分别赋值,并输出在控制台.char ch1 = '9';char ch2 = 'J';char ch3 = 'a';char ch4 = ' ';char ch5 = '@';System.out.println(ch1);System.out.println(ch2);System.out.println(ch3);System.out.println(ch4);System.out.println(ch5);// 定义2个 boolean类型变量,分别赋值,并输出在控制台.boolean b1 = true;boolean b2 = false;System.out.println(b1);System.out.println(b2);}}

1.7

1. 步骤:
   1. 定义类 Test7
   2. 定义 main方法
   3. 定义两个整数变量a，b并赋值
   4. 控制台输出变量a，b互换前的值
   5. 定义一个第三方变量temp，不赋值
   6. 利用第三方变量temp使a，b的值互换
   7. 控制台输出变量a，b互换后的值
2. 提示：定义变量不赋值的格式

    数据类型 变量名;int temp;

3. 实现：

    public class Test7 {public static void main(String[] args) {// 定义两个整数变量a，b并赋值int a = 10;int b = 20;// 控制台输出变量a,b的值System.out.println("互换前:");System.out.println(a);System.out.println(b);// 定义一个第三方变量,不赋值.int temp;// 利用第三方变量,是a,b的值互换.temp = a ;a = b;b = temp;// 控制台输出变量a,b的互换后的值.System.out.println("互换后:");System.out.println(a);System.out.println(b);} }

第二部分 方法重载

2.1 方法定义，方法重载

1. 步骤：
   1. 定义类 Test1,类中定义 main方法,定义int类型a为10, b为10.
   2. 定义printNum方法,参数为(int iVar, int iVar2),返回值无,输出iVar和iVar2的值
   3. 定义doubling方法,参数为(int r, int p),返回值无,方法内r翻倍,p翻倍,并调用printNum方法,输出r和p的值
   4. 定义doubling方法,参数为(int r),返回值int, 方法内r翻倍,返回r.
   5. main方法中,调用printNum方法,传入a,b
   6. main方法中,调用doubling方法,传入a,b
   7. main方法中,调用printNum方法,传入a,b
   8. main方法中,调用doubling方法,传入a,用a接收返回值
   9. main方法中,调用doubling方法,传入b,用b接收返回值
   10. main方法中,调用printNum方法,传入a,b
2. 实现：

    public class Test1 {public static void main(String[] args) {// 定义int类型a为10, b为10.int a = 10;int b = 10;printNum(a, b);doubling(a, b);printNum(a, b);System.out.println("***********************");a = doubling(a);b = doubling(b);printNum(a, b);}// 定义printNum方法,参数为(int iVar, int iVar2),返回值无,输出iVar和iVar2的值public static void printNum(int iVar, int iVar2) {System.out.println("iVar:" + iVar + ", iVar2:" + iVar2);}// 定义doubling方法,参数为(int r, int p),返回值无,方法内r翻倍,p翻倍,并调用printNum方法,输出r和p的值public static void doubling(int r, int p) {r *= 2;p *= 2;System.out.println("翻倍:r=" + r + ",p=" + p);}// 定义doubling方法,参数为(int r),返回值int, 方法内r翻倍,返回r.public static int doubling(int r) {r *= 2;return r;}}//结果：iVar:10, iVar2:10翻倍:r=20,p=20iVar:10, iVar2:10***********************iVar:20, iVar2:20

2.2 方法定义，if

1. 步骤：
   1. 定义类 Test2,类中定义 main方法
   2. 定义doCheck方法,参数为(int iVar),返回值boolean类型
   3. doCheck方法内,定义变量boolean flag.
   4. doCheck方法内,判断num是否为偶数.
   5. 如果是偶数,使用for循环,初始化值i为0,i<=20进入循环,步进表达式i++
   6. 循环内,num-=i;
   7. flag赋值为true.
   8. 否则是奇数,使用for循环,初始化值i为0,i<=20进入循环,步进表达式i++
   9. 循环内,num+=i;
   10. flag赋值为false.
   11. 输出num的值
   12. 返回flag
   13. 调用doCheck方法,传入2,保存返回值,并输出
   14. 调用doCheck方法,传入3,保存返回值,并输出
2. 实现：

    public class Test2 {public static void main(String[] args) {boolean b = doCheck(2);System.out.println(b);boolean b1 = doCheck(3);System.out.println(b1);}// 定义doCheck方法,参数为(int iVar),返回值boolean类型public static boolean  doCheck(int num){//        3.doCheck方法内,定义变量boolean flag.boolean flag  ;//        4.doCheck方法内,判断num是否为偶数.if (num % 2== 0 ) {// 如果是偶数,使用for循环,初始化值i为0,i<=20进入循环,步进表达式i++for (int i = 0; i <= 20; i++) {num-=i;}flag =  true;}else {// 否则是奇数,使用for循环,初始化值i为0,i<=20进入循环,步进表达式i++for (int i = 0; i <= 20; i++) {num+=i;}flag =   false;}// 输出num的值System.out.println("num:"+ num);return flag;}}//结果：num:-208truenum:213false

2.3

1. 要求：定义showColor方法，根据英文单词，输出对应的颜色
2. 实现：

    public class Test3 {public static void main(String[] args) {showColor("red");}// showColor方法中,使用switch语句,判断颜色.public static void showColor(String color) {switch (color) {case "red":System.out.println(color + "是红色!");break;case "blue":System.out.println(color + "是蓝色!");break;case "green":System.out.println(color + "是绿色!");break;default:System.out.println(color+" 颜色未知!");}}}//结果：red是红色!

2.4

1. 需求：
   • 定义getValue方法，获取三个数中的最值，能够通过字符串，指定获取最大值或者最小值。
2. 提示：
   • getValue中，带有String类型参数，可以指定『大』或者『小』
   • 分别定义最大值方法，最小值方法，以供getValue调用。
3. 实现：

    public class Test5 {public static void main(String[] args) {getExtValue("小" , 5, 6, 7);}//  定义getExtValue方法,参数为(String str, int n, int n2, int n3),返回值无public static void getExtValue(String ext , int n1,int n2 , int n3) {switch (ext) {// // 当str为大时,调用getMax方法,获取n,n2,n3中的最大值输出case "大":int max  = getMax(n1,n2,n3);System.out.println("最大值为:" + max);break;// 当str为小时,调用getMin方法,获取n,n2,n3中的最小值输出case "小":int min  =  getMin(n1,n2,n3);System.out.println("最小值为:" + min);break;default:System.out.println("指令有误!");}}private static int getMin(int i, int j, int k) {int min = i < j ? (i < k ? i : k) : (j < k ? j : k);return min ;}private static int getMax(int i, int j, int k) {int max = i > j ? (i > k ? i : k) : (j > k ? j : k);return  max ;}}//结果：最小值为:5

2.5

1. 需求：
   • 定义printX方法，打印任意行的图形。
2. 提示：

• 参考之前的练习，将代码抽取为一个方法。

3. 实现：

    public class Test5 {public static void main(String[] args) {printX(7);}/*2.定义printX方法,参数为(int m) , 返回值无3.printX方法中,使用for循环,初始化变量x = 1,如果x<=m进入循环,步进表达式x++4.for循环内部,再嵌套定义一套for循环,初始化变量y = 1,如果y<=m进入循环,步进表达式y++5.在内循环内部,判断x==y 或者 x+y==1+m ,则打印"O",否则打印"*"*/public static void printX(int m) {for (int x = 1; x <= m; x++) {//循环7行for (int y = 1; y <= m; y++) {//循环7列if (x == y || x + y == m + 1) {//对角线打印OSystem.out.print("O");} else {System.out.print("*");//其他位置打印.}}System.out.println();//换行}}}//结果：O*****O*O***O***O*O*****O*****O*O***O***O*O*****O

2.6

1. 需求：
   • 定义round方法，接收一位小数，实现四舍五入运算，并返回结果。
2. 开发提示：
   • round方法中，参数+0.5后，转换为int类型，并返回。
3. 实现：

    public class Test6 {public static void main(String[] args) {System.out.println( 10.1 + "->"+ round(10.1));System.out.println( 10.4 +"->"+ round(10.4));System.out.println( 10.5 +"->"+ round(10.5));System.out.println( 10.9 +"->"+ round(10.9));}// 定义round方法,参数为(double d) , 返回值intpublic static int round(double d) {// round方法中,d+0.5后,转换为int类型,并返回.int n = (int)(d  + 0.5);return n;}}//结果：10.1->1010.4->1010.5->1110.9->11

第三部分 函数式接口

3.1 函数式接口

1. 要求：
   1. 定义一个函数式接口CurrentTimePrinter,其中抽象方法void printCurrentTime()，使用注解@FunctionalInterface
   2. 在测试类中定义static void showLongTime(CurrentTimePrinter timePrinter)，该方法的预期行为是使用timePrinter打印系统当前毫秒值
   3. 测试showLongTime(),通过lambda表达式完成需求
2. 实现：

    //定义一个函数式接口@FunctionalInterfacepublic interface CurrentTimePrinter {void printCurrentTime();}//主方法：Test01.javapublic class Test01 {public static void main(String[] args) {showLongTime(() -> System.out.println(System.currentTimeMillis()));}public static void showLongTime(CurrentTimePrinter timePrinter){timePrinter.printCurrentTime();}}//结果：1584069834537

3.2 函数式接口

1. 要求：
   1. 定义一个函数式接口IntCalc,其中抽象方法int calc(int a , int b)，使用注解@FunctionalInterface
   2. 在测试类中定义static void getProduct(int a , int b ,IntCalc calc), 该方法的预期行为是使用calc得到a和b的乘积并打印结果
   3. 测试getProduct(),通过lambda表达式完成需求
2. 实现：

    //定义一个函数式接口@FunctionalInterfacepublic interface IntCalc {int cale(int a, int b);}//主方法：public class Test02 {public static void main(String[] args) {getProduct(5, 6, (a, b) -> a*b);}public static void getProduct(int a, int b, IntCalc calc){int product = calc.cale(a, b);System.out.println(product);}}//结果：30

3.3 静态方法引用

1. 要求：
   1. 定义一个函数式接口NumberToString,其中抽象方法String convert(int num)，使用注解@FunctionalInterface
   2. 在测试类中定义static void decToHex(int num ,NumberToString nts), 该方法的预期行为是使用nts将一个十进制整数转换成十六进制表示的字符串，tips:已知该行为与Integer类中的toHexString方法一致
   3. 测试decToHex (),使用方法引用完成需求
2. 实现：

    //定义一个函数式接口@FunctionalInterfacepublic interface NumberToString {String convert(int num);}//主方法：public class Test03 {public static void main(String[] args) {//Lambda//decToHex(155, (num) -> Integer.toHexString(num));//方法引用decToHex(155, Integer::toHexString);}public static void decToHex(int num, NumberToString nts){String convert = nts.convert(num);System.out.println(convert);}}//结果：9b

第四部分 缓冲流&转换流

4.1 高效字节输出流写出字节数据

1. 要求：
   1. 创建字节输出流对象关联文件路径
   2. 利用字节输出流对象创建高效字节输出流对象
   3. 调用高效字节输出流对象的write方法写出一个字节
   4. 关闭高效流，释放资源。
2. 实现：

    public class Test01_01 {public static void main(String[] args) throws IOException {// 创建字节输出流FileOutputStream对象并指定文件路径。FileOutputStream fos = new FileOutputStream("d:\\d.txt");// 利用字节输出流创建高效字节输出流对象BufferedOutputStream bos = new BufferedOutputStream(fos);// 调用高效字节输出流对象的write(int byte)方法写出一个字节数据bos.write(97);//关闭bos.close();}}//结果：d.txt中出现了一个a

4.2 高效字节输出流写出字节数组数据

1. 描述：利用高效字节输出流往C盘下的e.txt文件写出一个字节数组数据，如写出：”i love java”
2. 要求：
   1. 创建字节输出流对象关联文件路径
   2. 利用字节输出流对象创建高效字节输出流对象
   3. 定义字符串存放要输出的数据，然后将字符串转换为字节数组。
   4. 调用高效字节输出流对象的write方法将字节数组输出。
   5. 关闭高效流。
3. 实现：

    public class Test01_02 {public static void main(String[] args) throws IOException {// 创建字节输出流FileOutputStream对象并指定文件路径。FileOutputStream fos = new FileOutputStream("d:\\e.txt");// 利用字节输出流创建高效字节输出流对象BufferedOutputStream bos = new BufferedOutputStream(fos);// 调用高效字节输出流对象的write(byte[] buff)方法写出一个字节数据bos.write("i love you".getBytes());// 关闭流bos.close();}}//结果：e.txt文件中：i love you

4.3 高效流文件复制

1. 描述：利用高效字节输入流和高效字节输出流完成文件的复制。
2. 要求：
   1. 将f盘下的picture文件夹中1.jpg文件复制到D盘下
   2. 一次读写一个字节数组方式复制
3. 步骤：
   1. 创建字节输入流对象并关联文件路径
   2. 利用字节输入流对象创建高效字节输入流对象
   3. 创建字节输出流对象并关联文件路径
   4. 利用字节输出流对象创建高效字节输出流对象
   5. 创建字节数组用来存放读取的字节数
   6. 利用高效字节输入流循环读取文件数据，每读取一个字节数组，利用高效字节输出流对象将字节数组的内容输出到目标文件中。直到读取到文件末尾。
   7. 关闭高效流对象
4. 实现：

    public class Test01_03 {public static void main(String[] args) throws IOException {// 创建字节输入流对象并关联文件路径FileInputStream fis = new FileInputStream("f:\\picture\\1.jpg");// 利用字节输入流对象创建高效字节输入流对象BufferedInputStream bis = new BufferedInputStream(fis);// 创建字节输出流对象并指定文件路径。FileOutputStream fos = new FileOutputStream("d:\\1.jpg");// 利用字节输出流创建高效字节输出流对象BufferedOutputStream bos = new BufferedOutputStream(fos);// 定义字节数组接收读取的字节byte[] buffer = new byte[1024];// 定义变量接收读取的字节数int len = -1;// 循环读取图片数据while((len = bis.read(buffer)) != -1){// 每读取一个字节的数据就写出到目标文件中bos.write(buffer, 0, len);}// 关闭流bis.close();bos.close();}}

4.4 高效字符流和集合的综合使用

1. 描述：
   1. 在项目根目录下新建一个文件：data.txt,键盘录入3个字符串验证码，并存入data.txt中，要求一个验证码占一行；
   2. 键盘录入一个需要被校验的验证码，如果输入的验证码在data.txt中存在：在控制台提示验证成功，如果不存在控制台提示验证失败
2. 实现：

    public class Test01_04 {public static void main(String[] args) throws IOException {//键盘录入3个字符串并写入项目根路径下的data.txt文件中writeString2File();//验证码验证verifyCode();}/** 验证码验证*/private static void verifyCode() throws IOException {//创建ArrayList集合，用于存储文件中的3个验证码ArrayList<String> listA = new ArrayList<>();//创建高效字符缓冲输入流对象,并和data.txt文件关联BufferedReader br = new BufferedReader(new FileReader("data.txt"));String line = null;//循环读取每一行while (null != (line = br.readLine())){//将读到的每一行信息存入到list集合中listA.add(line);}//关闭流对象br.close();//创建键盘录入对象Scanner sc = new Scanner(System.in);//提示用户输入验证码System.out.println("请输入一个验证码");String code = sc.nextLine();if(listA.contains(code)){System.out.println("验证成功");}else {System.out.println("验证失败");}}/** 键盘录入3个字符串并写入项目根路径下的data.txt文件中*/private static void writeString2File() throws IOException {//创建高效字符缓冲输出流对象并和data.txt文件关联BufferedWriter bw = new BufferedWriter(new FileWriter("data.txt"));String line = null;//创建键盘录入对象Scanner sc = new Scanner(System.in);for(int i = 0; i < 3; i++){System.out.println("请输入第"+(i+1)+"个字符串验证码");//读取用户键盘录入的一行验证码信息line = sc.nextLine();//将读取到的一行验证码写入到文件中bw.write(line);//写入换行符bw.newLine();}//关闭流对象bw.close();}}//结果：请输入第1个字符串验证码==abc==请输入第2个字符串验证码==cba==请输入第3个字符串验证码==bca==请输入一个验证码==abc==验证成功

4.5 转换输出流的使用

1. 描述：现有一字符串：”我爱Java”。将该字符串保存到当前项目根目录下的a.txt文件中
2. 要求：使用gbk编码保存。
3. 注意：
   • idea的默认编码是utf-8,所以可以通过filesettingsfile encodings设置为gbk格式，否则打开a.txt文件看到的将会是乱码。
4. 步骤：
   1. 创建文件字节输出流关联目标文件
   2. 根据文件字节输出流创建转换输出流对象，并指定编码字符集为：gbk
   3. 调用流对象的方法将字符串写出到文件中。
   4. 关闭流并释放资源。
5. 实现：

    public class Test01_05 {public static void main(String[] args) throws IOException {// 要保存的字符串String content = "我爱Java";// 创建字节输出流对象FileOutputStream fos = new FileOutputStream("a.txt");// 创建转换输出流对象OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");// 调用方法写入数据osw.write(content);// 关闭流释放资源osw.close();}}

4.6 转换输入流的使用

1. 描述：利用转换输入流将当前项目根目录下使用gbk编码的a.txt文件的内容读取出来，并打印在控制台上。
2. 要求：不能出现乱码的情况
3. 步骤：
   1. 创建字节输入流对象指定文件路径。
   2. 根据字节输入流对象创建转换输入流对象并指定字符集编码为：gbk
   3. 调用转换输入流对象的读取方法读取内容
   4. 关闭流释放资源
4. 实现：

    public class Test01_06 {public static void main(String[] args) throws IOException {// 创建字节输入流对象并关联文件FileInputStream fis = new FileInputStream("a.txt");//创建转换输入流对象InputStreamReader isr = new InputStreamReader(fis, "GBK");// 定义字符数组存放读取的内容char[] buffer = new char[1024];// 定义变量接收读取的字符个数int len = -1;while ((len = isr.read(buffer)) != -1){System.out.println(new String(buffer, 0, len));}// 关闭流isr.close();}}//结果：我爱Java