运算符:
分类:
算数运算符
赋值运算符
比较运算符|关系运算符
逻辑运算符
条件运算符
位运算符
操作数: 运算符左右两边的数
表达式: 运算符连接操作数整体叫做表达式
语句: 分号代表语句的结束
单目|一元运算符: 操作数为1个 +号 ++ –
双目|二元运算符: 操作数为2个 + - * / 加减乘除
三目|三元运算符: 条件运算符
============================================================
算数运算符: +
作用: 作为正负号使用
正号(可省略)
public class Test01{
public static void main(String[]args){
int a = 3;
System.out.println(+3);//+号可以省略
System.out.println(3);
/*
以上代码结果输出是一样的,3前面的可以省略.
*/
}
}
加法运算
代码演示:
public class Test01{
public static void main(String[]args){
int a = 3;
int b = 5;
System.out.println(a+b);//+号作为加法运算符出现,输出的结果为8,即3+5=8;
/*
以上代码中的加号是属于加法运算.
*/
}
}
字符串的连接符
代码演示:
public class Test01{
public static void main(String[]args){
int a = 3;
//如果+左右两边有字符串的出现"",+就是作为字符串的连接符使用,把两边的内容拼接成为一整个字符串使用
System.out.println("a="+a);//+号作为字符串的拼接符出现,输出的结果为a=3;
/*
*/
}
}
-作为负号使用
减法运算
代码演示:
public class Test01{
public static void main(String[]args){
int a = 3;
int b = 5;
System.out.println(b-a);//-号作为减法运算符出现,输出的结果为2,即5-3=2;
/*
以上代码中的-号是属于减法运算.
*/
//为a重新赋值
a=-8;
System.out.println("a="+a);//-号作为负号出现,输出的结果为a=-8;
}
}
*乘以
代码演示:
public class Test01{
public static void main(String[]args){
int a = 3;
int b = 5;
System.out.println(a*b);//*号作为乘法运算符出现,输出的结果为15,即3*5=15;
}
}
/*
以上代码中的*号是属于乘法运算.
*/
/除以
代码演示:
public class Test01{
public static void main(String[]args){
int a = 4;
int b =8;
System.out.println(b/a);// *号作为除法运算符出现,输出的结果为2,即8/4=2;
}
}
/*
以上代码中的/号是属于除法运算.
*/
% 模以 取模 求余数
代码演示:
public class Test01{
public static void main(String[]args){
int a = 3;
int b =8;
System.out.println(b%a);// %号作为求余数出现,输出的结果为2,即8/3,余数为2;
//以上代码中的%号是属于求余数.
System.out.println(a%b);//输出结果为3,第一个操作数小于第二个操作数,即a<b 3<8;
//如果第一个操作数小于第二个操作数,结果就为第一个操作数
}
}
============================================================
自增与自减 ++ –
/*
++ 自增 a++ ==> a=a+1;
-- 自减 a-- ==> a=a-1;
分析:
++,--操作自己
++放在操作数的前面还是后面,都是自身+1
--放在操作数的前面还是后面,都是自身-1
++,--操作别人
++--放在操作数的前面,先自身+1|-1,再去参与运算
++--放在操作数的后面,先去参与运算,在自身+1-1
*/
代码演示:
public class Test01{
public static void main(String[]args){
int a = 3;
int b = 5;
a++;//不参与其他运算,++放在操作数的前面还是后面,都是自身+1
System.out.println("a="+a);// 输出结果为4
//运行完以上代码,这里a的值已经为4了.
b = ++a+b;//涉及到参与运算,结果影响到最终b的值,++放在操作数的前面,先自身+1,再去参与运算
System.out.println("b="+b);//输出结果为10; 即5+5=10;
int x = 5;
int y = 8;
y = x++ + y;//涉及到参与运算,结果影响到最终y的值,++放在操作数的后面,先参与运算,再自身+1;
//以上代码经过运行,x++后,x的值已经为6;
System.out.println("x="+x);//输出结果为 x=6;
System.out.println("y="+y);//输出结果为 y=13,即5+8=13;
//--同理
}
}
/*总结一句话:单独一个操作数前面有++或者--,结果都是自身+1或者-1,如果参与运算了,那么需要看符号在操作数的前面还是后面,如果在前,那么自身+1和或者-1,然后参与运算,如果在操作数的后面,那么先参与运算,然后自身+1或者-1;
*/
============================================================
赋值运算符
代码演示:
public class Test01{
public static void main(String[]args){
int a = 4;//把4赋值给a;自右向左运算
System.out.println(a);//输出结果为4;
}
}
基础赋值运算符 = 是java中唯一一个自右向左运算的符号,优先级最低
/*
扩展赋值运算符(算数运算符+基础赋值运算符)
a+=b a+=b; ==> a=a+b;
a-=b a-=b; ==> a=a-b;
a*=b a*=b; ==> a=a*b;
a/=b a/=b; ==> a=a/b;
a%=b a%=b; ==> a=a%b;
*/
public class Test01{
public static void main(String[]args){
int a = 4;
int b = 6;
a+=b;//a+=b a+=b; ==> a=a+b;
System.out.println("a="+a);//输出结果为a=10;即a=a+b ==>a=4+6;
}//-=,*=,/=,%=,同理
}
/*
推荐使用扩展赋值运算符
优点:
执行效率高
*/
============================================================
关系运算符|比较运算符
/*
> 大于
< 小于
>= 大于等于
<= 小于等于
只能比较基本数据类型 byte short char int long float double
== 等于 注意:在java中,=是赋值运算符,和==不一样;
!= 不等于
基本数据类型的数据,引用数据类型的数据都可以比较是否相等
最终的运算结果,都为boolean类型的值
*/
public class Test01{
public static void main(String[]args){
int a = 4;
int b = 6;
System.out.println(a>b);//输出结果为false;
System.out.println(a+3 != b-1); //输出结果为true;经过运算得到7不等于5,结果为true
}//关系运算符|比较运算符,最终的运算结果,都为boolean类型的值.
}
=======================================================================================
Java中的逻辑运算符
// & 与
public class Test01{
public static void main(String[]args){
//一个false就是false,两个都为true,才为true
System.out.println(true&false);//输出结果为false;
System.out.println(false&true);//输出结果为false;
System.out.println(false&false);//输出结果为false;
System.out.println(true&true;//输出结果为true;
}
}
// | 或
public class Test01{
public static void main(String[]args){
//一个为true就是true,两个都为false,才是false
System.out.println(true|false);//输出结果为true;
System.out.println(false|true);//输出结果为true;
System.out.println(true|true);//输出结果为true;
System.out.println(false|false);//输出结果为false;
}
}
// ! 非
public class Test01{
public static void main(String[]args){
// 取反 !true->false !false->true
System.out.println(!true);//输出结果为false;
System.out.println(!false);//输出结果为true;
}
}
// ^ 亦或
public class Test01{
public static void main(String[]args){
// 相同为false,不同为true
System.out.println(true^false);//输出结果为true;
System.out.println(false^true);//输出结果为true;
System.out.println(true^true);//输出结果为false;
System.out.println(false^false);//输出结果为false;
}
}
/*
短路: 如果第一个操作数就能够决定最终的结果,第二个操作数位置不执行
&& 短路与
|| 短路或
单|和单&与双||和双&& 判断的结果是一样,只是多了一个短语的作用.
推荐使用短路内容,执行效率高.
所有的逻辑运算符的操作数都为值为boolean类型的表达式
*/
============================================================
Java中的条件运算符
代码演示:
public class Test01{
public static void main(String[]args){
int a = 4;
int b = 6;
/*
格式:条件表达式 ? 值1 : 值2;条件表达式:值为boolean类型的表达式
执行流程:
1.条件表达式 ,最终会得到一个boolean结果
2.如果结果为true,整个条件表达式最终的结果为值1
3.如果结果为flase,最终结果为值2
条件运算符最终肯定会得到一个结果
*/
int m = a>b? a:b;
//打印最大值
System.out.println("最大值为"+m);//输出结果:最大值为6;
}
}
============================================================
Java中的位运算符 (了解)
/*
测试java中的位运算符(了解)
先把操作数转为2进制,再去运算,得到结果转为十进制
& 同一位置的两个数如果两个都为1才是1,一个为0就是0
| 同一位置的两个数如果一个为1就是1,两个都为0才是0
^ 同一位置的两个数如果一相同为0,不同为1
位移运算符
>> 右移 先把第一个操作数转为2进制,向右移动第二个操作数个位数,想象原数据右侧有分水线,最终看左侧保留的二进制数据转为十进制
/2 8>>3 --> 8/2^3 ==1
<< 左移 先把第一个操作数转为2进制,向左移动第二个操作数个位数,空位补0,转为十进制
*2 8<<3 --> 8*2^3
*/
public class Operator07{
public static void main(String[] args){
System.out.println(2&3); //得到的结果为2
System.out.println(2|3); //得到的结果为3
System.out.println(2^3); //得到的结果为1
System.out.println(8>>3); //得到的结果为1
System.out.println(8>>2); //得到的结果为2
System.out.println(8<<3); //得到的结果为64
System.out.println(8<<1); //得到的结果为16
System.out.println(9>>2); //得到的结果为2
运算符优先级口诀: 单目算数位关系,逻辑三目后赋值
============================================================
java中的Scanner:
/*注意:不要让你的类名与java中已有的类名一致
数据类型有基本数据类型和引用数据类型
基本数据类型:
int a = 5;
引用数据类型的使用:
1).创建一个该类型的引用|变量
引用数据类型 变量名 = new 引用数据类型();
2) 使用功能
变量名.功能名字();
Scanner : 接收键盘输入
1.导包 告诉 编译器Scanner类的位置
import 包名+类名;
位置: 类的上面导包
2.创建一个Scanner类型的引用|变量
Scanner sc=new Scanner(System.in);
3.使用功能
*** sc.nextInt(); 接收用户输入的int类型的数据
sc.nextByte(); 接收用户输入的Byte类型的数据
sc.nextShort();接收用户输入的Short类型的数据
sc.nextLong();接收用户输入的Long类型的数据
*** sc.nextDouble();接收用户输入的Double类型的数据
sc.nextFloat();接收用户输入的Float类型的数据
*** sc.next(); 接收用户输入的字符串类型的数据
从有效字符开始,遇到空格就无法接收,遇到enter结束功能
*** sc.nextLine(); 接收String类型数据,空格也接收,以行为单位接收
4.关闭
sc.close(); 关闭资源
必须要等待全部使用完毕Scanner的功能才能关闭
*/
//导包 位置: 类的上面导包
import java.util.Scanner;
public class ScannerTest{
public static void main(String[] args){
//1.导包
//2.创建一个Scanner类型的引用|变量
Scanner sc=new Scanner(System.in);
//3.使用功能
//键盘接收数字
System.out.println("请输入数字");
int i=sc.nextInt();
//打印键盘接收的整数型数字
System.out.println(i);
//接收用户输入的字符串类型的数据
System.out.println("请输入文字");
String str = sc.next();
//打印键盘接收的字符串
System.out.println(str);
sc.close(); //关闭资源
//必须要等待全部使用完毕Scanner的功能才能关闭,关闭后就算重新创建也没用
}
}
============================================================
java中的Random:
/*
java中的Random的作用是产生随机数
1.导包
2.创建该类型的引用或者变量
3.使用功能
nextInt() 随机产生一个int范围内的整数
nextInt(整数n) 产生一个 [0,n) 随机整数
nextDouble() 随机产生[0,1)之间的随机小数
公式:
[0,max] ran.nextInt(max+1);
[min,max] ran.nextInt(max-min+1)+min;
[min,max) ran.nextInt(max-min)+min;
*/
//导包
import java.util.Random;
public static void main(String[] args){
//1.导包
//2.创建该类型的引用或者变量
Random ran = new Random();
//3.使用功能
int i=ran.nextInt();
System.out.println(i);
//随机生成0~19之间的整数; 公式:[0,max] ran.nextInt(max+1);
int i2=ran.nextInt(20);
//打印生成的随机数
System.out.println(i2);
//随机生成[1,19]之间的随机整数
i3=ran.nextInt(19)+1; //公式:[min,max) ran.nextInt(max-min)+min;
//打印生成的随机数
System.out.println(i3);
//随机生成[5,10]之间的随机整数
i4=ran.nextInt(10-5+1)+5;
//打印生成的随机数
System.out.println(i4);
//随机产生 [50,100] 判断这个数是否是3的倍数
int num =ran.nextInt(100-50+1)+50;//公式:[min,max] ran.nextInt(max-min+1)+min;
//打印生成的随机数
System.out.println(num);
System.out.println(num%3==0?"是3的倍数":"不是3的倍数");
}
}
=======================================================================================
Java中流程控制语句
/*
流程控制语句:
顺序结构: 默认执行顺序 从上倒下,从左到右
选择结构: 满足条件执行对应的语句体
循环结构: 重复执行某些代码
if..else
switch
单选泽|单分支:
if(条件){
语句体;
}
条件:是一个值为boolean类型的表达式
满足条件,就执行{}中的语句体,不满足条件,跳过整个if结构
*/
public class IfTest{
//主方法是程序的入口,逐行执行
public static void main(String[] args){
//单选择:
if(false){
System.out.println("if语句结果为false,不执行此语句");
}
System.out.println("正常执行");
if(true){
System.out.println("if语句结果为true,执行此语句");
}
System.out.println("正常执行");
}
}
/*
双选泽|双分支:
if(条件){
语句体1;
}else{
语句体2;
}
执行流程:
1.执行条件表达式,如果结果为true,就执行语句体1
2.如果结果为false,就执行语句体2
*/
public class IfElseTest{
//主方法是程序的入口,逐行执行
public static void main(String[] args){
//双选
String name="zhangsan";
if("zhangsan".equals(name)){
System.out.println("用户名正确");
}else{
System.out.println("用户名错误");
}
}
}
/* 多选泽|多分支:
if(条件1){
语句体1;
}else if(条件2){
语句体2;
}else if(){
....
}
...
else{
语句体n;
}
执行流程:
1.计算条件表达式1,如果结果为true,执行语句体1,如果结果为false
2.执行条件表达式2,如果结果为true,执行语句体2,如果结果为false
....
如果以上条件都不满足,执行else中的语句体n
*/
//导包
import java.util.Scanner;
public class Test01{
//写主方法
public static void main(String[]args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入小明的一门成绩");
int num = sc.nextInt();
if(num==100){
System.out.println("爸爸给你买个iphoneX");
}else if (num>=90&&num<100){
System.out.println("爸爸给你买个iphone8");
}else if(num>=60&&num<90){
System.out.println("别灰心,爸爸给你买各种学习资料");
}else if(num>0&&num<60){
System.out.println("买学习资料,上补习班,各种爱的教育,如果下次还不及格,小心皮鞭沾凉水");
}else{
System.out.println("我看你是快了!!!");
}
sc.close();
}
}
/*
只要{}中的语句体只有一句的时候,前后的{}可以省略
if与条件运算符之间的区别:
if可以没有结果,条件运算符肯定有一个结果
if可以同时对多个条件进行判断
结果复杂推荐使用if,如果结构简单,推荐使用条件运算符
*/
=======================================================================================
java中的switch语句
/*
swtich 语句:定值判断
switch(表达式){
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
...
default:
语句体n;
break;
}
执行流程:
1.计算表达式,得到一个结果,值
2.第一步算出的结果值与case后的值进行判断,如果相等,就执行对应的语句体,如果不相等,就继续向下判断
3.如果执行了语句体,后如果有break,结束整个switch语句,如果没有break会发生case穿透
4.如果以上所有case后的值都不满足条件,执行default(接盘侠 else)
表达式: 只能为byte,short,char,int,String(jdk1.7之后),枚举(jdk1.5) seo 搜索引擎优化
case穿透: 满足条件的语句体执行之后,如果没有break,下面的case无论是否满足条件,都会执行他们的语句体,直到遇到下一个break或switch的结果而结束
default:位置可以任意改变,break可以省略,但是如果写在switch最后,省略break没有影响,其他位置会发生case穿透
if和switch区别:
1.if可以做区间判断,可以做定定值判断
2.switch只能做定值判断
能使用switch地方都能使用if
*/
public class SwitchTest01{
//主方法是程序的入口,逐行执行
public static void main(String[] args){
String flag="红灯";
switch(flag){
case "红灯":
System.out.println("红灯停");
break;
case "黄灯":
System.out.println("黄灯等一等");
break;
case "绿灯":
System.out.println("绿灯行");
break;
default:
System.out.println("没有这种颜色的灯!!!");
break;
}
}
}
case穿透
public class SwitchTest01{
//主方法是程序的入口,逐行执行
public static void main(String[] args){
//case穿透: 满足条件的语句体执行之后,如果没有break,下面的case无论是否满足条件,都会执行他们的语 句体,直到遇到下一个break或switch的结果而结束
String flag="黄灯";
switch(flag){
case "红灯":
System.out.println("红灯停");
case "黄灯":
System.out.println("黄灯等一等");
case "绿灯":
System.out.println("绿灯行");
break;
default:
System.out.println("没有这种颜色的灯,沙雕!!!");
}
}
}
扫一扫
188
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
