Java语言基础：运算符

阅读目录：

• 1.算数运算符
• 2.赋值运算符
• 3.比较运算符
• 4.逻辑运算符
• 5.位运算符
• 6.三元运算符

 

1.算数运算符

class Demo01 
{
    public static void main(String[] args) 
    {
        //算术运算符。 +  -  *  /   %(取余，模运算，若是左边小于右边就获得左边的数：2%5=2,3%5=3)
        //  ++ (自增：在原有数据基础上+1，再赋给原有的数据。)  
　　　　　int x = 6370;
        x = x / 1000 * 1000;
        System.out.println(x);
　　　　 System.out.println(3+"2");   //  32    不是32，是3和2连一块儿。
　　　　　　
　　　　 int  a = 4, b=5;
　　　　 System.out.println("a="+a+",b="+b); //a=4.b=5
　　　　  
　　　　　int a = 3;
　　　　  a++;   //a = a+1;
　　　　  System.out.println("a="+a);

　 } }

 

注意：

1.JAVA是的强烈型语言

2.任何数据和字符串相加，得出的结果都是相连。

3.运算中，通常地变量会先参与其余的运算，在运行自身自增的动做。

 内存原理："把右边运算完之后，在赋值给右边"

 分析：  开始a=3，它会先创建一个a=3的空间，它会先参与其它的运算，a++=3+1=4,  自身a=4, 以后再把原来a=3的内容值3赋值给右边b，因此b=3. 

2.赋值运算符

 

class Demo02
{
    public static void main(String[] args)
    {
        //赋值运算符，  =  +=  *=  /=  %=
        //int a,b,c
        // a = b = c =4;

        //int  a = 4;
        //a +=2; //  a = a + 2;

        short s = 3;  // short 自己可存 2个字节，赋值运算，s要进行检查
        // s += 4;    //成功，它是一次运算，+=动做时候它在里面作了强转，即：自动转换。
        //s = (short) (s+4)  这个能够表明： s = s+4  .
        s = s + 4;   //失败  它是两次运算，由于s是不肯定的值，因此检查不出来。失败
        System.out.println("s+="+s)

        //分析：
        //1个编译失败的缘由：由于实现自动类型的提高，因此类型已经不能赋给低空间的类型，会丢失精度
    　　//1个编译成功的缘由：由于它里面作了类型的强转。
        
    }
}

 

3.比较运算符

class Demo03
{
    public static void main(string[] args)
    {
        /*
        比较运算符，运算完的结果必须是true或者false
        */
        System.out.println(3>2); //true   
        System.out.println(3==2); //false
    }
}

 

 

 

4.逻辑运算符

class Demo03
{
    public static void main(string[] args)
    {
        /*
        比较运算符，运算完的结果必须是true或者false
        */
        //System.out.println(3>2); //true   
        //System.out.println(3==2); //false

        //2<x<5  java中这种形式要拆分： x>2  x<5
        /*
        逻辑运算符有什么用？
        答： 用于链接两个布尔型的表达式
        
        & ： 与
        | ： 或
        
        &：符号的运算特色：
            true & true  = true;
            true & false = false;
            false & true = false;
            false & false = false;

        &：运算规律：
            &运算的两边只有一个false，结果确定是false，
            只有两边都为true，结果才是true。

        |：运算特色：
            true | true = true;
            true | false = true;
            false | ture = true;
            false | false = false;

        ||运算规律：
            |运算的两边只要有一个是true，结果确定是true，
            只有两边都为false，结果都是false。

        ^  异或 ： 和 “或” 有点不同，  
            true  | true = false;
            true  | false = true;
            false | ture = true;
            false | false = false;
        
        ^ 异或的运算规律：
        ^ 符号的两边结果若是相同，结果是false
            两边的结果不一样，结果是true。
    
        ！： 非运算，判断事物的另外一面。
            !true = false     非真为假
            !false = true;    非假为真

            !!true = true;     非非真为真
        
        && 双与：
            int x = 6
            x > 2 && x<5  真与与假为假
            x > 2 & x<5   真与假为假

            int x = 1;

            x>2 % x<5   假与真为假
            x>2 && x<5  双与一旦左边为假，右边就不比较了。双与比单与高效。 可作运费运算。

        && 双与的特色：
            和& 运算的结果是同样的，可是有点小区别。
            单& :不管左边的运算结果是什么，右边都参与运算。
            双&&:当左边为false时，右边是不参与运算的。

        ||： 
            和| 运算的结果是同样的，可是有点小区别。
            单| :不管左边的运算结果是什么，右边都参与运算。
            双||:当左边为true时，右边是不参与运算的。

        */
        int x = 6;
        System.out.println(x>2&x<5)  //与：左边为真，右边为假，整体结果就为假
        System.out.println(x>2|x<5)  //或：左边为真，右边为假，整体结果就为真

    }
}

 

5.位运算符

 

 

 移位运算符：

 

 

 

6.三元运算符

格式：
    1.（条件表达式）？ 表达式1：表达式2;
    2.若是条件为true，运算后的结果是表达式1;
    3.若是条件为false，运算后的结果是表达式2;

示例：
    1.获取两个数中较大的数。
    2. int x =3 ,y=4,z;
    3. z = (x>y)?x:y;  // z变量存储的就是两个数中较大的数。

示例：

class Demo
{
    public static void main(String[] args)
    {
        int x = 0;y;
        y = (x>1)?100:200;
        System.out.println("y="+y);　　　　 int a,b;　　　　 int max = a>b?a:b;　　　　 int o,p,q;        int temp = o>p?o:p;　　　　 int max2 = temp>q?temp:q;
    }
}