首页 > > 程序设计 > Java技术 >

java 运算符

2019-08-16 11:45:53来源：博客园阅读 ()

java 运算符

运算符：进行特定操作的符号。例：+

表达式：用运算符连的式子叫做表达式，例：1+2

1.四则运算：

加：+

减：-

乘：*

除：/ 被除数 / 除数 = 商 .... 余数

对于一个整数的表达式来说，除法用的是整除。结果仍为整数。只看商。不看余数

只有对于整数的除法来，取模运算符才有余数的意义

注意事项：

1.一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种

例子：

public class PeratorDemo{

     public static void main(String[] args){

          //两个常量直接可以进行数学运算

          System.out.println(20 + 30);

          //两变量之间也可以进行数学运算

          int a = 20;

          int b = 30;

          System.out.println(a - b);

          //变量和常量之间可以混合使用

          System.out.println(a * 10);

          int x = 10 ;

          int y = 3 ;

          int result1 = x / y;

          System.out.println(result1);//3

          int result2 = x % y ;

          System.out.println(result2);//余数，模，1

          //int + double ---> double + double --->double

          double result3 = x + 2.5;

          System.out.println(result3);//12.5

     }

}

运行结果：

四则运算当中的加号”+“有三种用法：

1.对于数值来，那就是加法。

2.对于字符char类型来，再计算之前会被提升为int，然后再计算。

-char类型字符，和int类型数值，之间的对照关系表：ASCII,Unicode

3.对于字符串String(首字母大写，并不是关键字)来。加号代表字符串连操作。

-任何数据类型和字符串进行连的时候，结果都会变成字符串

例子：

public class PlusDemo{

     public static void main(String[] args){

          //字符串类型的变量基本使用

          //数据类型变量名称 = 数据值

          String str1 = "Hello";

          System.out.println(str1);//Hello

          System.out.println("Hello"+"Hello");//HelloHello

          String str2 = "Java";

          //String + int --->String

          System.out.println(str2 + 20);//Java20

          //优先问题

          //String + int + int

          //String + int

          //String

          System.out.println(str2 + 20 + 30);//Java2030

          System.out.println(str2+(20+30));//Java50

     }

}

运行结果：

2.自增自减运算符

自增运算符：++

自减运算符：--

基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1

使用格式：写在变量名称之前，或者写在一个变量名称之后

-eg:++num , num++

使用方式：

1.单独使用：不和其他任何操作混合，自己单独成为一个步骤

2.混合使用，和其他操作混合，例如与赋值混合，或者和打印操作混合，等

使用区别：

1.在单独使用的时候，前++和后++没有任何区别，也就是：++num;和 num ++;是完全一样的

2.在混合使用的时候，有【重大区别】

A.如果是前++，那么变量立刻+1，然后拿着结果进行使用【先加后用】

B.如果是后++，那么变量先使用，【然后再让变量+1】【先用后加】

注意事项：

1.只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。

例子：

public class PeratorDemo2{

     public static void main(String[] args){

          int num1 = 10;

          System.out.println(num1);

          ++num1;//单独使用,前++

          System.out.println(num1);//11

          num1++;//单独使用,后++

          System.out.println(num1);//12

          System.out.println("================");

          //与打印操作混合的时候

          int num2 = 20;

          //混合使用，先++，变量立马上变成21，然后打印结果21

          System.out.println(++num2);//21

          //混合使用，后++，变量先打印成原来的21 ，然后变量+1变成22

          System.out.println(num2++);//21

          System.out.println(num2);//22

          System.out.println("===========");

          //和赋值操作混合使用

          int num3 = 30 ;

          //混合使用，先---,变量先变成29,然后赋值给result1

          int result1 = -- num3;//result=29

          System.out.println(result1);//29

          System.out.println(num3);//29

          //混合使用，先将num3赋值给result2,再将变量变成28

          int result2 = num3 --;//将29赋值给result2

          System.out.println(result2);//29

          System.out.println(result2);//29

          System.out.println(num3);//28

     }

}

运行结果：

3.赋值运算符

赋值运算符分为：

