运算符

package 基础;

public class 运算符 {
    /*
    算数运算符:+  -  *  /  %(取余,也叫模)  ++  --
    赋值运算符:=
    关系运算符:>  <  >=  <=  ==  !=  instanceof
    逻辑运算符:&&  ||  !
    位运算符:&  |  ^  ~  >>  <<  >>>
    条件运算符:?  :
    扩展赋值运算符:+=  -=  *=  /=
     */
    // + - * /
    public static void main(String[] args) {
        int za = 2;
        int zb = 3;

        System.out.println(za+zb);
        System.out.println(za-zb);
        System.out.println(za*zb);
        System.out.println(za/zb);
        System.out.println(za/(double)zb);
        System.out.println(za/(float)zb);
        System.out.println("===============================");

        long zc = 2332332332332332332L;
        int d = 1231231231;
        short e = 10110;
        byte f = 46;
        double g = 155555513531535.46;//输出值很怪，目前可以知道的是如果整数位很高会转化成E形式，且小数位会省去，而且整数位的最后一位输出也不同
        float h = 455132135132.3135f;//似乎同上

        System.out.println(zc+d+e+f);//结果为long
        System.out.println(d+e+f);//结果为int
        System.out.println(e+f);//结果为int
        System.out.println((float) e+f);
        //所以式子中有long时结果也为long，没有时默认结果为int,浮点数形式优先级更高
        System.out.println(g);
        System.out.println(h);
        System.out.println(g+h);//看不出来是哪种形式
        System.out.println(zc+g);//转成了double形式
        System.out.println("=====================================");

        //%(模运算)即求余
        long xc = 123;
        int ac = 12;
        System.out.println(xc%ac);
        System.out.println("=====================================");

        //关系运算符运算的结果为布尔值
        long i = 10;
        long j = 20;
        int k = 10;
        float l = 10.0f;
        System.out.println(i<j);
        System.out.println(i>j);
        System.out.println(i==j);
        System.out.println(i!=j);
        System.out.println(i==k);
        System.out.println(i==l);
        long o = 1;
        long r = 10;
        float m = 1.0000001f;
        float n = 1.00000001f;
        float p = 10.000001f;
        float q = 10.0000001f;
        System.out.println(o==m);
        System.out.println(o==n);
        System.out.println(r==p);
        System.out.println(r==q);
        long wd = 10000001;
        float dd = 10000001.1f;
        float sd = 1000001.1f;
        System.out.println(wd==dd);
        System.out.println(wd==sd);
        System.out.println("============================");
        //float形式9位以后的会被省略，包括小数点,即从第一个数开始数，包括小数点，到第十个数会被省略

        //重点  难点！！！======================================================
        //++  --  自增  自减
        int a = 1;
        System.out.println(a);//1
        int b = a++;//a++  相当于  a=a+1
        //也就是说，相当于在输出前，多了一行隐藏代码，即a=a+1，也就是说，在这里，a=a+1
        System.out.println(a);//2
        System.out.println(b);//1
        //a++总结，就是这里输出a与b时，由于先输出，所以b=1，等b=1以后，再给a+1，即a=2
        int c = ++a;
        //所以++a就是先赋值，后输出，因此在这里a与c都是3
        System.out.println(a);//3
        System.out.println(c);//3
        //以上可见，++相当于其值本身加一，++在后（a++）就是先赋值，后自增   ++在前（++a）就是先自增，后赋值
        System.out.println("========================");
        //===================================================================

        //幂运算  java中^不是用来进行幂运算的，因此需要借助一些工具
        double pow = Math.pow(5,3);//注意此处double pow是一个固定句式，不能修改
        //相当于5^3,即5*5*5
        System.out.println(pow);

        //逻辑运算符
        //&&与  ||或  !非
        boolean T = true;
        boolean F = false;

        System.out.println("yes && no="+(T && F));//两个都为真即为真
        System.out.println("yes || no="+(T || F));//两个都是假即为假=但凡有真就是真
        System.out.println("!(yes && no=)"+!(T && F));//最终结果取反值
        System.out.println("=======================================");//此处运用了字符串连接符+，后面会说
        //短路运算
        //即&&与运算中，由于全真才是真，所以只要在其中运算到一个假，整体便为假，直接输出为假，后面便不会再运算
        //也就是说，System.out.println(F && T);中，运算到F为假后，便不再运算T
        //实验:
        int Y =2;
        boolean N = ((Y>3) && (Y++<1));
        System.out.println(N);
        System.out.println(Y);//2  若上方Y++运算，则应当为Y=Y+1=3，所以可以看出来当运算到Y>3=false时，后面即停止运算
        /*步骤分析
        先自定一个变量并赋值  int Y =2
        然后通过布尔变量并用关系运算令其值为false   boolean N = Y>3
        接着运用自增减运算，使其值更改  Y++<1
        （上边Y++<1中的（<1）应该是没啥实际作用的，因为光一个Y++会报错，而再新建一个变量又要多一行）
        然后让这两个变量进行与运算  (Y>3) && (Y++<1)
        输出值
         */
        System.out.println("====================================");

        //位运算符
        /*  &  相当于二进制版的与？  |或    ^异或（相同为0，不同为1）  ~取反
        A = 0011 1100
        B = 0000 1101

        A&B=0000 1100  各位都是1输出为1
        A|B=0011 1101  各位有1就输出1
        A^B=0011 0001  各位相同为1不同为0
        ~A =1100 0011  各位取反
        就是把二进制的各位分别进行与运算？

        <<  左移  >>  右移
        0000 0000  0
        0000 0001  1
        0000 0010  2
        0000 0011  3
        0000 0100  4
        0000 1000  8
        0001 0000  16
        所以
        <<就是把二进制的八个数字整体左移一位，相当于*2
        >>就是右移一位，相当于/2
        */

        //扩展赋值运算符 +=  -=  *=  /=（偷懒）
        int Q = 5;
        int W = 10;

        Q+=W;//Q=Q+W
        Q-=W;//Q=Q-W
        Q*=W;//Q=Q*W
        Q/=W;//Q=Q/W

        System.out.println(Q);//Q=(Q+W-W)*W/W=5
        System.out.println("=========================================");
        //没啥好说的

        //字符串连接符  +
        System.out.println(Q+W);//15没啥好说的
        System.out.println(""+Q+W);//510
        System.out.println(Q+W+"");//15   上下不同的原因是运算顺序不同
        /*
        在+前面出现string字符串形式(一大特点就是""符号)时
        后面的+就会变成字符串连接符，将其左右的变量转为字符串形式，进行拼接例如Q+W就是5+10=510
         */
        System.out.println(""+Q+W+Q+W);//所以好像是字符串后面所有的+都进行了拼接
        System.out.println(""+(Q+W));//经测试括号可以隔绝这种影响（括号优先级最高的原因？）
        System.out.println("===============================");

        //条件运算符  必须掌握
        //x ? y :z
        //如果x==true，则结果为y，否则为z
        int 发呆 = 100;
        int 发一会儿呆 = 30;
        String FD = 发呆 < 100 ?"发个小呆" :"发个大呆";
        String fd = 发一会儿呆<100 ? "发个小呆":"发个大呆";
        System.out.println(FD);
        System.out.println(fd);
        System.out.println("======================");

        System.out.println("一本正经的推广:https://www.bilibili.com/video/BV12J41137hu?p=30");
    }
}