Java中的运算符

运算符

*算数运算符

*关系运算符

*逻辑运算符

*赋值类运算符

*字符串连接运算符

*三元运算符 

关于java编程中运算符之:算术运算符
   +     求和
   -     相减
   *     乘积
   /     商
   %     求余数【取模】
   ++    自加1
   --    自减1
   注意：一个表达式当中有多个运算符，运算符有优先级，不确定加小括号，优先级得到提升。
        没有必要去专门记忆运算符的优先级

public class day14 {
    public static void main(String[]args){
        int i=10;
        int j=3;
        System.out.println(i+j);//13
        System.out.println(i-j);//7
        System.out.println(i*j);//30
        System.out.println(i/j);//3
        System.out.println(i%j);//1
        //以下以++为例，--运算符自学
        //关于++运算符【自加1】
        int k=10;
        //++运算符可以出现在变量后面【单目运算符】
        k++;
        System.out.println(k);//11
        int y=10;
        //++运算符可以出现在变量前面【单目运算符】
        ++y;
        System.out.println(y);//11
        //小结：
        //++运算符可以出现在变量前，也可以出现在变量后，无论在变量前还是后
        //只要++运算结束，该变量中的值一定会自加1
        //++出现在变量后
        //规则：先做赋值运算，在对变量中保存的值进行自加1。
        int a=100;
        int b=a++;
        System.out.println(a);
        System.out.println(b);
        //++出现在变量前
        //规则：先进性自加1运算，然后在进行赋值操作。
        int m=20;
        int n=++m;
        System.out.println(m);
        System.out.println(n);
        int xx=500;
        System.out.println(xx);//500
        int e=100;
        System.out.println(e++);//100
        System.out.println(e);//101
        int s=100;
        System.out.println(++s);//101
        System.out.println(s);//101

        System.out.println("-------------------------------------");
        System.out.println(--s);//100
        System.out.println(s++);//100
        System.out.println(s--);//101
        System.out.println(s--);//100
        System.out.println(s--);//99
        System.out.println(s);//98
    }
}
/*
class A
{
    public void m(int x){
    }
    main{
        int i=10;
        m(i);
    }
}
 */

关系运算符：
    >   大于
    >=  大于等于
    <   小于
    <=  小于等于
    ==  等于
    !=  不等于
    =是赋值运算符
    ==关系运算符
  关系运算符的运算结果一定是布尔型：true/false

  关系运算符运算原理：
      int a=10;
      int b=10;
      a>b比较的时候，表较的是a中保存的10这个值和h中保存的10这个值之间大小比较。
      a==b也是如此。

public class day15 {
    public static void main(String[]args){
        int a=10;
        int b=10;
        System.out.println(a>b);//false
        System.out.println(a>=b);//true
        System.out.println(a<b);//false
        System.out.println(a<=b);//true
        System.out.println(a==b);//true
        System.out.println(a!=b);//false
    }
}

逻辑运算符：
   &    逻辑与【并且】     （两边的算子都是true,结果才是true）
   |    逻辑或【或者】     （两边的算子只有一个是true,结果就是）
   !    逻辑非     （取反，！false就是true,!true就是false，这是一个单目运算符）
   ^    逻辑异或   （两边的算子只要不一样，结果就是true）
   &&   短路与     （）
   ||   短路或     （）
   1、逻辑运算符要求两边的算子都是布尔型，并且逻辑运算最终运算结果也是一个布尔类型。
   2、短路与和逻辑与最终的运算结果是相同的， 只不过短路与存在短路现象。
   3、短路或和逻辑或最终的运算结果是相同的， 只不过短路或存在短路现象。
   4、什么时候发生短路现象呢？
   5、什么时候使用逻辑与运算符？什么时候使用短路与运算符？

public class day16 {
    public static void main(String[]args){
        //运算优先级不确定，加小括号。
        System.out.println(5>3&5>2);//true
        System.out.println(5>3&5>6);//false
        System.out.println(5>3|5>6);//true
        System.out.println(true&true);//true
        System.out.println(true&false);//false
        System.out.println(false&true);//false
        System.out.println(false&false);//false
        System.out.println("------------------------------");
        System.out.println(true|false);//true
        System.out.println(false|false);//false
        System.out.println("-------------------------------");
        System.out.println(!false);//true
        System.out.println(!true);//false
        System.out.println("-------------------------------");
        System.out.println(true^false);//true
        System.out.println(false^false);//false
        System.out.println(true^true);//false
        /*
        //逻辑与和短路与
        int x=10;
        int y=8;
        System.out.println(x<y&++x<y);
        System.out.println(x);//11
         */

        //逻辑与和短路与
        int x=10;
        int y=8;
        //短路与
        //x<y结果是false,整个表达式已经确定是false
        //所以后面的表达式没有执行，这种现象被称为短路现象
        //短路与才会出现短路现象，逻辑与不会存在短路现象的。
        System.out.println(x<y&&++x<y);
        System.out.println(x);//10
        /*
        从某个角度来看，短路与更智能，由于后面的表达式可能不执行，
        所以执行效率较高。这种方式在实际的开发使用较多。短路与比
        逻辑与使用的多。短路与更常用。

        但是，在某些特殊的业务逻辑当中，要求运算符两边的算子必须全部
        执行，此时必须使用逻辑与，不能使用短路与，使用短路与可能导致
        右边的表达式不执行。
         */
        /*
        什么情况下发生短路或？
          *第一个表达式执行结果是true，会发生短路或。
        什么情况下发生短路与？
          *第一个表达式执行结果是false，会发生短路与。
         */
    }
}

