第一部分 常量&变量
1.1
- 步骤：
- 定义类 Test1
- 定义 main方法
- 控制台输出5行字符串类型常量值
- 控制台输出5行字符类型常量值
- 实现：
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
- 步骤：
- 定义类 Test2
- 定义 main方法
- 控制台输出5行整数类型常量值
- 控制台输出5行小数类型常量值
- 实现：
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
- 步骤:
- 定义类 Test3
- 定义 main方法
- 控制台输出所有布尔类型常量值
- 实现：
public class Test3 {
public static void main(String[] args) {
// 控制台输出所有布尔类型常量值
System.out.println(true);
System.out.println(false);
}
}
1.4
- 步骤:
- 定义类 Test4
- 定义 main方法
- 定义2个 byte类型变量,分别赋byte类型范围内最大值和最小值,并输出在控制台.
- 定义2个 short类型变量,分别赋short类型范围内的值,并输出在控制台.
- 定义2个 int类型变量,分别赋int类型范围内的值,并输出在控制台.
- 定义2个 long类型变量,分别赋超过int类型范围的值,并输出在控制台.
- 实现：
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
- 步骤:
- 定义类 Test5
- 定义 main方法
- 定义2个 float类型变量,分别赋值,并输出在控制台.
- 定义2个 double类型变量,分别赋值,并输出在控制台.
- 实现：
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
- 步骤:
- 定义类 Test6
- 定义 main方法
- 定义5个 char类型变量,分别赋值,并输出在控制台.
- 定义2个 boolean类型变量,分别赋值,并输出在控制台.
- 实现：
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
- 步骤:
- 定义类 Test7
- 定义 main方法
- 定义两个整数变量a，b并赋值
- 控制台输出变量a，b互换前的值
- 定义一个第三方变量temp，不赋值
- 利用第三方变量temp使a，b的值互换
- 控制台输出变量a，b互换后的值
- 提示：定义变量不赋值的格式
数据类型 变量名;
int temp;
- 实现：
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 方法定义，方法重载
- 步骤：
- 定义类 Test1,类中定义 main方法,定义int类型a为10, b为10.
- 定义printNum方法,参数为(int iVar, int iVar2),返回值无,输出iVar和iVar2的值
- 定义doubling方法,参数为(int r, int p),返回值无,方法内r翻倍,p翻倍,并调用printNum方法,输出r和p的值
- 定义doubling方法,参数为(int r),返回值int, 方法内r翻倍,返回r.
- main方法中,调用printNum方法,传入a,b
- main方法中,调用doubling方法,传入a,b
- main方法中,调用printNum方法,传入a,b
- main方法中,调用doubling方法,传入a,用a接收返回值
- main方法中,调用doubling方法,传入b,用b接收返回值
- main方法中,调用printNum方法,传入a,b
- 实现：
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=20
iVar:10, iVar2:10
***********************
iVar:20, iVar2:20
2.2 方法定义，if
- 步骤：
- 定义类 Test2,类中定义 main方法
- 定义doCheck方法,参数为(int iVar),返回值boolean类型
- doCheck方法内,定义变量boolean flag.
- doCheck方法内,判断num是否为偶数.
- 如果是偶数,使用for循环,初始化值i为0,i<=20进入循环,步进表达式i++
- 循环内,num-=i;
- flag赋值为true.
- 否则是奇数,使用for循环,初始化值i为0,i<=20进入循环,步进表达式i++
- 循环内,num+=i;
- flag赋值为false.
- 输出num的值
- 返回flag
- 调用doCheck方法,传入2,保存返回值,并输出
- 调用doCheck方法,传入3,保存返回值,并输出
- 实现：
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:-208
true
num:213
false
2.3
- 要求：定义showColor方法，根据英文单词，输出对应的颜色
- 实现：
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
- 需求：
- 定义getValue方法，获取三个数中的最值，能够通过字符串，指定获取最大值或者最小值。
- 提示：
- getValue中，带有String类型参数，可以指定『大』或者『小』
- 分别定义最大值方法，最小值方法，以供getValue调用。
- 实现：
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
- 需求：
- 提示：
- 实现：
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) {//对角线打印O
System.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
- 需求：
- 定义round方法，接收一位小数，实现四舍五入运算，并返回结果。
- 开发提示：
- round方法中，参数+0.5后，转换为int类型，并返回。
- 实现：
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) , 返回值int
public static int round(double d) {
// round方法中,d+0.5后,转换为int类型,并返回.
int n = (int)(d + 0.5);
return n;
}
}
//结果：
10.1->10
10.4->10
10.5->11
10.9->11
第三部分 函数式接口
3.1 函数式接口
- 要求：
- 定义一个函数式接口CurrentTimePrinter,其中抽象方法void printCurrentTime()，使用注解@FunctionalInterface
- 在测试类中定义static void showLongTime(CurrentTimePrinter timePrinter)，该方法的预期行为是使用timePrinter打印系统当前毫秒值
- 测试showLongTime(),通过lambda表达式完成需求
- 实现：
//定义一个函数式接口
@FunctionalInterface
public interface CurrentTimePrinter {
void printCurrentTime();
}
//主方法：Test01.java
public 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 函数式接口
- 要求：
- 定义一个函数式接口IntCalc,其中抽象方法int calc(int a , int b)，使用注解@FunctionalInterface
- 在测试类中定义static void getProduct(int a , int b ,IntCalc calc), 该方法的预期行为是使用calc得到a和b的乘积并打印结果
- 测试getProduct(),通过lambda表达式完成需求
- 实现：
//定义一个函数式接口
@FunctionalInterface
public 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 静态方法引用
- 要求：
- 定义一个函数式接口NumberToString,其中抽象方法String convert(int num)，使用注解@FunctionalInterface
- 在测试类中定义static void decToHex(int num ,NumberToString nts), 该方法的预期行为是使用nts将一个十进制整数转换成十六进制表示的字符串，tips:已知该行为与Integer类中的toHexString方法一致
- 测试decToHex (),使用方法引用完成需求
- 实现：
//定义一个函数式接口
@FunctionalInterface
public 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 高效字节输出流写出字节数据
- 要求：
- 创建字节输出流对象关联文件路径
- 利用字节输出流对象创建高效字节输出流对象
- 调用高效字节输出流对象的write方法写出一个字节
- 关闭高效流，释放资源。
- 实现：
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 高效字节输出流写出字节数组数据
- 描述：利用高效字节输出流往C盘下的e.txt文件写出一个字节数组数据，如写出：”i love java”
- 要求：
- 创建字节输出流对象关联文件路径
- 利用字节输出流对象创建高效字节输出流对象
- 定义字符串存放要输出的数据，然后将字符串转换为字节数组。
- 调用高效字节输出流对象的write方法将字节数组输出。
- 关闭高效流。
- 实现：
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 高效流文件复制
- 描述：利用高效字节输入流和高效字节输出流完成文件的复制。
- 要求：
- 将f盘下的picture文件夹中1.jpg文件复制到D盘下
- 一次读写一个字节数组方式复制
- 步骤：
- 创建字节输入流对象并关联文件路径
- 利用字节输入流对象创建高效字节输入流对象
- 创建字节输出流对象并关联文件路径
- 利用字节输出流对象创建高效字节输出流对象
- 创建字节数组用来存放读取的字节数
- 利用高效字节输入流循环读取文件数据，每读取一个字节数组，利用高效字节输出流对象将字节数组的内容输出到目标文件中。直到读取到文件末尾。
- 关闭高效流对象
- 实现：
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 高效字符流和集合的综合使用
- 描述：
- 在项目根目录下新建一个文件：data.txt,键盘录入3个字符串验证码，并存入data.txt中，要求一个验证码占一行；
- 键盘录入一个需要被校验的验证码，如果输入的验证码在data.txt中存在：在控制台提示验证成功，如果不存在控制台提示验证失败
- 实现：
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 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 转换输出流的使用
- 描述：现有一字符串：”我爱Java”。将该字符串保存到当前项目根目录下的a.txt文件中
- 要求：使用gbk编码保存。
- 注意：
- idea的默认编码是utf-8,所以可以通过filesettingsfile encodings设置为gbk格式，否则打开a.txt文件看到的将会是乱码。
- 步骤：
- 创建文件字节输出流关联目标文件
- 根据文件字节输出流创建转换输出流对象，并指定编码字符集为：gbk
- 调用流对象的方法将字符串写出到文件中。
- 关闭流并释放资源。
- 实现：
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 转换输入流的使用
- 描述：利用转换输入流将当前项目根目录下使用gbk编码的a.txt文件的内容读取出来，并打印在控制台上。
- 要求：不能出现乱码的情况
- 步骤：
- 创建字节输入流对象指定文件路径。
- 根据字节输入流对象创建转换输入流对象并指定字符集编码为：gbk
- 调用转换输入流对象的读取方法读取内容
- 关闭流释放资源
- 实现：
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
