Java语言基础(3)
1 算术运算符：+，-，*（乘法），/（除法），%（求余数）
1）只有相同类型的数据才可以进行算术运算，经常使用到自动类型转换和强制类型转换，把参与运算的数据转换为同一个类型，然后再进行算术运算。
案例：Demo1
public class Demo1 {
public static void main(String[] args) {
int num1=100,num2=200;
int sum1 = num1+num2;
//num1，num2都是int类型，直接进行加法运算
System.out.println("sum1="+sum1);
int num3=10;
double num4=100.6;
double result = num4-num3;
//分析：首先num4是double，而num3是int，num3进行
//自动类型转换，由当前的int类型自动的转换为double
//类型（10--->10.0），然后执行减法运算，最后把
//运算的结果赋值给result（90.6）
System.out.println("result="+result);
int num5=100;
double num6=1.66;
double result2 = num5*num6;
//num5进行自动类型转换int--》double
// (100-->100.0)
System.out.println("result2="+result2);
int num7=100,num8=10;
int result3 = num7/num8;
System.out.println("result3="+result3);
int num9=10;
float num10=10.99f;
int result4 = num9+(int)num10;
// 10
System.out.println("result4="+result4);
}
}
2）算术运算的结果跟参与运算数据的类型（统一类型）一致
案例：Demo2
public class Demo2 {
public static void main(String[] args){
int num1=10,num2=4;
double result = num1/num2;
//分析：首先num1和num2都是int类型，所以算术运算
//结果也是int类型，结果是2，然后2进行自动类型转换，
//由当前的int类型自动的转换为double类型（2->2.0）
//最后把2.0赋值给result
System.out.println("result="+result);
}
}
3）%：求出余数
被除数 = 商 * 除数 + 余数
余数 = 被除数 - 商 * 除数
eg：
int num1=10,num2=3;
int result1=num1/num2; //3
int result2=num1%num2; //1
案例：Demo3
public class Demo3 {
public static void main(String[] args) {
int num1=10,num2=3;
int result1 = num1/num2;//3
System.out.println("result1="+result1);
int result2 = num1%num2;//1
System.out.println("result2="+result2);
int num3=100,num4=10;
int result3 = num3/num4;//10
System.out.println("result3="+result3);
int result4 = num3%num4;//0
System.out.println("result4="+result4);
}
}
a）整除余数是0
b）负数的余数，依然是负数（整除例外）
案例：Demo4
public class Demo4 {
//负数的余数，依然是负数（整除例外）
public static void main(String[] args) {
int num1=-100,num2=3;
int result1 = num1/num2;//-33
System.out.println("result1="+result1);
int result2 = num1%num2;//-1
System.out.println("result2="+result2);
}
}
eg：
int num1=-10，num2=-3；
int result = num1/num2; //3
int result = num1%num2;
余数 = 被除数 - 商*除数
= -10 - （-3）*3
= -10 - （-9）
= -10 + 9
= -1
c）小数的余数，依然是小数
案例：Demo5
public class Demo5 {
public static void main(String[] args) {
double num1=10.666;
int num2=10;
double result = num1%num2;//0.666
System.out.println("result="+result);
}
}
2 自增运算符：++
1）变量的值和表达式的值
eg：
int a =100；
变量a的值是100
表达式a+1的值是101
2）前置的自增：
++i：首先i先加1（i=i+1），然后把i当前的值作为++i整个表达式的值
eg：
int num=10；
int result = ++num；
分析：首先num=num+1（11），然后把num当前的值作为++num整个表达式的值（11），最后把++num表达式的值（11）赋值给变量result（11）
案例：Demo6
public class Demo6 {
//++i:首先i=i+1，然后把i加完以后的值作为++i整个
//表达式的值。
public static void main(String[] args) {
int num = 100;
int result = ++num;
//分析：首先num=num+1（101），然后把num当前的值
//作为++num整个表达式的值（101），最后把++num
//表达式的值赋值给result（101）
System.out.println("num="+num);
System.out.println("result="+result);
}
}
//Demo7:
//int num = 10;
//int sum = ++num + ++num + ++num;
//sum = ?
public class Demo7 {
public static void main(String[] args) {
int num = 10;
int sum = ++num + ++num + ++num;
// 11 12 13
// 变量 表达式
//第1个表达式：11 11
//第2个表达式：12 12
//第3个表达式：13 13
System.out.println(sum);
}
}
//Demo8
//int num=100;
//int sum = ++num + ++num + ++num + ++num?
//sum = ?
public class Demo8 {
public static void main(String[] args) {
int num=100;
int sum = ++num + ++num + ++num + ++num;
// 101 102 103 104
// 变量 表达式
//第1个表达式： 101 101
//第2个表达式： 102 102
//第3个表达式： 103 103
//第4个表达式： 104 104
System.out.println(sum);
}
}
3）后置的自增：
i++：首先把i当前的值作为i++整个表达式的值，然后i再加1（i=i+1）
eg：
int num=100;
int result = num++;
分析：首先把num当前的值作为num++整个表达式的值（100），然后num=num+1（101），最后把num++表达式的值（100）赋值给result
案例：Demo9
public class Demo9 {
//i++：首先把i当前的值作为i++整个表达式的值，然后
//i=i+1
public static void main(String[] args) {
int num = 1000;
int result = num++;
//分析：首先把num当前的值作为num++整个表达式的值
//（1000），然后num=num+1（1001），最后把num++
//表达式的值赋值给result
System.out.println("num="+num);
System.out.println("result="+result);
}
}
//Demo10
//int num = 100;
//int sum = num++ + num++ + num++;
//sum = ?
public class Demo10 {
public static void main(String[] args) {
int num = 100;
int sum = num++ + num++ + num++;
// 100 101 102
// 变量 表达式
//第1个表达式： 101 100
//第2个表达式： 102 101
//第3个表达式： 103 102
System.out.println(sum);
}
}
//Demo11
//int num=10;
//int sum = ++num + ++num + num++ + num++;
//sum = ?
public class Demo11 {
public static void main(String[] args) {
int num=10;
int sum = ++num + ++num + num++ + num++;
// 11 12 12 13
// 变量 表达式
//第1个表达式： 11 11
//第2个表达式： 12 12
//第3个表达式： 13 12
//第4个表达式： 14 13
System.out.println(sum);
}
}
3 自减运算符：--
1）前置自减：
--i：首先i=i-1，然后把i当前的值作为--i整个表达式的值。
eg：
int num = 10;
int result = --num;
分析：首先num=num-1（9），然后把num当前的值（9）作为--num整个表达式的值（9），最后把--num表达式的值赋值给result（9）
案例：Demo12
public class Demo12 {
//--i：首先i=i-1，然后把i减完以后的值作为--i整个
//表达式的值
public static void main(String[] args) {
int num = 1000;
int result = --num;
//首先num=num-1（999），然后把num当前的值（999）
//作为--num整个表达式的值（999），最后把--num
//表达式的值赋值给result（999）
System.out.println("num="+num);
System.out.println("result="+result);
}
}
//Demo13
//int num = 100;
//int sum = --num + --num + --num;
//sum = ?
public class Demo13 {
public static void main(String[] args) {
int num = 100;
int sum = --num + --num + --num;
// 99 98 97
// 变量 表达式
//第1个表达式： 99 99
//第2个表达式： 98 98
//第3个表达式： 97 97
System.out.println(sum);
}
}
//Demo14
//int num=100
//int sum = num++ + num++ + --num + --num;
//sum = ?
public class Demo14 {
public static void main(String[] args) {
int num = 100;
int sum = num++ + num++ + --num + --num;
// 100 101 101 100
// 变量 表达式
//第1个表达式： 101 100
//第2个表达式： 102 101
//第3个表达式： 101 101
//第4个表达式： 100 100
System.out.println(sum);
}
}
2）后置自减：
i--：首先把i当前的值作为i--整个表达式的值，然后i=i-1
eg：
int num = 100;
int result = num--;
分析：首先把num当前的值作为num--整个表达式的值（100），然后num=num-1（99），最后把num--整个表达式的值赋值给result（100）
案例：Demo15
public class Demo15 {
//i--：首先把i当前的值作为i--整个表达式的值，然后
//i=i-1
public static void main(String[] args) {
int num = 10;
int result = num--;
//分析：首先把num当前的值作为num--整个表达式的值
//(10)，然后num=num-1(9)，最后把num--表达式的值
//赋值给result
System.out.println("num="+num);
System.out.println("result="+result);
}
}
//Demo16:
//int num = 100;
//int sum = --num + --num + num--;
public class Demo16 {
public static void main(String[] args) {
int num = 100;
int sum = --num + --num + num--;
// 99 98 98
// 变量 表达式
//第1个表达式： 99 99
//第2个表达式： 98 98
//第3个表达式： 97 98
System.out.println(sum);
}
}
//Demo17
//int num=100;
//int sum = num++ + num++ + num-- + num--;
//sum = ?
public class Demo17 {
public static void main(String[] args) {
int num = 100;
int sum = num++ + num++ + num-- + num--;
// 100 101 102 101
// 变量 表达式
//第1个表达式： 101 100
//第2个表达式： 102 101
//第3个表达式： 101 102
//第4个表达式： 100 101
System.out.println(sum);
}
}
//Demo18
//int num = 100;
//int sum = ++num + num++ + --num + num--;
//sum = ?
public class Demo18 {
public static void main(String[] args) {
int num = 100;
int sum = ++num + num++ + --num + num--;
// 101 101 101 101
// 变量 表达式
//第1个表达式： 101 101
//第2个表达式： 102 101
//第3个表达式： 101 101
//第4个表达式： 100 101
System.out.println(sum);
}
}
总结：
无论前置自增还是后置自增，变量都会加1，不同仅仅只是表达式的值。
无论前置自减还是后置自减，变量都会减1，不同仅仅只是表达式的值。
4 复合赋值运算符：+=,-=,*=,/=,%=
eg:
int num=100;
num += 10; // num = num+10
num -= 20; // num = num-20
num *= 100; // num = num*100
num /=10; // num = num/10
int num2=200;
num += num2-100; // num = num+(num2-100)
num /= num2+100; // num = num / (num2+100)
num %= num2/100; // num = num % (num2/100)
案例：Demo19
public class Demo19 {
//复合赋值运算符：+=,-=,*=,/=,%=
public static void main(String[] args) {
int num1=100;
// num1 += 200; //num1=num1+200
// System.out.println(num1);
// num1 *= 10; //num1=num1*10
// System.out.println(num1);
int num2=200;
// num1 -= num2/100;
// num1 = num1 - (num2/100)
// System.out.println(num1);
num1 /= num2/100;
// num1 = num1 / (num2/100)
System.out.println(num1);
}
}
5 关系运算符： >,>=(大于或者等于),<,<=(小于或者等于),==(等于)，!=(不等于)
1）关系表达式：使用关系运算符连接的表达式，称为关系表达式，关系表达式最终必须返回一个boolean类型结果，要么true，要么false。
eg：
int num1=100,num2=200;
boolean result1 = num1>num2; //false
案例：Demo20
public class Demo20 {
public static void main(String[] args) {
int num1=100,num2=500;
boolean result1 = num1==num2;
// false
System.out.println("result1="+result1);
boolean result2 = num1!=num2;
// true
System.out.println("result2="+result2);
boolean result3 = num1>num2;
// false
System.out.println("result3="+result3);
boolean result4 = num1<=num2;
// true
System.out.println("result4="+result4);
}
}
2）运算符的优先级：
算术运算符>关系运算符>赋值运算符
eg：
int num1=100,num2=200;
boolean result = (num1-50)*3+100>=num2;
算术 50 *3 +100>=num2
250>=num2
关系 true
赋值 把true赋值给result
案例：Demo21
public class Demo21 {
//运算符优先级：算术运算符>关系运算符>赋值运算符
public static void main(String[] args) {
int num1=100,num2=200,num3=1000;
boolean result =
(num1*4+200)*2-num2 >= num3;
//算术 (400+200)*2-num2 >= num3
// 600*2-num2 >= num3
// 1200-200 >= num3
// 1000 >= num3
//关系 true
//赋值 把true赋值给result
System.out.println("result="+result);
}
}
Java语言基础(3)的更多相关文章
- Java学习总结（二）----Java语言基础
1. Java语言基础 2.1 关键字 定义:被java语言赋予特殊含义的单词 特点:关键字中的字母都为小写 用于定义数据类型的关键字 class,interface,byte,short,i ...
- java语言基础02
一.Java语言基础(常量的概述和使用)(掌握) 1:什么是常量 就是在程序的执行过程中其值不发生改变的量. 2:Java中常量的分类 (1):字面值常量 (2):自定义常量(面向对象部分讲解) 3: ...
- Java之--Java语言基础组成—数组
Java语言基础组成-数组 Java语言由8个模块构成,分别为:关键字.标识符(包名.类名.接口名.常量名.变量名等).注释.常量和变量.运算符.语句.函数.数组. 本片主要介绍Java中的数组,数组 ...
- Java之--Java语言基础组成—函数
Java语言基础组成-函数 Java语言由8个模块构成,分别为:关键字.标识符(包名.类名.接口名.常量名.变量名等).注释.常量和变量.运算符.语句.函数.数组. 本片主要介绍Java中的函数,函数 ...
- Java之--Java语言基础组成（关键字、标识符、注释、常量和变量、运算符）
Java语言基础组成-关键字.标识符.注释.常量和变量.运算符 Java语言由8个模块构成,分别为:1.关键字:2.标识符(包名.类名.接口名.常量名.变量名等):3.注释:4.常量和变量:5.运算符 ...
- Java语言基础（二） Java关键字
Java语言基础(二) Java关键字 Java关键字比较多,我就不列举出来了,只记录一些常用的小知识点: ①Java的关键字只有小写. ②then.sizeof都不是Java的关键字,熟悉C++的程 ...
- Java语言基础(九)
Java语言基础(九) 一.自增运算(++) 自减运算(--) i++ 就是将i+1再赋给 i i-- 是将i-1再赋给 i 对变量i,j来说,i++ 或++i 这里没什么区别,都是将i的值加1后,再 ...
- Java语言基础(八)
Java语言基础(八) 一.数学运算 + - * / % (1)凡是byte short char类型都按int类型的计算 看看上面的代码,为什么出错! 我已经将100转成byte类型,( ...
- Java语言基础（七）
Java语言基础(七) 今天在公司多呆了会,回来晚了 一.自动类型转换 在Java中,数据是可以转换的 例如可以将byte类型的赋给int类型的 这里希望你了解内存的变化,例如 在这里,我想你应该知 ...
- Java语言基础（六）
Java语言基础(六) 前一章提到的, BigDecimal, DecimalFormat等具体用法,这里就不在说了,网上有许多 一.下面让我们看一个例子(自由落体运动位移) 说明: (1).公式是 ...
随机推荐
- redis的坑
1.外网无法连接redis 解决方法: 把redis.conf里的bind 127.0.0.1注释掉,不行的话把127.0.0.1修改成0.0.0.0 2.make的时候显示没有gcc 解决方法: 安 ...
- H5本地存储技术
H5 Web存储技术 前言 web存储技术在初期的时候被定义为HTML5的一部分作为其API.后来被独立出来作为一份独立的标准. web存储标准包含localStorage对象和sessionStor ...
- 微擎-T
微擎菜单栏对应的数据库表 ims_modules_bindings 小程序前端uniacid的配置,微擎后台进入小程序应用时鼠标移动至管理查看链接即可(不点击) ims_account_wxapp微擎 ...
- Java工程师研发面经大合集
百度研发面经整合版 软件研发工程师 基础研发工程师 百度智能云 百度核心搜索部 百度今年的提前批有点奇怪,好像都不走流程,牛客上好几个百度内推的帖子,我投了几个,基本上都是百度智能云的,当然也有其他部 ...
- Java闭包和回调
Java中的闭包与回调可以通过成员内部类来实现. 简单的来说闭包就是返回一个内部类对象,这个内部类对象包含了外部类对象的信息(因为一个内部类对象定依托于一个外部类对象). 回调就是在闭包的基础上实现的 ...
- 用yum安装的方法部署lamp服务
# yum install -y httpd php php-mysql mariadb mariadb-server# vim /etc/httpd/conf/httpd.conf <If ...
- Construct String from Binary Tree
You need to construct a string consists of parenthesis and integers from a binary tree with the preo ...
- PostgreSQL SQL优化之NOT IN问题
在我们平时写SQL时,如果遇到需要排除某些数据时,往往使用id <> xxx and id <> xxx,进而改进为id not in (xxx, xxx); 这样写没有问题, ...
- JavaSE 基础
一.Java 面向对象 1. 面向对象都有哪些特性以及 你对这些特性的理解 1.1. 继承: 继承是从已有类得到继承信息创建新类的过程. 提供继承信息的类被称为父类(超类,基类);得到继承信息的类被称 ...
- vue-router和webpack懒加载，页面性能优化篇
在vue单页应用中,当项目不断完善丰富时,即使使用webpack打包,文件依然是非常大的,影响页面的加载.如果我们能把不同路由对应的组件分割成不同的代码块,当路由被访问时才加载对应的组件(也就是按需加 ...