＜训练营＞初学Java-Java基础知识-运算符day02

1基本数据类型转换

Java 是强类型语言，变量有明确的数据类型，类型不一致时需要进行转换

数据类型的范围关系(图解)：

• 自动类型转换
  • 由小范围到大范围是支持自动类型转换的
• 强制类型转换：
  • 由大范围到小范围进行转换，范围可以转换整个，超过范围会出现溢出
  • 浮点数会出现精度损失
  • 浮点到整数会出现舍弃小数部分

强制类型转换运算符：(数据类型)

public class Deom03 {
    public static void main(String[] args) {
        /**
         * 基本数据类型转换
         */
        int n = 234;
        //自动类型转换，将int类型n自动转换为long类型数据赋值给l
        long l  = n;
        System.out.println(l);//数值不会变化
        byte b = 23;
        int i = b;//自动类型转换
        System.out.println(i);
        /**
         * 强制类型转换
         *  - 大范围类型不能直接赋值给小范围类型，需要强制类型转换
         */
        int k = 45;
        //将int类型数据k的值转换为byte类型数据赋值给b1
        byte b1 = (byte) k;
        System.out.println(b1);
        //超过小类型范围情况下进行数据类型转换会发生溢出
        k = 128;
        b1 = (byte) k;
        System.out.println(b1);
        //强制类型转换引起精度损失
        double dx = Math.sqrt(2);
        System.out.println(dx);
        float f = (float) dx;
        System.out.println(f);
        //强制类型转换浮点数到整数，会舍弃小数部分
        double d = Math.PI;
        long li = (long) d;
        System.out.println(d);
        System.out.println(li);
    }
}

控制台效果展示

2运算符

2.1数字运算

数学运算符：

1. +  加
2. -  减
3. *  乘
4. /  除
5. % 取余数

• 同种类型数据参与运算，得到同种类型的结果
  • 如果数据类型不一致，先进性自动数据类型转换，转换一致以后在进行运算
• 整数除法是整除
• 小于32位整数类型，按照int类型计算
• 计算时候如果超过数据范围会发生溢出

public class Demo04 {
    public static void main(String[] args) {
        /**
         * 数学运算:同种数据类型参与运算得到同种类型的结果
         * 如果类型不一致，先进性自动数据类型转换，让后在计算
         */
        int n = 5;
        long k = 10;
        //     int+long
        //     long+long
        //       long
        int m =(int) (n + k);
        int g =n + (int) k;
        long l = n + k;
        System.out.println(m);
        System.out.println(g);
        System.out.println(l);
        /**
         * 整数出发是整除
         * 浮点数除法得浮点数
         */
        int n1 = 7;
        double d = 7.8;
        int k1 = n / 2;
        double x = d / 2;
        double y = n / 2;
        System.out.println(k1);
        System.out.println(x);
        System.out.println(y);
    }
}

类型溢出现象 

public class Demo07 {
    public static void main(String[] args) {
        /**
         * 运算时超出范围会溢出
         */
        //int类型溢出现象
        int n = Integer.MAX_VALUE;
        int m = n + 1;
        System.out.println(n);
        System.out.println(m);
        //long类型溢出现象
        long l = Long.MAX_VALUE;
        long l2 = l + 1;
        System.out.println(l);
        System.out.println(l2);
        //浮点数
        double d = Double.MAX_VALUE;
        double x = d + 1;
        System.out.println(d);
        System.out.println(x);
        //计算可观察宇宙大小
        double dx = 300000.0 * 60 * 60 * 24 * 365 *92000000000.0;
        System.out.println(dx);
    }
}

 控制台展示效果

 

 2.1.1%取余数

余数：

• 0 / 4 得 0 余 0        0 % 4 = 0
• 1 / 4 得 0 余 1        1 % 4 = 1
• 2 / 4 得 0 余 2        2 % 4 = 2
• 3 / 4 得 0 余 3        3 % 4 = 3
• 4 / 4 得 1 余 0        4 % 4 = 0
• 5 / 4 得 1 余 1        5 % 4 = 1
• 6 / 4 得 1 余 2        6 % 4 = 2
• 7 / 4 得 1 余 3        7 % 4 = 3
• 8 / 4 得 2 余 0        8 % 4 = 0
• 9 / 4 得 2 余 1        9 % 4 = 1
• 10 / 4 得 2 余 2      10 % 4 = 2

public class Demo08 {
    public static void main(String[] args) {
        /**
         *  取余数计算
         */
        System.out.println(0 % 4);
        System.out.println(1 % 4);
        System.out.println(2 % 4);
        System.out.println(3 % 4);
        System.out.println(4 % 4);
        System.out.println(5 % 4);
        System.out.println(6 % 4);
        System.out.println(7 % 4);
        System.out.println(8 % 4);
        System.out.println(9 % 4);
    }
}

控制台展示效果

 

• 余数小于除数
• 余数是周期变化的

2.2自增(自减)运算

将当前变量的值增加或者减少1

运算符++  --

• 单目运算，一个操作数参与计算

列子：

1. int i = 1;
2. i++;
3. System.out.Println(i);//展示的是2

n++和++n的区别

表达式的整体值不同，一个是增加之前的值，一个是增加之后的值

假设n为8

• n++，加号在后，称为后加，先取值，在增加。先去当前的n的值8做为n++表达式整体值，让后将n增加1，为9
• ++n，加号在前，称为先加，先加1，在取值，先将n增加1，n为9，让后取n的值为当前表达式的值9

使用规则：

