java编程之旅第五章——运算符
来源：互联网 发布：mac webstorm sass 编辑：程序博客网 时间：2024/06/07 19:26
A:前言:
今天这章来讲下运算符，那么什么是运算符呢，运算符的概念就是对常量和变量进行操作的符号成为运算符，另外，运算符有一个优先级，可以百科，这里不再赘述；B分类：算术运算符
赋值运算符比较运算符
逻辑运算符
位运算符（二进制运算，了解就可以，一带而过）
三元运算符
*一:算术运算符+,-,*,/,%,++,--
*A：%（一个数字对另一个数取余数，例如10%2 等于5 余 05%2 等于2 余 1
2%2 等于1 余 0
1%2 等于0 余 1
余数后边的是得出的值，倒着连起来就是10的二进制：1010，进制转换前边省略了，这里说点一下）
* 当左边的绝对值小于右边：结果是左边
* 当左边的绝对值等于右边或者是右边倍数的时候：结果是0
* 当左边的绝对值大于右边：结果是余数,符号取决与左边的的符号
* 取余的正负号取决于左边,右边忽略不记
* 用途：任意正整数%2 结果是要么0，要么1。用于切换条件
* B：++,--
* 递增，递减运算符。就是加1或者减1
* 单独存在，放在操作数的前面或者后面，结果一样
* 参与运算时：
* 放在变量的前面，先自身加或者减1，然后再参与运算
* 放在变量的后面，先参与运算，然后再自身加或者减1
* C：+
* 作为数据的符号(正号)
* 做加法运算
* 字符串连接符"5 + 5 =" + (5 + 5);
例子一；class OperatorDemo {
public static void main(String[] args) {
int a = 3 ;
int b = 4 ;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/b);//0
//整数相除得到结果是整数
//如果想得到小数就将参与运算的数据转换成double类型
System.out.println(a*1.0/b);
System.out.println(a%b);//3
System.out.println("--------------------");
System.out.println(3%4);//3
System.out.println(-3%4);//-3
System.out.println(-3%-4);//-3
System.out.println(3%-4);//3
}
}
例子二；
/*
++,--
++ 功能 数据做了自加1,也就是本身的基础上+1;
-- 功能 数据做了自减1,也就是本身的基础上-1
单独使用:
放在数据前面,放在数据后面效果一样.都对数据做了自加1(自减1)(开发中常用)
参与运算:
++放在操作数后面,相当于先参与运算,然后在做自增.
++放在操作数前面,相当于先做自增,然后再参与运算.
--放在操作数后面,相当于先参与运算,然后再做自减
--放在操作数前面,相当于先做自减,然后再参与运算
*/
class OperatorDemo2 {
public static void main(String[] args) {
/*单独使用
int x = 3;
//x++;
++x;
System.out.println(x);//4
int y = 4;
//y--;
System.out.println(y);//
*/
int x = 3;
//int m = x++;
//++放在操作数的后面相当于 先把值赋给了m,然后在做自加
int m = ++x;
//++放在操作数的前面相当于 先做了自加,然后赋值给m
System.out.println("x:"+x);//4 ,4
System.out.println("m:"+m);//3 ,4
}
}
例子三；
/*
A:案例演示
请分别计算出a,b,c的值?
int a = 10;
int b = 10;
int c = 10;
a = b++;
c = --a;
b = ++a;
a = c--;
B:案例演示
请分别计算出x,y的值?
int x = 4;
int y = (x++)+(++x)+(x*10);
*/
class OperatorTest{
public static void main(String[] args) {
int a = 10;
int b = 10;
int c = 10;
a = b++;//a:10,b:11,c:10
c = --a;//a:9,b:11,c:9
b = ++a;//a:10,b:10,c:9
a = c--;//a:9,b:10,c:8
System.out.println("a:"+a);
System.out.println("b:"+b);
System.out.println("c:"+c);
int x = 4;
int y = (x++)+(++x)+(x*10);
//x:4,5,6
//y=4+6+60 = 70
System.out.println("x:"+x);
System.out.println("y:"+y);
}
}
二；赋值运算符=,+=,*=
* 赋值运算符* A：=：赋值运算符 把右边的值赋给左边
#
举例：int x = 3; 把3赋给int类型变量x
int a,b,c;
a = b = c = 5;
* B：+=：加赋值运算符 把左边和右边的和赋给左边
* 举例：int x = 3; x+=2;等同于 x = x + 2;
* 面试题
*
byte b = 5;
b = b + 2;
b += 2; b = (byte)(b + 2);
System.out.println(b);会不会报错?
+=运算符在给b赋值时，自动完成了强转操作。
三；比较运算符==,!=,>,<,>=,<=
* 比较运算符的结果都是boolean型，也就是要么是true，要么是false。/*
==:判断两边数据是否相等,相等为真(true),不等为假(false)
!=:判断两边数据是否不相等,不相等为真(true),相等为假(false)
< :判断左边数据是否小于右边数据,如果小于为真(true),如果不小于为假(false)
> :判断左边数据是否大于右边数据,如果大于为真(true),如果不大于为假(false)
<=:判断左边数据是否小于或等于右边数据,如果小于或等于为真(true),如果大于为假(false)
>=:判断左边数据是否大于或等于右边数据,如果大于或等于为真(true),如果小于为假(false)
无论左右两边数据是复杂还是简单,比较后的结果肯定是boolean类型.
"=="不能写成"="。
"==" 是判断是否相等的
"=" 是赋值运算符,做赋值用的
例子4；
*/
class OperatorDemo {
public static void main(String[] args) {
System.out.println(3==4);//false
System.out.println(3!=4);
System.out.println(3<4);//输出结果true
System.out.println(3>4);//false
System.out.println(3<=4);输出结果true
System.out.println(3>=4);//false
}
}
四:逻辑运算符
* 逻辑与运算符 &第一个条件 第二个条件 结果
true true true
false true false
true false false
false false false
简单记：左右两边同时为true，结果为true。
* 逻辑或运算符 |(或)
第一个条件 第二个条件 结果
true true true
false true true
true false true
false false false
简单记：左右两边只要有一个结果是true，结果为true。
* 逻辑异或运算符 ^（异或）
第一个条件 第二个条件 结果
true true false
false true true
true false true
false false false
简单记：左右两边相同，结果为false。
* 逻辑非运算符 !（非）
!true false
!false true
!!true true
* 短路与：&&
&:左边无论什么结果，右边都执行。
&&:左边为false，右边不执行，结果为false。
int x = 10;
x > 11 && x < 15
* 短路或：||
|:左边无论什么结果，右边都执行。
||:左边为true，右边不执行，结果为true。
例子五；
/*
逻辑运算符:
基本的:&,|,!,^
扩展:&&,||
得到的结果是boolean类型
注意:
逻辑运算符一般连接boolean类型的表达式或值.
表达式:就是用运算符将常量和变量连接起来的符合java语法规范的式子.
a==b; a+b;a=10;
!一个特点:
非偶数个还是其本身.
*/
class OperatorDemo {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5 ;
//逻辑& 特点:有false则false 有假结果就是假
System.out.println((a>b)&(a>c));//false & false =false
System.out.println((a>b)&(a<c));//false & true =false
System.out.println((a<b)&(a>c));//true & false =false
System.out.println((a<b)&(a<c));//true & true =true
System.out.println("---------------------------------------------");
//逻辑| 特点:有true则true 有真结果就是真
System.out.println((a>b)|(a>c));//false | false =false
System.out.println((a>b)|(a<c));//false | true =true
System.out.println((a<b)|(a>c));//true | false =true
System.out.println((a<b)|(a<c));//true | true =true
System.out.println("---------------------------------------------");
//逻辑^ 特点:相同为假,不同为真 相同为false,不同为true
//磁铁:同性相斥,异性相吸.
System.out.println((a>b)^(a>c));//false ^ false =false
System.out.println((a>b)^(a<c));//false ^ true =true
System.out.println((a<b)^(a>c));//true ^ false =true
System.out.println((a<b)^(a<c));//true ^ true =false
System.out.println("---------------------------------------------");
//逻辑! 特点:非true则false 非false则true 非真则假,非假则真
//System.out.println(!(a>b));//!false = true
//System.out.println(!(a<b));//!true = false
System.out.println(!!false);//!!false = !true = false
System.out.println(!!!false);
}
}
例子六；
/*
&&和&的区别?
(1):结果是一样的.
(2):因为与的特点是有false则false,双与就有个功能:左边是false那结果肯定是false,
所以右边就不执行了(相当于短路效果)
||和|:
(1):结果是一样的
(2):根据或的特点有true则true,所以双或就有个功能,左边是true,右边就不执行了
开发中常用
&&,||,!
*/
class OperatorDemo2 {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;
//逻辑& 特点:有false则false 有假结果就是假
//逻辑&& 特点: & &&
System.out.println((a>b)&&(a>c));//false & false =false false
System.out.println((a>b)&&(a<c));//false & true =false false
System.out.println((a<b)&&(a>c));//true & false =false false
System.out.println((a<b)&&(a<c));//true & true =true true
System.out.println("----------------------");
int x = 3;
int y = 4;
//boolean flag = ((x++)==3)&((y--)==4); //4,3,true
//boolean flag = ((x++)==3)&&((y--)==4);//4,3,true
//boolean flag = ((++x)==3)&((y--)==4);//4,3,false
boolean flag = ((++x)==3)&&((y--)==4);//4,4,false
System.out.println("x:"+x);
System.out.println("y:"+y);
System.out.println(flag);
}
}
例子七；
/*
面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
short s=1;
s = s+1; 有,损失精度 问题
short s=1;s+=1;
s+=1我只是说貌似是s=s+1;
实际是隐含了一个强制转换
s=(short)(s+1);
*/
class OperatorTest {
public static void main(String[] args) {
short s=1;
s+=1;//貌似是 s = s +1;实际是s=(short)(s+1);
System.out.println(s);
}
}
五:位运算符
* 位运算符2<<3 2 * 8 == 2 * 2^3* <<一个整数向左移动几位就乘以2的几次幂
* >>一个整数向右移动几位就除以2的几次幂,高位是0就补0,高位是1就补1
* >>>无符号右移无论最高位的符号位是0还是1,用无符号右移后高位符号位都是补0
例子八；
/* 位运算符;
结论:
&(与)，
有0则0
|(或)，
有1则1
^(异或) ,
相同为0,不同为1
~(按位取反) ,
就是1变0,0变1
*/
class OperatorDemo {
public static void main(String[] args) {
int a = 3;
int b = 4;
System.out.println(a&b);
System.out.println(a|b);
System.out.println(a^b);
System.out.println(~a);
}
}
/*
位运算是做的二进制运算,用到的就是数据的补码
int a 3 4个字节
原码:00000000 00000000 00000000 00000011
补码:00000000 00000000 00000000 00000011
int b 4 4个字节
原码:00000000 00000000 00000000 00000100
补码:00000000 00000000 00000000 00000100
位与&运算:有0则0
00000000 00000000 00000000 00000011
& 00000000 00000000 00000000 00000100
-------------------------------------------------
00000000 00000000 00000000 00000000
结果是:0
位或|运算:特点:有1则1
00000000 00000000 00000000 00000011
| 00000000 00000000 00000000 00000100
-------------------------------------------------
00000000 00000000 00000000 00000111
结果是:7
位异或^运算:特点:相同为0,不同为1
00000000 00000000 00000000 00000011
^ 00000000 00000000 00000000 00000100
-------------------------------------------------
00000000 00000000 00000000 00000111
结果是:7
按位取反~ :特点就是0变1,1变0
~ 00000000 00000000 00000000 00000011
----------------------------------------------
11111111 11111111 11111111 11111100 补码
11111111 11111111 11111111 11111011 反码
10000000 00000000 00000000 00000100 原码
结果-4
*/
例子九；
/*位异或的一个特点:
某一个数对另一个数异或两次得到结果是其本身.*/
class OperatorDemo2 {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a^b^a);//20
System.out.println(a^b^b);//10
}
}
例子十；/*
请自己实现两个整数变量的交换
分析:
定义两个整数变量
使用第三方变量(开发中用的,必须掌握的)
用了异或
异或有个特点:某个数对另一个数异或两次得到的是它本身
加法和减法来做.
注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
*/
class OperatorTest {
public static void main(String[] args) {
int a = 10;
int b = 20;
/*
//使用第三方变量(开发中就这么用)
int c = a;
a=b;
b=c;
//用异或
//左边a,b,a 右边a^b
a=a^b;//a=10^20
b=a^b;//b=10^20^20=10
a=a^b;//a=10^20^10=20
//用加减法
a = a+b;//a=10+20
b = a-b;//b=30-20=10
a = a-b;//a=30-10=20
//一句话搞定
b=a+b-(a=b);
//10+20-20=10
*/
System.out.println("a:"+a+",b"+b);
}
}
六:三元运算符
* 格式 ：(条件表达式)?表达式1：表达式2；* 如果条件为true，运算后的结果是表达式1；
* 如果条件为false，运算后的结果是表达式2；
* 条件运算符运算完之后一定有一个结果
int x,y,z;
x = 5;
y = 10;
z = x > y ? x : y;
例子十一；
/*
三目(元)运算符:
(布尔类型表达式) ? 表达式1 : 表达式2;
两个数谁大!
*/
class OperatorDemo {
public static void main(String[] args) {
int a = 11;
int b = 21;
int c = a>b ? a : b ;
System.out.println(c);
}
}
例子十二；
/*
A:案例演示
比较两个整数是否相同
B:案例演示
获取三个整数中的最大值
分析:
首先有三个整数:
其次可以先比较两个,拿到两者之中的最大值
最后拿到的较大值在与最后一个比较,得到的结果就是所要的最大值
*/
class OperatorDemo2 {
public static void main(String[] args) {
int a = 100;
int b = 101;
boolean flag = (a==b?true:false);
System.out.println(flag);
int x = 100;
int y = 400;
int z = 300;
int max1 = x>y ? x : y ;
int max2 = max1>z ? max1:z;
System.out.println("x,y,z最大值是:"+max2);
//想一想有更好的方法去做吗?(先了解一下)
int max = x > y ? (x>z ? x : z) : (y>z ? y : z) ;
System.out.println("x,y,z最大值是:"+max);
}
}
0 0
- java编程之旅第五章——运算符
- 跟着二厶学编程---ＪＡＶＡ第五章---【运算符】
- Java编程思想——第五章
- 第五章：运算符
- Java编程之条件运算符
- Java编程思想笔记——第五章
- Java编程思想 ——第五章 初始化与清理
- Java——第五章（面向对象编程）
- Java编程思想——第五章 清理与初始化
- java 第五讲 运算符续
- java 多线程编程 第五章
- java复习之——运算符
- Linux学习——shell编程之运算符
- 六：Java语言基础组成——运算符之赋值运算符、比较运算符
- Java编程那些事儿21——算术运算符
- Java编程那些事儿21——算术运算符
- Java编程那些事儿22—比较运算符
- Java编程那些事儿24—赋值运算符
- DES MEI号码加密
- C 语言易忘点笔记（一）
- Command设计模式-HeadFirst学习
- set如何确保高效保证值唯一性
- JSP 自定义标签 (custom tags) 入门介绍
- java编程之旅第五章——运算符
- Android轻量型数据库SQLite详解
- SpringMVC+Spring+Mybatis快速入门（一）配置详解
- java一些基础
- Linux 下的Nginx的下载与安装
- IOS UITableView
- SpringMVC由于级联导致查询结果重复
- Git push的使用
- Android-Property Animation(属性动画)
