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)的更多相关文章

  1. Java学习总结(二)----Java语言基础

    1.     Java语言基础 2.1 关键字 定义:被java语言赋予特殊含义的单词 特点:关键字中的字母都为小写 用于定义数据类型的关键字 class,interface,byte,short,i ...

  2. java语言基础02

    一.Java语言基础(常量的概述和使用)(掌握) 1:什么是常量 就是在程序的执行过程中其值不发生改变的量. 2:Java中常量的分类 (1):字面值常量 (2):自定义常量(面向对象部分讲解) 3: ...

  3. Java之--Java语言基础组成—数组

    Java语言基础组成-数组 Java语言由8个模块构成,分别为:关键字.标识符(包名.类名.接口名.常量名.变量名等).注释.常量和变量.运算符.语句.函数.数组. 本片主要介绍Java中的数组,数组 ...

  4. Java之--Java语言基础组成—函数

    Java语言基础组成-函数 Java语言由8个模块构成,分别为:关键字.标识符(包名.类名.接口名.常量名.变量名等).注释.常量和变量.运算符.语句.函数.数组. 本片主要介绍Java中的函数,函数 ...

  5. Java之--Java语言基础组成(关键字、标识符、注释、常量和变量、运算符)

    Java语言基础组成-关键字.标识符.注释.常量和变量.运算符 Java语言由8个模块构成,分别为:1.关键字:2.标识符(包名.类名.接口名.常量名.变量名等):3.注释:4.常量和变量:5.运算符 ...

  6. Java语言基础(二) Java关键字

    Java语言基础(二) Java关键字 Java关键字比较多,我就不列举出来了,只记录一些常用的小知识点: ①Java的关键字只有小写. ②then.sizeof都不是Java的关键字,熟悉C++的程 ...

  7. Java语言基础(九)

    Java语言基础(九) 一.自增运算(++) 自减运算(--) i++ 就是将i+1再赋给 i i-- 是将i-1再赋给 i 对变量i,j来说,i++ 或++i 这里没什么区别,都是将i的值加1后,再 ...

  8. Java语言基础(八)

    Java语言基础(八) 一.数学运算  + - * /  % (1)凡是byte  short  char类型都按int类型的计算   看看上面的代码,为什么出错! 我已经将100转成byte类型,( ...

  9. Java语言基础(七)

    Java语言基础(七) 今天在公司多呆了会,回来晚了 一.自动类型转换 在Java中,数据是可以转换的  例如可以将byte类型的赋给int类型的 这里希望你了解内存的变化,例如 在这里,我想你应该知 ...

  10. Java语言基础(六)

    Java语言基础(六) 前一章提到的, BigDecimal, DecimalFormat等具体用法,这里就不在说了,网上有许多 一.下面让我们看一个例子(自由落体运动位移) 说明: (1).公式是 ...

随机推荐

  1. delete file SVN commit error has no URL

    在提交SVN的时候遇到这个提交失败的提示: delete file SVN commit error has no URL 我的提交顺序是: 先在自己工程的文件夹删除 ->工程中删除 -> ...

  2. oslo_db.sqlalchemy.engines连库

    _ mysql -uroot -pc1234 oslo_db.sqlalchemy.engines root@devstack2019:/etc/keystone# more keystone.con ...

  3. C# 跨线程更新 UI

    Winforms 跨线程更新 UI 在 Winforms 中, 所有的控件都包含 InvokeRequired 属性, 如果我们要更新UI,通过它我们可以判断是否需要调用 [Begin]Invoke. ...

  4. Golang 单例模式 singleton pattern

    在Java中,单例模式的实现主要依靠类中的静态字段.在Go语言中,没有静态类成员,所以我们使用的包访问机制和函数来提供类似的功能.来看下下面的例子: package singleton         ...

  5. 微信小程序省市区联动,自定义地区字典

    最近在做一个项目的时候遇到了这么一个问题,就是省市区的联动呢,我们需要自定义字典来设置,那么微信小程序自带的省市区选择就不能用了,经过三根烟的催化,终于写出来了.下面献上代码示例. 首先是在utils ...

  6. Docker管理面板-URLOS(易用、高效、强大)

    一.介绍 URLOS是一个Docker管理面板,它把服务器端软件应用的安装行为简化到极致,堪称服务器端的应用宝,具有集群管理.自动故障转移.自动负载均衡等高级功能,可轻易搭建7*24小时在线的网站运行 ...

  7. 二 MyBatis 从入门到进阶 2 Maven 入门

    1 Maven 的使用 1.1 本地仓库与中央仓库 本地仓库:Window \ Preferences \ Maven \ User Settings \ Local Repository 中央仓库: ...

  8. 【并行计算-CUDA开发】Windows下opencl环境配置

    首先声明我这篇主要是根据下面网站的介绍, 加以修改和详细描述,一步一步在我自己的电脑上实现的, http://www.cmnsoft.com/wordpress/?tag=opencl&pag ...

  9. 【VS开发】【DSP开发】浅谈Linux PCI设备驱动(二)

    我们在 浅谈Linux PCI设备驱动(一)中(以下简称 浅谈(一) )介绍了PCI的配置寄存器组,而Linux PCI初始化就是使用了这些寄存器来进行的.后面我们会举个例子来说明Linux PCI设 ...

  10. shell作业01

    1.判断/etc/inittab文件是否大于100行,如果大于,则显示”/etc/inittab is a big file.”否者显示”/etc/inittab is a small file.” ...