• 如果单行使用n++ 和 ++n没有区别
• 如果需要n增加1，使用n增加之后的值，则n++
• 如果需要n增加1，使用n增加之前的值，则++n

列子

1. int n = 8;
2. //                               8
3. System.out.println(n++);//8
4. System.out.println(n);//9
5. n = 8;
6. //                               9
7. System.out.println(++n);//n = 9 

public class Demo09 {
    public static void main(String[] args) {
        /**
         * 自增运算
         */
        int n = 8;
        n++;
        System.out.println(n);
        /**
         * 自减运算
         */
        int i = 12;
        i--;
        System.out.println(i);
        //++
        n = 8;
        System.out.println(n++);//8
        System.out.println(n);//9
        n = 8;
        System.out.println(++n);//9
        System.out.println(n);//9
        System.out.println("---------------------");
        //--
        n = 8;
        System.out.println(n--);
        System.out.println(n);
        n = 8;
        System.out.println(--n);
        System.out.println(n);

    }
}

控制台效果展示 

2.3赋值运算

• 赋值是一个运算符
• 运算时候按照先计算右侧，在赋值到右侧
• 赋值运算本身也是表达式，也有一个值，这个值是赋值结果

列子：

public class Demo10 {
    public static void main(String[] args) {
        int n = 9;
        //   9 + 3
        //      12
        // n = 12
        n = n + 3;
        System.out.println(n);//12
        n = 9;
        System.out.println(n = n + 3);//12
        int k = 6;
        n = 9;
        k = k + (n = n + 6);
        System.out.println(n);//15
        System.out.println(k);//21
    }
}

控制台展示效果

2.4复合赋值符

可以看作的一类赋值运算的简写形式。

双目运算，都可以与等号组曾复合赋值运算

+  +=  n+=2  n=n+2
-  -=  n-=2  n=n-2
*  *=  n*=2  n=n*2
/  /=  n/=2  n=n/2
%  %=  n%=2  n=n%2
... ...

列子：

public class Demo11 {
    public static void main(String[] args) {
        int n = 9;
        //n在原有的数据上增加了2
        n += 2;//等于n = n = 2;
        System.out.println(n);//11
    }
}

控制台展示效果 

用途：商品总价打8折

public class Demo11 {
    public static void main(String[] args) {
        /**
         * 商品总价打8折
         */
        double total = 568.8;
        total *= 0.8;//total = total * 0.8;
        System.out.println(total);
    }
}

控制台展示效果 

2.5单目与双目运算

• 只有一个操作参与计算，称为单目运算：++ -- (类型)
• 单目运算优先级是最高的，优先计算
• 两个操作数参与的运算是双目运算： + -  *  /  %  &  |  ...

2.6比较运算符

用于比较两个变量的值，相等，不等，大于小于

比较结果是boolean类型值，成立得到true，不成立得到false

运算符：

1. >  <  >=  <=  ==  !=

public class Demo12 {
    public static void main(String[] args) {
        /**
         * 比较运算
         * 比较一下 分数是否及格了
         * > < >= <= == !=
         */
        int score = 100;
        System.out.println(score >= 60);//true
        System.out.println(score == 100);//false
        System.out.println(score <60);//false
        System.out.println(score != 100);//false

    }
}

控制台效果展示

 

2.7逻辑运算符

用于处理复杂逻辑处理，用于进行 并且 或者 否则等规则

逻辑运算对boolean数据进行运算，得到boolean结果

运算符：

1. &&  并且
2. ||     或者
3. ！   否则

2.7.1并且运算

1. true && true 得 true
2. true && false 得 false
3. false && true 得 false
4. false && false 得 false

列子：女得并且60岁以上可以通过

public class Demo13 {
    public static void main(String[] args) {
        int age = 66;
        char gender = '女';
        //22899女
        //30007男
        //              22899 == 22899 && 66>60
        //                  true       &&  true
        //                          true
        boolean pass = gender == '女' && age >= 60;
        System.out.println(pass);//true
    }
}

控制台展示效果

 2.7.2或者运算

或者：两个条件一个成立则整体成立

运算符：||

1. false || false = false
2. false || true = true
3. true || false = true
4. true || true = true

列子：女的或者60以上老头

public class Demo14 {
    public static void main(String[] args) {
        /**
         * 或者运算符
         * 可以尝试更改值
         */
        int age = 66;
        char gender = '男';//22899
        //              30007==22899 || 66>=60
        //                  false     || true
        //                          true
        boolean pass = gender == '女' || age >=60;
        System.out.println(pass);
    }
}

控制台展示效果

2.7.3非运算

列子：

1. ! true = false；
2. ! false = true;

public class Demo15 {
    public static void main(String[] args) {
        int age = 10;
        boolean isKid = age <= 12;
        boolean isMan = !isKid;
        System.out.println(isKid);
        System.out.println(isMan);
    }
}

控制台展示效果

 3根据年份判断是否为闰年

• 4年一闰，百年不闰
• 400年在闰

public class Demo16 {
    public static void main(String[] args) {
        /**
         * 根据年份判断是否为闰年
         */
        int year = 2000;
        //          2000 % 4 = 0  && ( 2000 %100 != 0 )|| (2000 % 400 == 0)
        //              0 == 0    &&       (0 != 0)    ||     (0 == 0)
        //                  true  &&  (false)          ||       (true)
        //                  true  &&                true
        //                      true
        boolean tyy = (year % 4 == 0)&&(year % 100 != 0)||(year % 400 == 0);
        System.out.println(tyy);
    }
}

控制台展示效果