Day05 P25 Java基础 ， P26变量、常量、作用域，P27基本运算符，P29逻辑运算符、位运算符_java p26

Day05

P25 Java基础05：类型转换

小数的优先级大于整数

public class Demo5 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;
        /*此处为 强制转换 把高容量类型（四个字节的int）赋值给为低容量类型
         (1个字节的byte）时要强制转换  格式为： （类型）变量名
         此处 内存溢出 因为byte最大为127而i是128
         */
        System.out.println(i); //输出为128
        System.out.println(b); //输出为-128 因为b为byte类型最大为127所以溢出了

        int i1 = 128;
        double b1 = i1;
        /*此处为 自动转换 把低容量类型int i1赋值给高容量类型double b1
        （8个字节的double）时自动转换，不用强制
         */
        System.out.println(i1);// 输出为128
        System.out.println(b1);// 输出为128.0

        /*
           注意点：
           1. 不能对布尔值进行转换
           2. 不能把对象类型转换为不相干的类型
           3. 在把高容量转换到低容量的时候，强制转换
           4. 转换的时候可能存在内存溢出，或者精度问题！
         */
        //举例如下：
        System.out.println("=============");
        System.out.println((int)23.7);//浮点类型强制转低容量int,输出为23
        System.out.println((int)-45.89f);//同上，输出为-45
        
        //例2：
        System.out.println("=============");
        char c = 'a';
        int d = c + 1;
        System.out.println(d);//输出为98 因为a对应97
        System.out.println((char)d);//输出为b 此处为int d向char的高向低容量强制转换
                                    //d此时为98，char中对应b所以输出b
        
        
        public class Demo06 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割而且不改变数字大小
        //例如：
        int money = 10_0000_0000;
        System.out.println(money);//输出为1000000000，证明加下划线数值不变

        int years = 20;
        int total = money*years;
        System.out.println(total);//输出为-1474836480，计算的时候溢出了
        //正确示范如下：
        long total3 = money*((long)years);
        //把int换成long,然后在相乘之前把其中一个数转换为long
        System.out.println(total3);//输出为20000000000,正确
    }
}

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

P26 Java基础06：变量、常量、作用域

public class Demo07 {
    public static void main(String[] args) {
        //int a,b,c;
        //int a=1,b=2,c=3;  //程序可读性
        String name = "qinjiang";
        char x = 'X';
        double pi = 3.14;
    }
}
1
2
3
4
5
6
7
8
9

public class Demo08 {

    //类变量 static：在类Demo中可用
    static double salary = 2500;

    //属性：变量

    //实例变量：从属于对象，只能在一个类里面用，比如这里一个类是Demo08
    /*实例变量如果不自行初始化，这个类型的默认值为 0 0.0
      布尔值默认是false
      除了基本类型，其余的都默认值是null
     */
    String name;
    int age;

    //下面这个叫main方法
    public static void main(String[] args) {

        //局部变量：只在一个方法的大括号{}之间有效，必须声明和初始化值
        int i = 10;/*声明i是int型，初始化值是10，是局部变量 比如就不
                    能在下面那个add方法里用*/
        System.out.println(i);

        //实例变量在类里面的使用：
        //变量类型为Demo08  变量名字为demo08 值是 new Demo08()
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);//输出0
        System.out.println(demo08.name);//输出null


        //类变量 static
        System.out.println(salary);//输出为2500



    }

    //其他方法:  下面这个叫add方法
    public void add(){

    }
}
//以上Demo08的整个是一个类


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

public class Demo09 {
    //常量final的使用：
    //static是类修饰符  修饰符不存在先后顺序 所以写成final static 也可以
    //加个static后这个常量就可以在类里面随时引用
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);//输出3.14
    }
}

1
2
3
4
5
6
7
8
9
10
11

P27 Java基础07：基本运算符

% : 模运算，又叫取余运算

!= : 不等于符号

&& ：与 || : 或 ！：非

如何在IDEA中选中多个Java文件：先点第一个文件，按住shift，再点最后一个，即可全部选中，如下图

