目录
一、基本数据类型转换
类型转换有两种: 自动类型转换 、强制类型转换
从小到大(按字节空间排序):byte --->short ----> int ----->long ---->float ----->double
其他类型基本不用,所以这里不强调
2.强制类型转换(显示转换):将大类型转载(赋值)给小类型的过程
强转有风险,使用需谨慎,有可能强转后的类型装载不了强转之前的数据.
(就是可能因为数据太大了,前面的小类型无法装载,就会报错)
需要强转的时候的例子: a = 100L; int b = (int)a;
所以要确保数据不会溢出才转.
代码实例:
/自动类型转换
int a = 100;//没有发生类型转换!
long b = a;//发生自动类型转换
double c = b;//发生自动类型转换
//强制类型转换
long d = 2147483647L;//long类型的数据
int e = (int)d;//使用强制转换的语法:在需要强制转换的变量前面加上小括号,小括号里写要转换的类型即可
System.out.println(e);
double f = 3.1415926;
int g = (int)f;//将小数类型强转为整数类型时, 会截断删除小数点后的内容.
System.out.println(g);//3
规则:
- 整数直接量是可以直接赋值给byte ,short , char类型的!但是不能超过当前类型范围
(例子:char t = 97 这里的97是ASCII码,输出t会是输出它对应的字母。) - byte,short,char 如果进行运算时,系统会自动将其结果转换为int类型!
(比如:byte a = 10; byte b = 20; 那 byte c = a + b就会报错,因为此时的c默认为int,所以要得出c的话就需要int c = a + b,或者强转为byte) - 小类型与大类型在参与运算时,系统会自动将其结果转换为大类型.
-
默认的整数直接量是 10进制 直接量,由数字:0123456789组成(例:100)
-
使用0x开头的直接量是16进制直接量,由数字及字母:0123456789abcdef组成
(例:0xef123b)使用0开头的直接量是 8进制 直接量,由数字:01234567组成(例:0123)
使用0b开头的直接量是 2进制 直接量,由数字:01组成(例:0b00101)
char d = 'a';//97
char e = 'a';//97
System.out.println(d + e);//194 两个char相加结果为int
System.out.println((char)(d + e));//将int的码转换为字符显示
byte b1 = 100;
byte b2 = (byte)(b1+20);
int b2 = b1 +20; //byte(小类型) + int (大类型) 运算结果就是大类型.
二、运算符
数学运算符
+,-,*,/,%
%是取余,取模,算出余数
注意:取余操作时,若左边小于右边,则取余结果仍然为左边的数据。
比如:
System.out.println(1 % 3);//1
System.out.println(2 % 3);//2
System.out.println(3 % 3);//0
自增自减运算符(重要)
自增:在变量自身基础上增加1 自增符号(++)
注意符号要紧挨着。
1.单独运算时(只有当前变量被运算),符号在前在后都一样,都会完成自增或者自减。
int a = 5;
a++
System.out.println(a);//6
++a
System.out.println(a);//7
2.1符号如果在后,就会先参与其它运算,然后再去进行自增或自减。
2.2符号如果在前,就会先进行自增或自减,再去参与其它运算。
看下面这两个例子就懂了:
int a = 5;
int b = 5;
int c = a++;
int d = ++b;
System.out.println(a);//6
System.out.println(b);//6
System.out.println(c);//5
System.out.println(d);//6
/**
* 面试题:
* */
int a = 1;
//符号在后,所以先将变量的内容赋值给临时变量进行存储。
//接着再进行变量的自增
//最后再将临时变量赋值给a
a = a++; //(1)temp = a; (2) a = a+1; (3) a = temp;
System.out.println(a);//输出1
int b = 1;
//符号在前,(1)先将变量进行自增
//(2)再将变量的内容赋值给临时变量进行存储。
//(3)最后再将临时变量赋值给b
b = ++b;//(1)b = b+1; (2) temp = b; (3) b = temp;
System.out.println(b);//输出2
关系运算符
大于( > ) ,小于( < ) ,大于等于( >= ) ,小于等于( <= ) 等于号( == ) ,不等于号( != )
关系运算符的运算结果一定是boolean类型的结果。(和python一样,没什么好说的)
主要看代码的写法:
int a = 50; int b = 40;
boolean r = a > b;
int c = 50; int d =50;
boolean r1 = c >= d;
int e = 100; int f = 99;
f++;
boolean r2 = e == f;
System.out.prinln(r2);//true
System.out.prinln(100 != 100); // false
---------------------------------------
int a = 50;
int b = 40;
boolean r = a > b;
System.out.println(r);
System.out.println(a <= b);//false
System.out.println(10 < 10);// false
System.out.println(10 != 10);//false
System.out.println(5 == 4);//false
逻辑运算符
逻辑运算符是结果一定是boolean类型
Java中逻辑运算符分为3种:
与(&&)、或(||)、非(!)
例子(必看):
int a = 5;
int b = 10;
int c = 5;
boolean r = a > b && b > c;// false && true
System.out.println(r);//false
System.out.println(a > b || b > c);//false
System.out.println(a == ++c && c > 5);//false
//注意 这个时候c在此时已经自增过了。
System.out.println(c == ++a && b == 10);//所以这个是对的,true
//所以代码要结合一起去看,自增和自减之后,无论是不是赋予了变量,
//还是在自增或自减里面发生了改变,都一定会改变目前变量的值,面试题常考。
一道简单的逻辑判断题
判断年份是否为闰年?
//闰年的判断条件:
/**
* 条件1 : 年份能被4整除 并且 年份不能被100整除
* 或者
* 条件2: 年份能被400整除
* */
Scanner s = new Scanner(System.in);//创建了一个扫描器
System.out.println("请输入要判断闰年的年份,回车即可");
int year = s.nextInt();//使用扫描器接收控制台中int类型的数据 并存给了year
// boolean r1 = year % 4 == 0 && year % 100 != 0; //条件1
// boolean r2 = year % 400 == 0;//条件2
// boolean result = r1 || r2;//条件1 或(||) 条件2
// System.out.println(result);
//推荐写法: 条件1 或 条件2
boolean result2 = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
System.out.println(result2);
扫描器 Scanner (重要)
作用:可以通过Scanner在控制台中输入数据并接收,方便后续的代码逻辑操作。
Scanner在写入时,不需要拼全,显示后直接回车即可!
创建时:Scanner 变量名 = new Scanner(System.in);
(例如:Scanner s = new Scanner(System.in)
使用时:数据类型 变量名 = 扫描器的变量名.next数据类型(例:int year = s.nextInt())
赋值运算符
赋值号: =
直接看例子即可:
//扩展赋值号的使用:使用扩展赋值号对自身变量进行运算,并将结果影响自身的操作.
int a = 10;
a += 10; //等价于: a = a + 10;
System.out.println(a);//20
a -= 10; //等价于: a = a - 10;
System.out.println(a);//10
a *= 2; //等价于: a = a * 2;
System.out.println(a);//20
a /= 5; //等价于: a = a / 5;
System.out.println(a);//4
a %= 2; //等价于: a = a % 2;
System.out时.println(a);//0
//面试题:
byte b = 5;
b = b + 5; 会显示编译错误:因为小类型+大类型 结果为大类型
b += 5;//但是注意!在使用扩展赋值时,系统会自动帮我们做强转为小类型
//比如这里相当于b = (byte)(b + 5);并且不会报错
三元(三目)运算符
语法: boolean ? 值1 : 值2 ;
判断的逻辑 ? 若为true 返回值1: 若为false返回值2
看例子就懂了:
int a = 10;
int b = 20;
//使用三元表达式时,用什么类型来接受主要看值1和值2的类型
//所以一般值1和值2类型要求统一.
// 判断的逻辑 ? 若为true 返回值1 : 若为false返回值2
int max = a > b ? a : b;
System.out.println(max);
int c = 10;
boolean r = c % 2 == 0 ? true : false;
System.out.println(r);
String s = c%2 == 0 ? "是偶数":"是奇数";
System.out.println(s);
字符串拼接符
字符是char类型,用单引号进行存储,只能存储一个字符(如 char temp = 'A')
字符串是String类型,用双引号来进行存储,可以存储一串字符.(如 String name = "你好")
7.2 使用+号时,若里面只要有一方为字符串类型,则把所有进行拼接操作,变成一个整体的字符串.
和python基本一致
例子:(重点看代码的实现,去复现)
int c = 10;
boolean r = c % 2 == 0 ? true : false;
System.out.println(r);
String s = c % 2 == 0 ? "是偶数" : "是奇数";
System.out.println(c + "这个值是:" + s);
int age = 30;
String name = "李四";
System.out.println("我叫:" + name + "我的年龄是:" + age);
System.out.println(10 + 10 + "" + 30);//"2030"
System.out.println("" + 10 + 10 + 30);//“101030”(7.2的例子)
System.out.println(10 + 10 + 30 + "");//"50"
//注意!这里是从左加到右,所以从前往后开始计算且拼接
流程控制
Java中流程控制分为3种,任何复杂的业务逻辑,都可以通过这三种方式来实现.
顺序结构
分支结构
单路分支
/** 语法结构:
* 条件
* if(boolean){
* //条件成立则执行的代码块
* }
* 执行过程:
* 判断if小括号中的条件是否成立。
* 若成立,则执行条件成立的代码块
* 若不成立,代码跳过if的代码块...继续向下执行
*/
双路分支
/**语法结构
* 条件
* if(boolean){
* 满足条件所执行的代码块
* } else{ 否则..
* 不满足条件 所执行的代码块
* }
* 执行过程:
* 先去判断if小括号里面的条件
* 若成立则执行 满足条件所执行的代码块
* 若不成立则执行 不满足条件 所执行的代码块
多路分支
if else if
/**语法结构
* if(条件1){
* 若条件1成立 则执行当前代码块
* } else if(条件2){
* 若条件2成立 则执行当前代码块
* }else if(条件3){
* 若条件3成立 则执行当前代码块
* }...
Switch case
适用性:对数值的数据进行判等时,使用switch case 效率要比if elseif 高一些。
而且Java7版本以后支持可以使用String。(使用s.nextLine()接受字符串)
面试题:Swicth case 结构中 ,接收的num支持的类型有:
byte、short、int、char、String、枚举值,记得long不行
//语法结构
int num = s.nextInt();
//这里要带括号,并且num只是一个数字
switch(num){
case 1://这里的1是什么数字都行,但是记得后面没有括号,
//并且case后面是数字
case 2:
case 3:
default:
System.out.println("对不起");
例子:
Scanner s = new Scanner(System.in);
System.out.println("中文请按1,英文请按2 ,人工服务请按0");
int num = s.nextInt();
switch (num){
case 1://如果输入的num = 1
System.out.println("中文服务开始");
break;//退出当前switch代码块
case 2://如果输入的num = 2
System.out.println("英文服务开始");
break;//退出当前switch代码块
case 0://如果输入的num = 0
System.out.println("人工服务请稍后...");
break;//退出当前switch代码块
default://默认 执行到这里代表上述的case 都没匹配上,默认执行的语句,相当于else
System.out.println("指令输入有误");
}
System.out.println("代码继续向后执行");
}
循环结构
Java中循环分为3种:1.while 2.do while 3.for(最常用)
循环三要素:1.循环变量的初始化 2.基于循环变量的条件 3.循环变量的改变
例子:
跑三圈
初始圈数 圈数为0
够三圈吗? 不够 跑一圈 圈数为1
够三圈吗? 不够 跑一圈 圈数为2
够三圈吗? 不够 跑一圈 圈数为3
够三圈吗? 够了 不跑了
三要素:
1.int count = 0; //循环变量的初始值
2. count < 3 ; //基于循环变量的条件
3. count++;//循环变量的改变
While 循环
有可能一次都不执行
/** while循环的语法结构
* 1.循环变量初始化
* while(2.条件){
* 条件成立则执行的代码块
* 3.循环变量的自增
* }
* */
do while循环
先做一次循环的代码块,再去判断条件,至少执行一次循环的代码块。
do while 语法演示:
* 1.
* do{
* 循环的代码块
* }while(条件);
经典例子:猜大小
Math.random(); 是java提供一个工具,是用来生成随机数的功能。生成的随机数是0~1但是取不到1的小数。
//随机数的使用:
double r = Math.random();//返回0~1的随机小数 取不到1
// System.out.println(r);
// double r1 = Math.random()*100;
// System.out.println(r1);
int r2 = (int)(Math.random()*100);//将随机的小数数据 强转为整数并使用r2变量进行接收
// System.out.println(r2);
//区间随机数的公式: (int)(随机数 *(最大值-最小值)+最小值)
// 90 - 100 区间的随机整数
int r3 = (int)(Math.random() * (100 - 90) +90);
System.out.println(r3);
/* 猜大小:
* 通过程序产生0~100区间的随机数,然后提示用户输入 猜0~100区间的数字,用户若猜对则提示猜对了,
* 若猜错了,则提示猜错了。
* 2.0 : 用户若猜错了,继续让用户猜,条件:用户猜不对!就要一直猜
* 3.0 : 若猜错,提示 猜大了还是猜小了。
* */
int r = (int) (Math.random() * 100);//系统产生的数据0-100 取不到100的随机
Scanner s = new Scanner(System.in);//创建一个扫描器
int user;
do {
//变量能在当前类的哪里使用,从上数离它最近的开始花括号 { 和对应的结束花括号的位置。
System.out.println("请猜0-99之间的数据" + r);
user = s.nextInt();//通过控制台接收用户输入的int的数据 存给 user这个变量
if (user == r) {//如果用户输入的数据 和 系统产生的数据一样
System.out.println("666,猜对了");
} else if (user > r) {//如果用户猜的数据大于系统产生的数据
System.out.println("555,猜大了");
} else {//否则用户一定是猜小了
System.out.println("555,猜小了");
}
} while (user != r);//用户猜不对就要一直循环!
面试题:while 和do..while的区别
相同点:当不明确循环次数时,已知循环条件,可以选择while或 do..while
while :先去判断条件,再去执行循环代码块,有可能一次都不执行代码块。
do..while:先做一次循环体,再判断条件,至少执行一次代码块。
for循环(最常用)
当已知循环次数时,使用for循环。
continue:跳过当次循环 ,直接执行第for循环语法进行下一次的循环!
遇到continue后面的循环代码内容则不再执行了,继续下次循环。
break; 退出当前循环,相当于代码若遇到 break 直接退出循环了!
遇到break后直接退出循环,即使循环代码块的代码还没执行完,也直接退出不会再执行!
语法结构:
for(int i = 0; i < 3; i++){
* 循环代码块(循环体)
* }
for中声明的变量比较特殊,且只能在for中可用。其它地方视为看不到。
for(int i = 0;...){
}
for(int i = 0;...){ //与上面的for循环中的i不冲突!
}