常量变量
常量
1.概述:在代码的运行过程中,值不会发生改变的数据
2.分类:整数常量:所有整数小数常量:所有带小数点的2.5 1.5 2.0字符常量:带单引号的 '' 单引号中必须有且只能有一个内容'1'(算) '11'(不算) ''(不算) 'a1'(不算)' '(算) ' '(两个空格不算)'写一个tab键'(算) 字符串常量:带双引号的 "" 双引号中内容随意"" "helloworld"布尔常量:true(真) false(假) -> 这两个单词不要加双引号"true"(这样写属于字符串,不属于布尔常量) 空常量:null 代表的是数据不存在
public class Demo01Constant{public static void main(String[] args){//整数常量System.out.println(1);System.out.println(-1); //小数常量System.out.println(1.5);System.out.println(1.0); //字符常量 单引号中必须有且只能有一个内容System.out.println('1');//System.out.println('11');错误System.out.println(' ');//一个空格算一个内容//System.out.println(' ');//四个空格算四个内容,所以不属于字符常量System.out.println(' ');//tab键算一个内容 //字符串常量System.out.println("本人是尚硅谷第一帅的男人");System.out.println(""); //布尔常量System.out.println(true);System.out.println(false); //空常量 不能直接使用//System.out.println(null);}
}
变量
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
|---|---|---|---|
| 字节型 | byte | 1个字节 | -128 至 127 定义byte变量时超出范围,废了 |
| 短整型 | short | 2个字节 | -32768 至 32767 |
| 整型 | int（默认） | 4个字节 | -231 至 231-1 正负21个亿 -2147483648——2147483647 |
| 长整型 | long | 8个字节 | -263 至 263-1 19位数字 -9223372036854775808到9223372036854775807 |
| 单精度浮点数 | float | 4个字节 | 1.4013E-45 至 3.4028E+38 |
| 双精度浮点数 | double（默认） | 8个字节 | 4.9E-324 至 1.7977E+308 |
| 字符型 | char | 2个字节 | 0 至 216-1 |
| 布尔类型 | boolean | 1个字节 | true，false(可以做判断条件使用) |
1.变量的数据类型:基本数据类型:4类8种整型:byte short int long浮点型:float double字符型:char布尔型:boolean引用数据类型: 类 数组 接口 枚举 注解
2.概述:在代码的运行过程中,值会随着不同的情况而随时发生改变的数据
3.作用:一次接收一个数据将来定义一个变量,接收一个值,后续可能会根据不同的情况对此值进行修改,此时可以用变量
4.定义:a.数据类型 变量名 = 值;b.数据类型 变量名;变量名 = 值;c.连续定义三个相同类型的变量数据类型 变量名1,变量名2,变量名3;变量名1 = 值;变量名2 = 值;变量名3 = 值;比如:int i,j,k;i = 10;j = 20; k = 30;数据类型 变量名1 = 值,变量名2 = 值,变量名3 = 值;比如: int i = 10,j = 20,k = 30;正确读法:先看等号右边的,再看等号左边的 -> 将等号右边的数据赋值给等号左边的变量哪怕等号右边有运算,我们都得先将等号右边的运算算出一个值来,最后赋值给等号左边的变量 5.注意:a.字符串不属于基本数据类型,属于引用数据类型,用String表示String是一个类,只不过字符串在定义的时候可以和基本数据类型格式一样
6.float和double的区别:a.float的小数位只有23位二进制,能表示的最大十进制为2的23次方(8388608),是7位数,所以float型代表的小数,小数位能表示7位 b.double的小数位只有52位二进制,能表示的最大十进制为(4 503 599 627 370 496),是16位数,所以double型代表的小数,小数位能表示出16位
7.切记:将来开发不要用float或者double直接参与运算,因为直接参与运算会有精度损失问题
1.变量的数据类型:基本数据类型:4类8种整型:byte short int long浮点型:float double字符型:char布尔型:boolean引用数据类型: 类 数组 接口 枚举 注解2.概述:在代码的运行过程中,值会随着不同的情况而随时发生改变的数据3.作用:一次接收一个数据将来定义一个变量,接收一个值,后续可能会根据不同的情况对此值进行修改,此时可以用变量4.定义:a.数据类型 变量名 = 值;b.数据类型 变量名;变量名 = 值;c.连续定义三个相同类型的变量数据类型 变量名1,变量名2,变量名3;变量名1 = 值;变量名2 = 值;变量名3 = 值;比如:int i,j,k;i = 10;j = 20; k = 30;数据类型 变量名1 = 值,变量名2 = 值,变量名3 = 值;比如: int i = 10,j = 20,k = 30;正确读法:先看等号右边的,再看等号左边的 -> 将等号右边的数据赋值给等号左边的变量哪怕等号右边有运算,我们都得先将等号右边的运算算出一个值来,最后赋值给等号左边的变量5.注意:a.字符串不属于基本数据类型,属于引用数据类型,用String表示String是一个类,只不过字符串在定义的时候可以和基本数据类型格式一样6.float和double的区别:a.float的小数位只有23位二进制,能表示的最大十进制为2的23次方(8388608),是7位数,所以float型代表的小数,小数位能表示7位b.double的小数位只有52位二进制,能表示的最大十进制为(4 503 599 627 370 496),是16位数,所以double型代表的小数,小数位能表示出16位7.切记:将来开发不要用float或者double直接参与运算,因为直接参与运算会有精度损失问题
public class Demo03Var{public static void main(String[] args){//bytebyte num1 = 100;System.out.println(num1);//shortshort num2 = 1000;num2 = 1001;System.out.println(num2);//int 整数的默认类型int num3 = 10000;num3 = 1;System.out.println(num3);//long -> 定义long型的变量后面加个Llong num4 = 10L;System.out.println(num4);//float -> 定义float型变量的时候后面加个Ffloat num5 = 2.5F;System.out.println(num5);//double -> 小数的默认类型double num6 = 2.5;System.out.println(num6);//charchar num7 = 'A';System.out.println(num7);//booleanboolean num8 = true;boolean num9 = false;/*num9 = falsenum8 = num9 -> 将num9的值赋值给num8 -> 相当于num8 = false*/num8 = num9;System.out.println(num8);//String -> 是一个引用数据类型,属于类的一种,但是定义和基本类型一致String name = "金莲";System.out.println(name);}
}
public class Demo04Var{public static void main(String[] args){int num1 = 10;int num2 = 3;int sum = num1+num2;System.out.println(sum);//13int sub = num1-num2;System.out.println(sub);//7//System.out.println(num1*num2);//30int mul = num1*num2;System.out.println(mul);//30/*由于/前后都是整数,结果取整数部分,结果还赋值给一个整数变量*/int div = num1/num2;System.out.println(div);//3double div1 = num1/num2;//3.0System.out.println(div1);}
}
public class Demo05Var{public static void main(String[] args){/*转义字符: \可以这样简单理解:a.将普通字符转成具有特殊含义的字符b.将具有特殊含义的字符转成普通字符*//*n:普通字符\n:换行符*/System.out.print("春眠不觉晓\n");System.out.print("处处闻啼鸟\n");System.out.print("夜来风雨声\n");System.out.print("花落知多少\n");/*t:普通字符\t:制表符 -> 就是tab键*/System.out.println("本人\t是尚硅谷第一帅");/*用String表示一个路径在java中两个\\代表一个\*/String path = "E:\\01_javase_video\\code";System.out.println(path);}
}
public class Demo06Var{public static void main(String[] args){float a = 10;float b = 3;float result = a/b;System.out.println(result);//3.3333333double c = 10;double d = 3;double result02 = c/d;System.out.println(result02);//3.3333333333333335float x = 3.55F;float y = 2.12F;float result03 = x-y;System.out.println(result03);//1.4300001}
}
2.变量使用时的注意事项
1.变量不初始化(第一次赋值)不能直接使用
2.在同一个作用域(一对大括号就是一个作用域)中不能定义重名的变量
3.不同作用域中的数据尽量不要随意互相访问在小作用域中能直接访问大作用域中的变量在大作用域中不能直接访问小作用域中的变量
public class Demo07Var{public static void main(String[] args){int i = 10;System.out.println(i);int j;j = 10;System.out.println(j);int k = 10;//int k = 20;//只要是变量名前带具体的数据类型就是重新定义System.out.println(k);{int x = 1000;System.out.println(k); }//System.out.println(x); }
}
练习
定义一个人类,用变量表示 姓名 性别 年龄 身高 体重
public class Demo08VarPerson{public static void main(String[] args){//姓名String name = "张三";//性别char sex = '男';//年龄int age = 20;//身高double height = 175.5;//体重double weight = 145.5;System.out.println(name);System.out.println(sex);System.out.println(age);System.out.println(height);System.out.println(weight);}
}
标识符
1.概述:咱们给类,方法,变量取的名字
2.注意:
a.硬性规定(必须遵守)
标识符可以包含"英文字母","数字","$和_"
标识符不能以数字开头 int i1 = 100(正确) int 1i = 100(错误)
标识符不能是关键字 int static = 100(错误) int public = 100(错误)
b.软性建议(可遵守可不遵守,但是建议遵守)
给类取名字:遵循大驼峰式 -> 每个单词首字母大写
给方法和变量取名字:遵循小驼峰式 -> 从第二个单词开始往后首字母大写
见名知意
数据类型
1.什么时候发生类型转换:a.等号左右两边类型不一致b.不同类型的数据做运算
2.分类:a.自动类型转换将取值范围小的数据类型赋值给取值范围大的数据类型 -> 小自动转大取值范围小的数据类型和取值范围大的数据类型数据做运算 -> 小自动转大 b.强制类型转换当将取值范围大的数据类型赋值给取值范围小的数据类型 -> 需要强转
3.基本类型中按照取值范围从小到大排序:byte,short,char -> int -> long -> float -> double
1.自动类型转换
1.将取值范围小的数据类型赋值给取值范围大的数据类型 -> 小自动转大
2.取值范围小的数据类型和取值范围大的数据类型做运算 -> 小自动转大
public class Demo09DataType{public static void main(String[] args){/*等号右边是整数,整数默认类型为int等号左边是long型的变量将取值范围小的数据类型赋值给取值范围大的数据类型,发生了自动类型转换*/long num1 = 100;System.out.println(num1); int i = 10;double b = 2.5; /*double = int+doubledouble = double+doubleint自动提升为了double,发生了自动类型转换*/double sum = i+b;System.out.println(sum);}
}
2.强制类型转换
1.将取值范围大的数据类型赋值给取值范围小的数据类型取值范围小的数据类型 变量名 = 取值范围大的数据类型 -> 需要强转
2.怎么强转:取值范围小的数据类型 变量名 = (取值范围小的数据类型)取值范围大的数据类型
public class Demo10DataType{public static void main(String[] args){/*等号右边的数据是小数,小数默认类型为double等号左边的变量是float型 将取值范围大的赋值给取值范围小 -> 报错,需要强转*///float num1 = 2.5;//float num1 = (float)2.5;float num1 = 2.5F;System.out.println(num1); }
}
3.强转的注意事项
1.不要随意写成强转的格式,因为会有精度损失问题以及数据溢出现象,除非没有办法
2.byte,short定义的时候如果等号右边是整数常量,如果不超出byte和short的范围,不需要我们自己强转,jvm自动转型 byte,short如果等号右边有变量参与,byte和short自动提升为int,然后结果再次赋值给byte或者short的变量,需要我们自己手动强转 3.char类型数据如果参与运算,会自动提升为int型,如果char类型的字符提升为int型会去ASCII码表(美国标准交换代码)范围内去查询字符对应的int值,如果在ASCII码表范围内没有对应的int值,回去unicode码表(万国码)中找
public class Demo11DataType{public static void main(String[] args){//精度损失int i = (int)2.9;System.out.println(i); /*数据溢出int型占内存4个字节,4个字节变成二进制是32位100个亿: 10 0101 0100 0000 1011 1110 0100 0000 0000 -> 34位二进制100个亿的二进制位比int型的二进制位多出来2位,此时干掉最前面的2位101 0100 0000 1011 1110 0100 0000 0000101 0100 0000 1011 1110 0100 0000 0000->1410065408*/int j = (int)10000000000L;System.out.println(j);//1410065408System.out.println("=========================");byte b = 10;System.out.println(b);b = (byte)(b+1);System.out.println(b);System.out.println("=========================");char c = '中';System.out.println(c+0);//20013}
}
进制 位运算 运算符
进制
| 十进制 | 二进制 | 八进制 | 十六进制 |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 2 | 10 | 2 | 2 |
| 3 | 11 | 3 | 3 |
| 4 | 100 | 4 | 4 |
| 5 | 101 | 5 | 5 |
| 6 | 110 | 6 | 6 |
| 7 | 111 | 7 | 7 |
| 8 | 1000 | 10 | 8 |
| 9 | 1001 | 11 | 9 |
| 10 | 1010 | 12 | a或A |
| 11 | 1011 | 13 | b或B |
| 12 | 1100 | 14 | c或C |
| 13 | 1101 | 15 | d或D |
| 14 | 1110 | 16 | e或E |
| 15 | 1111 | 17 | f或F |
| 16 | 10000 | 20 | 10 |
位运算
1.符号的介绍:a. &(与) -> 有假则假b. |(或) -> 有真则真c. ~(非) -> 取反d. ^(异或) -> 符号前后结果一样为false,不一样为truetrue ^ true -> falsefalse ^ false -> falsetrue ^ false -> truefalse ^ true -> true
2. 1代表true 0代表false
3.我们要知道计算机在存储数据的时候都是存储的数据的补码,计算也是用的数据的补码 但是我们最终看到的结果是原码换算出来的 原码 反码 补码4.正数二进制最高位为0; 负数二进制最高位为1
负数是以补码形式存储和参与运算的
5.如果是正数 原码 反码 补码 一致比如:5的原码 反码 补码一致:0000 0000 0000 0000 0000 0000 0000 0101 -> 因为是正数,二进制最高位为0如果是负数,原码 反码 补码不一样了反码是原码的基础上最高位不变,剩下的0和1互换补码是在反码的基础上+1比如:-9原码: 1000 0000 0000 0000 0000 0000 0000 1001反码: 1111 1111 1111 1111 1111 1111 1111 0110补码: 1111 1111 1111 1111 1111 1111 1111 0111
（1）左移：<<
运算规则：左移几位就相当于乘以2的几次方
注意：当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位
2<<2 结果等于8
快速算法: 2*(2的2次方)
-2<<2 等于-8
快速算法: -2*(2的2次方)
（2）右移：>>
快速运算：类似于除以2的n次，如果不能整除，向下取整
9>>2 等于2快速算法: 9除以(2的2次方)
-9>>2 等于-3快速算法: -9除以(2的2次方)
（3）无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补0，不管最高位是0还是1空出来的都拿0补
正数：和右移一样
9>>>2 等于2
负数：右边移出去几位，左边补几个0，结果变为正数
-9>>>2
结果为:1073741821
笔试题: 8>>>32位 -> 相当于没有移动还是8
8>>>34位 -> 相当于往右移动2位
（4）按位与：&
小技巧:将0看成为false 将1看成true
运算规则：对应位都是1才为1,相当于符号左右两边都为true,结果才为true
1&1 结果为1
1&0 结果为0
0&1 结果为0
0&0 结果为0
5&3 结果1
（5）按位或：|
运算规则：对应位只要有1即为1,相当于符号前后只要有一个为true,结果就是true
1|1 结果1
1|0 结果1
0|1 结果1
0|0 结果0
5|3 结果为7
（6）按位异或：^
运算规则：对应位一样的为0,不一样的为1
1^1 结果为0 false
1^0 结果为1 true
0^1 结果为1 true
0^0 结果0 false
5^3 结果为6
（7）按位取反
运算规则：~0就是1
~1就是0
~10 结果为-11
运算符
提示说明：
（1）表达式不要太复杂
（2）先算的使用(),记住,如果想让那个表达式先运行,就加小括号就可以了
i<(n*m)
1.算数运算符
| 符号 | 说明 |
|---|---|
| + | 加法 |
| - | 减法 |
| * | 乘法 |
| / | 除法 如果符号前后都是整数,结果取整数部分 如果符号前后有一个为小数,结果就是正常小数 |
| % | 模,取余数部分 |
public class Demo01Arithmetic {public static void main(String[] args) {int i = 10;int j = 3;int add = i+j;//推荐使用System.out.println(add);//13System.out.println(i+j);//13int sub = i-j;System.out.println(sub);//7int mul = i*j;System.out.println(mul);//30int div = i/j;System.out.println(div);//3int mo = i%j;System.out.println(mo);//1}
}
+:1.运算2.字符串拼接:任何类型的数据遇到字符串都会变成字符串,此时+就不再是运算了,而是字符串拼接,将内容直接往后拼接 public class Demo02Arithmetic {public static void main(String[] args) {int i = 10;int j = 3;System.out.println(i+j+"");//13System.out.println(i+j+""+1);//131System.out.println(i+""+j);//103System.out.println("i和j相加只和为:"+(i+j));}
}
1.2.自增自减运算符(也算算数运算符的一种)
1.格式:变量++ -> 后自加++变量 -> 前自加变量-- -> 后自减--变量 -> 前自减 自增和自减只变化1
2.使用:a.单独使用: ++ -- 单独为一句,没有和其他的语句掺和使用i++;符号前在在后都是先运算 b.混合使用: ++ -- 和其他的语句掺和使用了(比如:输出语句,赋值语句)符号在前:先运算,在使用运算后的值符号在后:先使用原值,使用完毕之后,自身再运算public class Demo03Arithmetic {public static void main(String[] args) {int i = 10;//i++;++i;System.out.println("i = " + i);System.out.println("==================");int j = 100;int result01 = ++j;System.out.println("result01 = " + result01);//101System.out.println(j);//101System.out.println("==================");int k = 10;int result02 = k++;System.out.println("result02 = " + result02);System.out.println(k);System.out.println("==================");int z = 100;System.out.println(z++);System.out.println(z);System.out.println("==================");int x = 10;int y = 20;/*10+19 = 2929+12 = 41以后开发肯定不会这么写*/int result03 = x++ + --y + ++x;System.out.println("result03 = " + result03);System.out.println("=======================");int c = 10;c = c++;System.out.println(c);//10System.out.println(c);//10}
}
2.赋值运算符
1.基本赋值运算符:= -> 先看等号右边的,再将右边的数据赋值给等号左边的变量
2.复合赋值运算符:+=:int i = 10;i+=2 -> i = i+2-=*=/= : 取整数部分%= : 取余数部分 3.注意:byte short 遇到复合赋值运算符,jvm会自动转型
public class Demo01Assignment {public static void main(String[] args) {int i = 10;i+=2;//i = i+2System.out.println(i);}
}
public class Demo02Assignment {public static void main(String[] args) {byte b = 10;//b = (byte)(b + 1);b+=1;//b = b+1System.out.println(b);}
}
3.关系运算符(比较运算符)
1.结果:boolean型 -> 要么是true,要么是false
2.作用:做条件判断使用
| 符号 | 说明 |
|---|---|
| == | 如果符号前后相等为true;否则为false |
| > | 如果符号前的数据大于符号后的数据为true,否则为false |
| < | 如果符号前的数据小于符号后的数据为true,否则为false |
| >= | 如果符号前的数据大于或者等于符号后的数据为true,否则为false |
| <= | 如果符号前的数据小于或者等于符号后的数据为true,否则为false |
| != | 如果符号前后不相等为true;否则为false |
public class Demo01Compare {public static void main(String[] args) {int i = 10;int j = 20;boolean result01 = i == j;System.out.println("result01 = " + result01);//falseSystem.out.println(i>j);//falseSystem.out.println(i<j);//trueSystem.out.println(i>=j);//falseSystem.out.println(i<=j);//trueSystem.out.println(i!=j);//true}
}
4.逻辑运算符
1.作用:连接多个boolean结果的2.结果:boolean型结果
| 符号 | 说明 |
|---|---|
| &&(与,并且) | 有假则假,符号前后有一个结果为false,整体就是false |
| ||(或者) | 有真则真,符号前后有一个结果为true,整体就是true |
| !(非,取反) | 不是true,就是false;不是false,就是true |
| ^(异或) | 符号前后结果一样为false;不一样为true true^true -> false true^false -> true false^true -> true false^false -> false |
public class Demo01Logic {public static void main(String[] args) {int i = 10;int j = 20;int k = 10;boolean result01 = (i>j) && (i==k);System.out.println("result01 = " + result01);//falseboolean result02 = (i>j) || (i==k);System.out.println("result02 = " + result02);//trueboolean result03 = (i>j) ^ (i==k);//false ^ trueSystem.out.println("result03 = " + result03);//trueboolean result04 = !(i>j) ;System.out.println("result04 = " + result04);//true}
}
符号 说明 & 1.单与,如果前后都是布尔型,有假则假,但是如果符号前为false,符号后的判断会继续执行
2.如果该符号前后都是数字,看做是位运算符&& 1.双与,有假则假,但是有短路效果,如果符号前为false,符号后的判断就不会执行了 | 1.单或,如果前后都是布尔型,有真则真,但是如果符号前为true,符号后的判断会继续执行
2.如果该符号前后都是数字,看做是位运算符|| 1.双或,有真则真,但是有短路效果,如果符号前为true,符号后的判断就不会执行了 public class Demo02Logic { public static void main(String[] args) {int a = 10;int b = 20;//boolean result01 = (++a>100)&(++b>10);//boolean result01 = (++a > 100) && (++b > 10);//boolean result01 = (++a<100)|(++b>10);boolean result01 = (++a<100)||(++b>10);System.out.println("result01 = " + result01);System.out.println("a = " + a);System.out.println("b = " + b); } }问题:定义一个变量(a),随意给一个值,判断这个变量接收的值是否在1-100之间
1<=a<=100 -> 错误,这是数学写法
i>=1 && i<=100 -> java写法,用逻辑运算符拼接多个判断
5.三元运算符
1.格式:boolean表达式?表达式1:表达式22.执行流程:先判断,如果是true,就走?后面的表达式1,否则就走:后面的表达式2
6.1练习1
需求:小明考完试了,判断小明的分数是否及格,返回结果
public class Demo01Ternary {public static void main(String[] args) {//定义一个变量,表示小明的分数int score = 60;String result = score>=60?"及格":"不及格";System.out.println("result = " + result);}
}
6.2练习2
有两个老人,年龄分别为70 80 求出两个老人的最高年龄
public class Demo02Ternary {public static void main(String[] args) {int old1 = 70;int old2 = 80;int max = old1>old2?old1:old2;System.out.println("max = " + max);}
}
6.3 练习3
有三个老人,年龄分别为70 80 60 求出三个老人的最高年龄
public class Demo03Ternary {public static void main(String[] args) {int old1 = 70;int old2 = 80;int old3 = 60;int temp = old1>old2?old1:old2;int max = temp>old3?temp:old3;System.out.println("max = " + max);}
}
流程控制
键盘录入_Scanner
1.概述:是java定义好的一个类
2.作用:将数据通过键盘录入的形式放到代码中参与运行
3.位置:java.util
4.使用:a.导包:通过导包找到要使用的类 -> 导包位置:类上import java.util.Scanner -> 导入的是哪个包下的哪个类 b.创建对象Scanner 变量名 = new Scanner(System.in);c.调用方法,实现键盘录入变量名.nextInt() 输入整数int型的变量名.next() 输入字符串 String型的
public class Demo01Scanner {public static void main(String[] args) {//创建对象Scanner sc = new Scanner(System.in);//录入int型整数int data1 = sc.nextInt();System.out.println("data1 = " + data1);//录入String型字符串String data2 = sc.next();System.out.println("data2 = " + data2);}
}====================================================
public class Demo02Scanner {public static void main(String[] args) {//创建对象Scanner sc = new Scanner(System.in);//录入int型整数int old1 = sc.nextInt();int old2 = sc.nextInt();int old3 = sc.nextInt();int temp = old1>old2?old1:old2;int max = temp>old3?temp:old3;System.out.println(max);}
}变量名.next():录入字符串 -> 遇到空格和回车就结束录入了 变量名.nextLine():录入字符串 -> 遇到回车就结束录入了public class Demo03Scanner {public static void main(String[] args) {Scanner sc = new Scanner(System.in);String data1 = sc.next();String data2 = sc.nextLine();System.out.println(data1);System.out.println(data2);} }Exception in thread "main" java.util.InputMismatchException -> 输入类型不匹配异常at java.base/java.util.Scanner.throwFor(Scanner.java:939)at java.base/java.util.Scanner.next(Scanner.java:1594)at java.base/java.util.Scanner.nextInt(Scanner.java:2258)at java.base/java.util.Scanner.nextInt(Scanner.java:2212)at com.atguigu.a_scanner.Demo04Scanner.main(Demo04Scanner.java:8) 原因:录入的数据和要求的数据类型不一致
Random随机数
学习Random和学习Scanner方式方法一样
1.概述:java自带的一个类
2.作用:可以在指定的范围内随机一个整数
3.位置:java.util
4.使用:a.导包:import java.util.Randomb.创建对象:Random 变量名 = new Random()c.调用方法,生成随机数:变量名.nextInt() -> 在int的取值范围内随机一个整数
public class Demo01Random {public static void main(String[] args) {//创建对象Random rd = new Random();int data = rd.nextInt();System.out.println("data = " + data);}
}
在指定范围内随机一个数:
nextInt(int bound) -> 在0-(bound-1)
a.nextInt(10) -> 0-9
b.在1-10之间随机一个数: nextInt(10)+1 -> (0-9)+1 -> 1-10
c.在1-100之间随机一个数:nextInt(100)+1 -> (0-99)+1 -> 1-100
d.在100-999之间随机一个数: nextInt(900)+100 -> (0-899)+100 -> 100-999
public class Demo02Random {public static void main(String[] args) {//创建对象Random rd = new Random();//在1-100之间随机int data1 = rd.nextInt(100)+1;System.out.println("data1 = " + data1);System.out.println("=====================");//在100-999之间随机一个数int data2 = rd.nextInt(900)+100;System.out.println("data2 = " + data2);}
}switch
学switch if 循环必须要先掌握定义格式,然后掌握执行流程(带一个数进去,根据执行流程观察值的变化)
1.switch基本使用
1.格式:switch(变量){case 常量值1:执行语句1;break;case 常量值2:执行语句2;break;case 常量值3:执行语句3;break;case 常量值4:执行语句4;break;...default:执行语句n;break;}2.执行流程:用变量接收的值和下面case后面的常量值匹配,匹配上哪个case就执行哪个case对应的执行语句如果以上所有case都没有匹配上,就走default对应的执行语句n
3.break关键字:代表的是结束switch语句
4.注意:switch能匹配什么类型的数据:byte short int char 枚举类型 String类型 public class Demo01Switch {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请您输入一个整数:");int data = sc.nextInt();switch (data){case 1:System.out.println("鹅鹅鹅");break;case 2:System.out.println("曲项向天歌");break;case 3:System.out.println("白毛浮绿水");break;case 4:System.out.println("红掌拨清波");break;default:System.out.println("下面没有了");break;}}
}
2.case的穿透性
1.如果没有break,就会出现case的穿透性,程序就一直往下穿透执行,直到遇到了break或者switch代码执行完毕了,就停止了
public class Demo02Switch {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int data = sc.nextInt();switch (data){case 1:System.out.println("鹅鹅鹅");case 2:System.out.println("曲项向天歌");case 3:System.out.println("白毛浮绿水");case 4:System.out.println("红掌拨清波");break;default:System.out.println("下面没有了");break;}}
}public class Demo03Switch {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int month = sc.nextInt();switch(month){case 12:System.out.println("冬季");break;case 1:System.out.println("冬季");break;case 2:System.out.println("冬季");break;case 3:System.out.println("春季");break;case 4:System.out.println("春季");break;case 5:System.out.println("春季");break;case 6:System.out.println("夏季");break;case 7:System.out.println("夏季");break;case 8:System.out.println("夏季");break;case 9:System.out.println("秋季");break;case 10:System.out.println("秋季");break;case 11:System.out.println("秋季");break;default:System.out.println("什么情况,你家有这个月份?");}}
}
if
1.if的第一种格式
1.格式:if(boolean表达式){执行语句;}
2.执行流程:先走if后面的boolean表达式,如果是true,就走if后面大括号中的执行语句,否则就不走
3.注意:if后面跟的是boolean表达式,只要是结果为boolean型的,都可以放在小括号中,哪怕直接写一个true或者false
public class Demo01If {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int data1 = sc.nextInt();int data2 = sc.nextInt();if (data1==data2){System.out.println("两个整数相等");}}
}
2.if的第二种格式
1.格式:if(boolean表达式){执行语句1;}else{执行语句2;}
2.执行流程:a.先走if后面的boolean表达式,如果是true,就走if后面的执行语句1b.否则就走else后面的执行语句2
public class Demo02IfElse {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int data1 = sc.nextInt();int data2 = sc.nextInt();if (data1==data2){System.out.println("两个整数相等");}else{System.out.println("两个整数不相等");}}
}
2.1 练习
任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数
public class Demo03IfElse {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int data = sc.nextInt();if (data%2==0){System.out.println("偶数");}else{System.out.println("奇数");}}
}
2.2练习
需求.利用if else 求出两个数的较大值
public class Demo04IfElse {public static void main(String[] args) {int i = 10;int j = 20;if (i>j){System.out.println(i);}else{System.out.println(j);}}
}public class Demo05IfElse {public static void main(String[] args) {int i = 10;int j = 20;int k = 30;//定义临时变量,接收前两个数的较大值int temp = 0;if (i>j){temp = i;}else{temp = j;}if (temp>k){System.out.println(temp);}else{System.out.println(k);}}
}
2.3练习
案例：从键盘输入年份，请输出该年的2月份的总天数。闰年2月份29天，平年28天。
闰年:a.能被4整除,但是不能被100整除 year%4==0 && year%100!=0b.或者能直接被400整除 year%400==0
步骤:1.创建Scanner对象,调用nextInt键盘录入一个年份 year2.判断(year%4==0 && year%100!=0) || (year%400==0)3.如果条件成立,就输出闰年2月29天,否则输出平年2月28天
public class Demo06IfElse {public static void main(String[] args) {//1.创建Scanner对象,调用nextInt键盘录入一个年份 yearScanner scanner = new Scanner(System.in);int year = scanner.nextInt();//2.判断(year%4==0 && year%100!=0) || (year%400==0)if ((year%4==0 && year%100!=0) || (year%400==0)){//3.如果条件成立,就输出闰年2月29天,否则输出平年2月28天System.out.println("闰年2月29天");}else{System.out.println("平年2月28天");}}
}
2.4练习
public class Demo07IfElse {public static void main(String[] args) {boolean num1 = false;boolean num2 = true;int i = 1;/*num1 = falsenum2 = truenum1 = num2 -> 相当于将num2的true赋值给了num1*/if (num1=num2){i++;System.out.println(i);//2}if (false){--i;System.out.println(i);}}
}3.if的第三种格式
1.格式:if(boolean表达式){执行语句1}else if(boolean表达式){执行语句2}else if(boolean表达式){执行语句3}...else{执行语句n}2.执行流程:从if开始往下挨个判断,哪个if判断结果为true,就走哪个if对应的执行语句,如果以上所有的判断都是false,就走else对应的执行语句n3.使用场景:2种情况以上的判断
public class Demo08ElseIf {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int data1 = sc.nextInt();int data2 = sc.nextInt();/* if (data1>data2){System.out.println("data1大于data2");}else if(data1<data2){System.out.println("data1小于data2");}else{System.out.println("data1等于data2");}*/if (data1>data2){System.out.println("data1大于data2");}else if(data1<data2){System.out.println("data1小于data2");}else if (data1==data2){System.out.println("data1等于data2");}}
}注意:最后一种情况,不一定非得用else,但是必须要保证所有的情况都判断了
3.1.练习
需求:键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
输入 1 输出 星期一
输入 2 输出 星期二
输入 3 输出 星期三
输入 4 输出 星期四
输入 5 输出 星期五
输入 6 输出 星期六
输入 7 输出 星期日
输入 其它数字 输出 数字有误public class Demo09ElseIf {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int week = sc.nextInt();/*if (week==1){System.out.println("周一");}else if (week==2){System.out.println("周二");}else if (week==3){System.out.println("周三");}else if (week==4){System.out.println("周四");}else if (week==5){System.out.println("周五");}else if (week==6){System.out.println("周六");}else if (week==7){System.out.println("周日");}else{System.out.println("是不是有点大病,没有这个星期!");}*/if (week<1 || week>7){System.out.println("是不是有点大病,没有这个星期!");}else{if (week==1){System.out.println("周一");}else if (week==2){System.out.println("周二");}else if (week==3){System.out.println("周三");}else if (week==4){System.out.println("周四");}else if (week==5){System.out.println("周五");}else if (week==6){System.out.println("周六");}else if (week==7){System.out.println("周日");}}}
}
3.2练习
根据最新的年龄段划分标准:0-6岁为婴幼儿7-12岁为少儿13-17岁为青少年18-45岁为青年46-69岁为中年69岁以上为老年
请键盘录入一个年龄,判断属于什么年龄段
public class Demo10ElseIf {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int age = sc.nextInt();/* if (age>=0 && age<=6){System.out.println("婴幼儿");}else if (age>=7 && age<=12){System.out.println("少儿");}else if (age>=13 && age<=17){System.out.println("青少年");}else if(age>=18 && age<=45){System.out.println("青年");}else if(age>=46 && age<=69){System.out.println("中年");}else if (age>69 && age<=130){System.out.println("老年");}else {System.out.println("年龄不太符合实际");}*/if (age<0 || age>130){System.out.println("年龄不太符合实际");}else{if (age>=0 && age<=6){System.out.println("婴幼儿");}else if (age>=7 && age<=12){System.out.println("少儿");}else if (age>=13 && age<=17){System.out.println("青少年");}else if(age>=18 && age<=45){System.out.println("青年");}else if(age>=46 && age<=69){System.out.println("中年");}else if (age>69 && age<=130){System.out.println("老年");}}}
}switch和if的区别:debug
1.switch:会直接跳到相匹配的case
2.if:从上到下挨个判断 -> 实际开发主要用if做判断,灵活
for循环
什么时候使用循环语句:当我们发现一件事或者一段代码在反复执行,我们就可以考虑使用循环语句了
1.格式:for(初始化变量;比较;步进表达式){循环语句 -> 哪段代码循环执行,就将哪段代码放到此处}
2.执行流程:a.先走初始化变量b.比较,如果是true,走循环语句,走步进表达式(初始化的变量的值进行变化) c.再比较,如果还是true,继续走循环语句,走步进表达式d.再比较,直到比较为false,循环结束了
public class Demo01For {public static void main(String[] args) {for(int i = 0;i<3;i++){System.out.println("我爱java");}}
}快捷键: 次数.fori
1.1练习
for循环:求1-3之间的数据和,并把求和结果输出到控制台上
1+2+3
步骤:1.定义一个变量,用来接受两个数的和 sum2.利用for循环将1-3表示出来3.在循环的过程中,两两相加,将结果赋值给sum4.输出sum
public class Demo02For {public static void main(String[] args) {//1.定义一个变量,用来接受两个数的和 sumint sum = 0;//2.利用for循环将1-3表示出来for (int i = 1; i <= 3; i++) {//3.在循环的过程中,两两相加,将结果赋值给sumsum+=i;//sum = sum+i;}//4.输出sumSystem.out.println("sum = " + sum);}
}1.2练习
需求:求出1-100的偶数和
步骤:1.定义一个变量sum,接受两个偶数的和2.利用for循环将1-100表示出来3.判断,如果是偶数,相加,将加的结果赋值给sum4.输出sum
public class Demo03For {public static void main(String[] args) {//1.定义一个变量sum,接受两个偶数的和int sum = 0;//2.利用for循环将1-100表示出来for (int i = 1; i <= 100; i++) {//3.判断,如果是偶数,相加,将加的结果赋值给sumif (i % 2 == 0) {sum += i;}}//4.输出sumSystem.out.println("sum = " + sum);}
}1.3练习
统计一下1-100之间的偶数个数
步骤:1.定义一个变量count,用来计数2.利用for循环将1-100表示出来3.判断,如果是偶数,count++4.输出count
public class Demo04For {public static void main(String[] args) {//1.定义一个变量count,用来计数int count = 0;//2.利用for循环将1-100表示出来for (int i = 1; i <= 100; i++) {//3.判断,如果是偶数,count++if (i % 2 == 0) {count++;}}//4.输出countSystem.out.println("count = " + count);}
}
while循环
1.格式:初始化变量;while(比较){循环语句;步进表达式}2.执行流程:a.初始化变量b.比较,如果是true,就走循环语句,走步进表达式c.再比较,如果还是true,继续走循环语句,继续走步进表达式d.再比较,直到比较为false,循环结束
public class Demo01While {public static void main(String[] args) {int i = 0;while(i<5){System.out.println("我爱java,我更爱钱");i++;}}
}
public class Demo02While {public static void main(String[] args) {int sum = 0;int i = 1;while(i<=3){sum+=i;i++;}System.out.println("sum = " + sum);}
}
public class Demo03While {public static void main(String[] args) {int sum = 0;int i = 1;while (i <= 100) {if (i % 2 == 0) {sum += i;}i++;}System.out.println("sum = " + sum);}
}
public class Demo04While {public static void main(String[] args) {int count = 0;int i = 1;while (i <= 100) {if (i % 2 == 0) {count++;}i++;}System.out.println("count = " + count);}
}
1.1while练习
需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度? 27步骤:1.定义一个变量表示山峰的高度 mountain2.定义一个变量表示纸的厚度 paper3.定义一个变量表示折纸的次数 count4.利用while循环循环比较,如果paper<mountain 就循环对折paper = paper*2;count++;5.输出count
public class Demo05While {public static void main(String[] args) {//1.定义一个变量表示山峰的高度 mountainint mountain = 8844430;//2.定义一个变量表示纸的厚度 paperdouble paper = 0.1;//3.定义一个变量表示折纸的次数 countint count = 0;/*4.利用while循环循环比较,如果paper<mountain 就循环对折paper = paper*2;count++;*/while(paper<mountain){paper*=2;count++;}//5.输出countSystem.out.println("count = " + count);}
}
do...while
1.格式:初始化变量;do{循环语句;步进表达式}while(比较);2.执行流程:a.初始化变量b.走循环语句c.走步进表达式d.判断,如果是true,继续循环,直到比较为false,循环结束3.特点:至少循环一次
public class Demo01DoWhile {public static void main(String[] args) {int i = 0;do{System.out.println("我爱java");i++;}while(i<5);}
}
循环控制关键字
1.break:a.在switch中代表结束switch语句b.在循环中代表结束循环 2.continue:结束当前本次循环,直接进入下一次循环,直到条件为false为止
public class Demo01BreakAndContinue {public static void main(String[] args) {for (int i = 1; i <= 5; i++) {if (i==3){//结束循环//break;//结束本次循环,进入下一次循环continue;}System.out.println("我爱java"+i);}}
}
死循环
1.概述:一直循环
2.什么条件下一直循环:比较条件一直是truepublic class Demo01Endless {public static void main(String[] args) {int count = 0;for (int i = 0; i < 10;) {count++;System.out.println("我爱java"+count);}/* while(true){count++;System.out.println("我爱java"+count);}*/}
}
嵌套循环
1.概述:循环中还有循环
2.执行流程:先执行外层循环,再进入内层循环,内层循环就一直循环,直到内层循环结束,外层循环进入下一次循环,直到外层循环都结束了,整体结束
public class Demo02Nest {public static void main(String[] args) {for (int fen = 0; fen < 60; fen++) {for (int miao = 0; miao < 60; miao++) {System.out.println(fen+"分"+miao+"秒");}}}
}
练习:打印矩形
public class Demo03Nest {public static void main(String[] args) {//外层循环控制行for (int i = 0; i < 5; i++) {//内层循环控制列for (int j = 0; j < 5; j++) {System.out.print("* ");}System.out.println();}}
}
练习:打印直角三角形
*
* *
* * *
* * * *
public class Demo04Nest {public static void main(String[] args) {for (int i = 1; i < 5; i++) {for (int j = 0;j<i;j++){System.out.print("* ");}System.out.println();}}
}练习
猜数字小游戏
1.创建Scanner和Random对象
2.调用Random中的nextInt(100)+1在1-100之间随机一个数 rdNumber
3.调用Scanner中的nextInt()方法 键盘录入一个要猜的数 scNumber
4.如果scNumber大于rdNumber,证明猜大了
5.如果scNumber小于rdNumber,证明猜小了
6.如果scNumber等于rdNumber,证明猜中了
public class Demo01Exam {public static void main(String[] args) {//1.创建Scanner和Random对象Scanner sc = new Scanner(System.in);Random rd = new Random();//2.调用Random中的nextInt(100)+1在1-100之间随机一个数 rdNumberint rdNumber = rd.nextInt(100) + 1;while(true){//3.调用Scanner中的nextInt()方法 键盘录入一个要猜的数 scNumberSystem.out.println("请您猜一个数:");int scNumber = sc.nextInt();//4.如果scNumber大于rdNumber,证明猜大了if (scNumber>rdNumber){System.out.println("对不起,您猜大了!");}else if (scNumber<rdNumber){//5.如果scNumber小于rdNumber,证明猜小了System.out.println("对不起,您猜小了!");}else{//6.如果scNumber等于rdNumber,证明猜中了System.out.println("恭喜您,猜中了!");break;}}}
}