基本赋值运算符：就是一个等号"=",代表将右侧的数据交给左侧的变量

int a = 30;

复合赋值运算符：

+= a += 1 相当于 a = a + 1

-= a -= 1 相当于 a = a - 1

*= a *= 1 相当于 a = a * 1

/= a /= 1 相当于 a = a / 1

%= a %= 1 相当于 a = a % 1

例子：

public class PeratorDemo3{

     public static void main(String[] args ){

          int a = 10;

          a+=5;//相当于 a= a+5 ---->10+5 = 15

          System.out.println(a);//15

          int x = 10;

          x %= 3;//相当于 x= x%3 ---->10%3 = 1

          System.out.println(x);//1

          byte num = 30;

          //num = num + 5

          //num = byte + int

          //num = int

          //num = (byte)int

          num +=5;

          System.out.println(num);//35

     }

}

运行结果：

4.比较运算符

大于： >

小于： <

大于等于: >=

小于等于： <=

相等： ==

不等于： !=

注意事项：

1.比较运算符的结果一定是一个boolean值，成立就是true,不成立就是false

2.如果进行多次判断，不能连着写

数学当中的写法例如：1<x<3

程序中不允许这样写

例子：

public class PeratorDemo4{

     public static void main(String[] args){

          System.out.println(10 > 5);//true

          int num1 = 10;

          int num2 = 12;

          System.out.println(num1 < num2);//true

          System.out.println(num2 >= 100);//false

          System.out.println(num2 <= 100);//true

          System.out.println(num2 <= 12);//true

          System.out.println("=============");

          System.out.println(10 == 10);//true

          System.out.println(20 != 25);//true

          System.out.println(20 != 20);//false

     }

}

运行结果：

5.逻辑运算符

与（并且） && 全都是true,才是true,否者就是false

或（或者） || 只要至少一个是true,就是true;全都是false,才是false

非（取反） ! 本来是true,变成false,本来是false,变成true

短路：

与“&&”，或“||”，具有短路的效果：如果根据左边已经判断得到最终结果

那么右边的代码将不再执行，从而节省一定的性能

注意事项：

1.逻辑运算符只能用于boolean值

2.与或需要左右各自有一个boolean值，大宋取反只有唯一一个boolean值

3.与、或两运算符，如果有多个条件，可以连续写

两个条件：条件A &&条件B

多个条件：条件A &&条件B &&条件C

例子：

public class LogicDemo{

     public static void main(String[] args){

          System.out.println(true && false);// false

          //true && true ---> true

          System.out.println(3 < 4 && 10 > 5);//true

          System.out.println("===============");

          System.out.println(true || false);//true

          System.out.println(true || true);//true

          System.out.println(false || false);//false

          System.out.println("===============");

          System.out.println(true);//true

          System.out.println(!false);//false

          System.out.println("===============");

          int a = 10;

          //false && ......

          System.out.println(3 > 4&& ++a < 100);//false

          System.out.println(a);//10

          System.out.println("================");

          int b = 10;

          //true || ......

          System.out.println(3 < 4 || ++b <100);//true

          System.out.println(b);//10

     }

}

运行结果：

6.三元运算符

一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反！，自增++

二元运算符：需要两数据才能进行的操作的运算符，例如：加法+，赋值=

三元运算符：需要三个数据才可以进行操作的运算符

格式：

数据类型变量名称 = 条件判断？表达式A ：表达式B;

流程：

首先判断条件是否成立：

如果成立为true,那么将表达式A的值赋值给左侧变量

如果不成立为false,那么将表达式B的值赋值给左侧变量

注意事项：

1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求

2.三元运算的结果必须被使用

例子：

public class PeratorDemo5{

     public static void main(String[] args){

          int a = 10;

          int b = 20;

          //数据类型变量名称 = 条件判断？表达式A ：表达式B

          //判断a>b是否成立，如果成立将a的值赋值给max，如果不成立将b的值赋值给max

          int max = a > b ? a : b;

          System.out.println(max);//20

          //int result = 3 > 4 ? 2.5 : 10;//错误写法

          //a > b ? a : b;//错误写法

     }

}