运算符【声息的运算符】、
   *赋值运算符
   *字符串链接运算符
   *三目运算符/三元运算符/条件运算符

关于Java中赋值运算符：
赋值类运算符包括两种：
   *基本的赋值运算符：
    =
   *扩展的赋值运算：
   +=
   -=
   *=
   /=
   %=
1、赋值类运算符优先级：先执行等号右边的表达式，将结果赋值给左边的变量。
2、注意以下代码：
    byte i=10;
    i+=5;等同于：i=(byte)(i+5);

    int k=10;
    k+=5;等同于：k=(int)(k+5);

    long x=10l;
    int y=20;
    y+=x;y=(int)(y+x);

    3、重要结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是
    byte类型，无论怎么进行追加或者追减，最终该变量的数据类型还是byte类型。
 

public class day17 {
    public static void main(String[]args){
        //基本的赋值运算符
        int a=10;
        System.out.println(a);//10
        a=a+5;
        System.out.println(a);//15
        //扩展的赋值运算符【+=运算符可以翻译为"追加/累加"】
        a+=5;
        System.out.println(a);//20
        a-=5;//等同于：a=a-5
        System.out.println(a);//15
        a*=2;//等同于：a=a*2
        System.out.println(a);//30
        a/=4;//等同于：a=a/4
        System.out.println(a);//7
        a%=2;//等同于：a=a%2
        System.out.println(a);//1
        //------------------------
        //10没有超出byte取值范围，可以直接赋值
        byte b=10;
        //b=15;//可以，编译通过，15没有超出byte取值范围
        //编译错误，为什么？
        //编译只检查语法，不运行程序，编译器发现b+5的类型是int类型   ，b变量数据类型是byte
        //大容量向小容量转换需要加强制类型转换符，所以以下程序编译报错。
        //b=b+5;

        //纠正错误
        b=(byte) (b+5);
        System.out.println(b);//15

        byte x=10;
        x+=5;//等同于：x=(byte)(x+5);其实并不等同于：x=x+5;
        System.out.println(x);
        byte z=0;
        z+=128;//等同于：z=(byte)(z+128);
        System.out.println(z);//-128
        z+=10000;//等同于：z=(byte)(z+10000);
        System.out.println(z);//-112
    }
}

关于java中的“+”运算符：
   1、+运算符在java语言当中有两个作用：
       *加法运算，求和
       *字符串的链接运算
   2、当"+"运算符两边的数据都是数字的话，一定是进行加法运算。
   3、当“+”运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算。
   并且，连接运算之后的结果还是一个字符串类型。
       数字+数字-->数字【求和】
       数字+"字符串"-->"字符串"【字符串连接】
   4、在一个表达式当中可以出现多个"+"，在没有添加小括号的前提之下，遵循自左向右的顺序依次运算。

public class day18 {
    public static void main(String[]args){
        System.out.println(10+20);//30这里的加号是求和
        System.out.println(10+20+30);//60这里的加号也是求和
        System.out.println(10+20+"30");//"3030"自左向右的顺序依次运算，第一个加号是求和，第二个加号是字符串连接
        System.out.println(10+(20+"30"));//"102030"
        int a=10;
        int b=20;
        //要求控制台上输出 "10+20=30"、
        System.out.println("10+20=30");
        //注意：要求以动态的方式输出
        System.out.println("10+20="+a+b);//"10+20=1020"
        System.out.println("10+20="+(a+b));
        System.out.println("a+20="+(a+b));
        System.out.println(a+"+20="+(a+b));
        System.out.println(a+"+b="+(a+b));
        System.out.println(a+"+"+b+"="+(a+b));
        a=100;
        b=200;
        System.out.println(a+"+"+b+"="+(a+b));
        //引用类型string
        //String是SUN在JavaSE当中提供的字符串类型
        //String.class字节码文件
        //int是基本数据类型，i是变量名，10是int类型字面值
        //int i=10;
        //String是引用数据类型，s是变量名，"abc"是String类型的字面值
        //String s="abc"
        //编译错误，类型不兼容
        //String ss=10;
        //定义一个String类型变量，起名username,赋值"zhangsan"
        String username="zhangsan";
        System.out.println("登录成功，欢迎username回来");
        System.out.println("登录成功，欢迎"+username+"回来");
        username ="jack";
        System.out.println("登录成功，欢迎"+username+"回来");
    }
}

三元运算符/三目运算符/条件运算符
   1、语法规则：
      布尔表达式？表达式1：表达式2
   2、三元运算符的执行原理？
      当布尔表达式的结果为true的时候，选择表达式1作为整个表达式的执行结果
      当布尔表达式的结果为false的时候，选择表达式2作为整个表达式的执行结果

public class day19 {
    public static void main(String[]args){
        //编译错误：不是一个完整的java语句
        //10;
        //编译错误：不是一个完整的java语句
        //'男'
        //布尔类型的变量
        boolean sex=false;
        //分析一下程序是否可以编译通过
        //编译报错，因为它不是一个完整的java语句
        char c=sex?'男':'女';
        System.out.println(c);
        sex=true;
        c=(sex?'男':'女');
        System.out.println(c);
        //语法错误，编译报错，结果可能是String,也可能是char，但是前边不能用char来接收数据。
        //语法不兼容
        //char c1=sex?"男":'女';
        //编译错误，类型不兼容
        /*
        sex=false;
        char c1=sex?"男":'女';
         */
        System.out.println(10);
        System.out.println("10");
        System.out.println('1');
        //可以
        System.out.println(sex?'男':"女");
        String s=sex?"男的":"女的";
        System.out.println(s);
    }
}