实例1：
package operator;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //CTRL + d : 复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b);//30
        System.out.println(a-b);//-10
        System.out.println(a*b);//200
        System.out.println(a/(double)b);//0.5
             /*因为第四个除法算出来有小数，而int为整数型，所以
             在除号这里任选一个数进行强制转换为double型，这样输出的
             值就有小数点了
              */
    }

}

实例2：
    package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123123123L;
        int b = 123;
        short c = 10;
        byte d = 8;

        System.out.println(a+b+c+d);//123123123123264  为long类型
        System.out.println(b+c+d);//141  为int类型
        System.out.println(c+d);//18  为int类型
        /* 总结: 不同整数类型的变量运算时，如果其中有long类型，则输出结果转换
                 为long类型，没有long类型的话结果自动转换为int类型
         */

    }
}


实例3
    package operator;

public class Demo03 {
    public static void main(String[] args) {

        //关系运算符返回的结果：正确true  错误false  用布尔值表示
        //多与if连用

        int a = 10;
        int b = 20;
        int c = 22;

        // % 取余 又叫模运算
        System.out.println(c%a);//2   c/a  22 / 10 = 2 .....2
        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a==b);//false
        System.out.println(a!=b);//true
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

P28 Java基础08：自增自减运算符、初识Math类

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //自增 ++   自减 --

        int a = 3;
        int b = a++;//a++意思是先把a=3赋值给b，然后a自增1后a=3
        System.out.println(a);//输出4

        int c = ++a;//++a意思是a先自增1后a=5,然后把 5 赋值给 c

        System.out.println(a);//5
        System.out.println(b);//3
        System.out.println(c);//5

        //幂运算 2的3次方  很多运算，我们会使用一些工具类来操作
        double pow = Math.pow(2, 3);//输入 Math.pow(2,3)按alt+回车，再按两次回车就行了
        System.out.println(pow);//8.0


    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

P29 Java基础09：逻辑运算符、位运算符

逻辑运算符

package operator;

//逻辑运算符
public class Demo05 {
    public static void main(String[] args) {
        // 与（and）  或（or） 非（取反）
        boolean a = true;
        boolean b = false;

        System.out.println("a && b: "+(a&&b));//逻辑与运算：两个变量都为真，结果才为true
        //输出为  a && b: false
        System.out.println("a || b: "+(a||b));//逻辑或运算：两个变量至少有一个为真，则结果为true
        //输出为  a || b: true
        System.out.println("! (a && b): "+!(a&&b));//如果是真则变成假，如果是假则变成真
        //输出为  ! (a && b): true
        //+在这里是连接符的作用，双引号里面的东西都是直接输出的 属于字符串 ，字符串中 + 号是连接符 连接后面的运算结果


        //短路运算： 在与运算过程c&&d中，如果左边第一个c为假，则计算机不再往后运算 d 的真假，直接输出结果为false
        //实例：
        int c = 5;
        boolean d = (c<4)&&(c++<4);//先运算第一个c<4已经为假，若计算机运算&&后的，则最后c=6
        System.out.println(d);//false
        System.out.println(c);//输出5， 说明计算机判断出c<4为假后就直接输出d是false,没有再判断运算&&后面（c++<4）的真假



    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

位运算符

package operator;
//位运算符
//∧取反，又叫异或运算符
public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100  与运算 对比上下对应位置上的数，都为1则为1
        A|B = 0011 1101  或运算 对比上下对应位置上的数，有一个为1则为1
        A∧B = 0011 0001  异或运算 对比上下对应位置上的数, 相同为0， 不同为1
        ~B =  1111 0010  取反运算

        左移<< 和 右移>> 运算
        实例：如何最快计算2*8？
        规律：一个数左移<<一位相当于乘2，右移>>一位相当于除2
        因为在位运算中
        0000 0000     0
        0000 0001     1
        0000 0010     2
        0000 0011     3
        0000 0100     4
        0000 1000     8
        0001 0000     16
         */
        System.out.println(2<<3);//输出16  表示把2变成二进制0000 0010 然后位运算向左移3位
                                 //就变成了0001 0000 换成十进制输出就是16
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31