class VarDemo

{

    public static void main(String[] args)

    {

        byte b = 6;

        short s = 4;

        int i = 7;

        long l = 1234567890l;    //过大的数（范围超过了int型）

        float f = 2.3f;    //如果不加f的话，编译的时候会报错，说损失精度，因为小数默认是double类型的

        double d = 3.4;

        char c = '1';        //char c = 1

        boolean bo = true;  //bo = false

    }

}

//自动类型转换

class VarDemo2

{

    public static void main(String[] args)

    {

        /*

        byte b = 4;

        int x = 3;

        x = x + b;    //b就自动类型提升为和x一样的整形。

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

        */

        byte b = 3;

        b = b + 1；

        /*
　　　　　　【在编译的时候，b=b+1是不会做加法运算的，所以下文中说到的相加是不准确的。】

        这一句在编译的时候会报错，因为在做相加之前

        byte类型的变量b被自动提升为了和1一样的整形类型

        ，所以相加完后的结果为整形，但是要赋给的变量b此时

        是byte类型的，所以可能丢失精度，此时编译器会报错：

        原理如下图（1）

        但是此时又有这样一个疑问：

        在定义byte b = 3;的时候，3也是整形的，

        那为什么整形的3可以赋值给byte类型的变量b呢（这个解释就是上面所说的内容）

        疑问是虽然做完了加法运算后的结果为整数（4），但是整形的4也在byte范围之内啊，

        此时为什么就不能赋给byte类型的变量b了呢？

        原因是：

        因为在做加法之前，byte类型的变量b的值是不确定的，比如如下代码

        byte b = 3;

        b = 127;

        b = b+1;

        这个时候做完加法后的结果是整形的数值128，而此时128已然超出了byte类型的范围，所以如果再

        把128赋给byte类型的变量b，就会发生数据损失。

        而byte b = 3之所以可以完成把整形（int）的数3赋给byte类型的变量b是因为编译器在检查的时候

        判断了这个3是在byte范围之内的，并且这个3是一个常量，值不会改变，（就是数值3）所以可以按照上面的

        方法把这个整形的3赋给byte类型的变量b。

        总结一句话就是：

        若是不变的量（常量）在判断后，符合这个类型的取值范围，则可以成功赋值。

        若是变量，则不能再赋值。比如 上面的b = b + 1;(第二个b是变量，不确定其值，万一b等于127呢？思考...)

        */

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

    }

}

        /*可以通过强制类型转换，实现上述赋值*/

        //byte b = 3;

        //b = (byte)(b+1);

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

　　　　　//但是种转换可能发生数据丢失：如下图：

class OperateDemo

{

    public static void main(String[] args)

    {

        /*【算术运算符】

        + - * / %(取余数)

        */

        int x1 = 3810;

        System.out.println(x/1000);

        System.out.println(2%5);    //结果为2

        System.out.println(-2%5);    //结果为-2

        System.out.println(2%-5);    //结果为2

        System.out.println(-2%-5);    //结果为-2

        //总结：结果为正还是为负，取决于左边的操作数。

        //        若左边操作数为正，则结果一定为正，

        //        若左边的操作数为负，则结果一定为负。

        //应用：

        //        如果想让某一个结果控制在这个数的范围内，

        //        则可以用模运算进行操作。比如想让某一个数

        //        的结果控制在10以内，就模10，则运算后的结果

        //        一定在10以内

        /*

        【++:自增】。对原有的数据进行+1

        int a = 3;

        a++ ++a--->a = a+1;

        //当自增，自减进行独立运算的时候,++a和a++是没有区别的。

          a++;

          System.out.println("a="+a)    //结果是a=4

          ++a;

          System.out.println("a="+a)    //结果是a=4

        */

         //当这个自增运算和其他运算放在一起时，就有区别了：

         int a= 3,b;

         b = ++a;

         System.out.println("a="+a+"b="+b);    //结果是a=4,b=4

        /*

        b = ++a;

        运算过程如下：

        a先执行a = a+1;再把此时a的值赋给b

        */

         b=a++;

         System.out.println("a="+a+"b="+b);    //运算结果是a=4,b=3;

         /*

        b = a++;

        运算过程如下：

        先在内存中开辟一块空间，把a的值3临时存储下来，然后做a= a+1运算，

        此时a的值为4。再把原有的a的值赋给b，则此时b的值为3。

        其运算原理如下：

        temp = a;    //先将a进行临时存储。

        a = a+1;    //自增

        b = temp;    //将临时的值赋给b。

        */

        //字符串的连接符：

        System.out.println(5+5);        //输出结果为整数10

        System.out.println("5"+5);        //输出结果为字符串55

        System.out.println("5+5="+5+5);    //输出结果为5+5=55

        System.out.println("5+5="+(5+5));    //输出结果为5+5=10

        //【赋值运算符】:= , +=, -= , *= , /= , %=

        int x,y,z;

        x=y=z;

        int a = 3;    //把右边赋给左边

        a+=4;        //将左右两边的和赋给左边a = a+4;

        //练习题：下面两个式子有区别吗？

        short s = 4;

        //s = s+5;        //编译不能通过

        //s+=5;            //编译可以通过,因为+=是赋值运算符，会做自动转换。

        //【比较运算符】

            System.out.println(3==4);    //输出结果为：false

            //运算完的结果要么true,要么false

        //【逻辑运算符】用来连接boolean型表达式的。

            /*

            &：与

            |：或

            ^:异或

            !:非

            && ：短路与  || ：短路或

            */

            int x = 7;

            //x>2 & x<5

            //x<2 | x>5

            /*

            &:两边都为true,结果为true.否则为false.

            |:两边都为false，结果为false，否则为true.

            ^:两边相同为false，两边相异为true.

            */

            //&& ：短路与  || ：短路或

            y>3 & y<6

            y>3 && y<6

            /*

            & 和 && 的区别：

            &：无论左边结果是什么，两边都参与运算。

            &&：当左边为false，右边不参与运算。

            | 和 ||的区别：

            |： 两边都参与运算。

            ||：当左边为true时，右边不参与运算。

            */

    }

}