Java开发零基础篇：Day02 变量和运算符

Java开发零基础篇：Day02 变量和运算符 变量

通过一张不完整的房屋租赁合同，引出变量。

案例：张三需要租赁李四的房屋，租赁合同如下：

上述合同，相当不正规，因为正规的合同上，租客和房东都是有变动的，不能写死，在整个合同中应该 是使用甲方来表示房东，乙方来表示租客，只会在最后的时候签名甲方是谁，乙方是谁。

变量概述

表示存储空间，可用来存放某一类型的常量，没有固定值，并可以重复使用。变量是内存中一块区域，可以往该区域存储数据，修改里面的数据，也可以获取里面的数据。

变量的特点：

(1)占据着内存中的某一块存储区域

(2)该区域有自己的名称（变量名）和类型（数据类型） 可以被重复使用

(3)该区域的数据可以在同一类型范围内不断变化

变量定义和赋值

1.定义一个int类型变量，并赋值。

public class Demo01 {
    public static void main(String[] args) {
        
        int age;
        age = 21;
        System.out.println(age);
​
        
        String name = "BanQ";
        System.out.println(name);
    }
}

控制台输出：

21
BanQ

使用变量注意：

(1)变量必须先声明，并且初始化后才能使用定义变量必须有数据类型；

(2)变量从开始定义到所在的花括号结束之内可以使用，离开花括号就不能使用了同一作用域内，变量名不能重复定义；

以上面的代码为例：

String，表示类型，这里可以写任何的类型；

name：变量名，和我们的姓名一样理解；

=：赋值运算符，意思是将右边的值赋值给左边的变量“BanQ”。

2.定义每一种数据类型的变量。

public class Demo02 {
    public static void main(String[] args) {
        //byte类型变量
        byte byteVar = 1;
        System.out.println(byteVar);
​
        //short类型变量
        short shortVar = 2;
        System.out.println(shortVar);
​
        //int类型变量
        int intVar = 3;
        System.out.println(intVar);
​
        //long类型变量
        long longVar = 4L;
        System.out.println(longVar);
​
        //float类型变量
        float floatVar = 0.5F;
        System.out.println(floatVar);
​
        //double类型变量
        double doubleVar = 0.6;
        System.out.println(doubleVar);
​
        //char类型变量
        char charVar = '7';
        System.out.println(charVar);
​
        //boolean类型变量
        boolean booleanVar = true;
        System.out.println(booleanVar);
​
        //String类型变量
        String stringVar = "8";
        System.out.println(stringVar);
    }
}

控制台输出：

1   2   3   4   0.5   0.6   7   true    8

3.交换两个相同类型变量的值。

(1)把num1的值存储到临时变量temp中去；

(2)把num2的值赋给num1变量；

(3)把temp存储的值赋给num2变量。

public class Demo03 {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        System.out.println("交换前num1：" + num1);
        System.out.println("交换前num2：" + num2);
        //交换 *** 作
        int temp;
        temp = num1;
        num1 = num2;
        num2 = temp;
        System.out.println("交换后num1：" + num1);
        System.out.println("交换后num2：" + num2);
    }
}

控制台输出：

交换前num1：10
交换前num2：20
交换后num1：20
交换后num2：10

表达式

表达式（expression），是由数字、运算符、括号、常量、变量等以能求得结果的组合。

表达式举例（下列a、b、x、y、z都表示变量）。

(1)a + b

(2)3.14 + a

(3)(x + y) * z + 100

基本数据类型转换

在8大基本数据类型中，boolean不属于数值类型，所以不参与转换，其他类型的转换规则如下图。一般的，byte、short、char三种类型相互之间一般不参与转换 *** 作。

按照转换方式，有两种（注意：boolean类型不参与类型转换）：

自动类型转换：范围小的数据类型直接转换成范围大的数据类型，小->大。

强制类型转换：范围大的数据类型强制转换成范围小的数据类型，大->小。

自动类型转换

自动类型转换，也称为“隐式类型转换，就是把范围小的数据类型直接转换成范围大的数据类型。

转换规则：byte、short、char—>int—>long—>float—>double

注意事项：byte、short、char相互之间不转换，他们参与运算首先转换为int类型

语法格式：范围大的数据类型 变量 = 范围小的数据类型值；

public class Demo04 {
    public static void main(String[] args) {
        // int类型 -> long类型
        long longVar = 17; //整数类型默认为int类型
​
        // long类型 -> float类型
        float floatVar = longVar;
​
        // float类型 -> double类型
        double doubleVar = floatVar;
​
        //自动类型提升
        int a = 1;
        int b = 2;
        int c = a + b;
​
        byte d = 2;
        int e = 3;
        //byte short char 类型参与运算时会自动提升为int类型
        System.out.println(d + e);
    }
}

自动类型提升

当一个算术表达式中，包含多个基本数据类型的常量或变量（boolean除外）时，整个算术表达式的结果类型将在出现自动提升，其规则是：

(1)所有的byte、short、char类型被自动提升到int类型，再参与运算；

(2)整个表达式的最终结果类型，被提升到表达式中类型最高的类型。

public class Demo05 {
    public static void main(String[] args) {
        System.out.println('a' + 1);
        byte a = 1;
        a = a + 2;  //编译失败
        double b = 1 + 2F + 3.14 + 4L;  //类型自动转化为最高类型double
        System.out.println(b);
    }
}

因此，算数表达式结果的类型就是其中范围最大的数据类型。

强制类型转换

强制类型转换，也称为显式类型转换，就是把范围大的数据类型强制转换成范围小的数据类型。

语法格式：

范围小的数据类型 变量 = （范围小的数据类型）范围大的数据类型值;

但是一般情况下不建议使用强转，因为强转有可能损失精度。

public class Demo06 {
    public static void main(String[] args) {
        int a = 1;
        byte b = 2;
        //自动类型转换
        int c = a + b;
        //强制类型转换
        byte d = (byte)(a + b);
        int e = (int)1.23;
        System.out.println(e);  //输出1
    }
}

运算符

对常量和变量进行 *** 作的符号称为运算符。

常用运算符：

算术运算符

赋值运算符

比较运算符

逻辑运算符

三元运算符

算术运算符

加减乘除余

对于字符串而言，+符号表示连接 *** 作，任何类型的数据和字符串相连接，结果都是字符串。

public class Demo07 {
    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        //加减乘除
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        //取模求余
        System.out.println(a % b);
        //字符串
        System.out.println(1+2+"BanQ");
        System.out.println("BanQ"+1+2);
    }
}

控制台输出：

30
10
200
2
0
3BanQ
BanQ12

自增和自减

自增：++，递增 *** 作符，使变量值增加1，有前置和后置之分，只能 *** 作变量。

自减：-- ，递减 *** 作符，使变量值减去1，有前置和后置之分，只能 *** 作变量。

自增和自减具体 *** 作是一样的，仅仅是一个是加1，一个是减1而已。

public class Demo08 {
    public static void main(String[] args) {
        int a = 1;
        int b = ++a;
        System.out.println("a=" + a);
        System.out.println("b=" + b);

        int c = 1;
        int d = c++;
        System.out.println("c=" + c);
        System.out.println("d=" + d);
    }
}

控制台输出：

a=2
b=2
c=2
d=1

代码 a++和 ++a，结果都是a变量的值加1。唯一的区别是：

前置（++a）: 表示对result加1之后的结果进行运算

后置（a++）: 表示对result变量加1之前的值（原始值）进行运算。

如果仅仅执行简单的递增 *** 作（只写a++或++a），那么选用任意一个都可以。

正确的解释：

++a表示取a的地址，增加它的内容，然后把值放在寄存器中；

a++表示取a的地址，把它的值装入寄存器，然后增加内存中的a的值；

如果不理解什么是寄存器，简单记住，都可以表示当前变量自身加1，区别是：

前置++：先增加后使用

后置++：先使用后增加

赋值运算符

public class Demo09 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println("a=" + a);
        a += 1;
        System.out.println("a=" + a);
        short b = 2;
        b += 1; //等价于 b = (short)（b + 1）
        System.out.println("b=" + b);
    }
}

控制台输出：

a=1
a=2
b=3

比较运算符

用于比较两个变量或常量之间的大小关系，其结果是boolean类型（要么为true，要么为false）。

其格式为:

boolean 变量名 = 表达式A 比较运算符 表达式B;

注意：>=符号，表示大于或者等于。

public class Demo10 {
    public static void main(String[] args) {
        System.out.println(10 > 5);
        System.out.println(10 >= 5);
        System.out. println(10 >= 10);
        System.out. println(10 < 5);
        System.out. println(10<= 5);
        System.out. println(10 <=10);
        System.out.println(10 == 10);
        System.out.println(10 != 10);
        int a = 10;
        int b = 5 ;
        boolean result = a > b;
        System.out.println(result);
    }
}

控制台输出：

true
true
true
false
false
true
true
false
true

三元运算符

三元运算符，表示有三个元素参与的表达式，所以又称为三目运算符，其语义表示if-else（如果什么情况就做什么，否则做什么）。

语法格式：

数据类型 变量名 = boolean表达式 ? 结果A ：结果B；

如果boolean表达式结果：

为true，则三元运算符的结果是结果A；

为false，则三元运算符的结果是结果B；

注：三元运算符必须定义变量接受运算的结果，否则报错。

三元运算符结果的类型由结果A和结果B来决定的，结果A和结果B的类型是相同的。

(1)判断一个数是不是偶数

public class Demo11 {
    public static void main(String[] args) {
        int a = 77;
        String result = a % 2 == 0 ? "偶" : "奇";
        System.out.println(result); //奇
    }
}

(2)求99和20两个数中的最大值

public class Demo12 {
    public static void main(String[] args) {
        int a = 99;
        int b = 20;
        int result = a > b ? a : b;
        System.out.println("最大值：" + result); //99
    }
}

(3)—共55条数据，每叶10个条数据，一共分多少页

public class Demo13 {
    public static void main(String[] args) {
        int totalCount = 55;
        int pageSize = 5;
        int totalPage = totalCount % pageSize == 0
                ? totalCount / pageSize
                : totalCount / pageSize + 1;
        System.out.println(totalPage);  //11
    }
}

逻辑运算符

逻辑运算符用于连接两个boolean表达式，结果也是boolean类型的。

语法格式为：

boolean 变量名 = boolean表达式A 逻辑运算符 boolean表达式B;

运算规则如下：

规律：

非：取反，！true则false,！false则true

与：有false则false

或：有true则true

异或：^ 相同则false,不同则true

public class Demo14 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        //与 *** 作
        System.out.println((a > b) & (a > c)); //false & false
        System.out.println((a > b) & (a < c)); //false & true
        System.out.println((a < b) & (a > c)); //true & false
        System.out.println((a < b) & (a < c)); //true & true
        //或操作
        System.out.println((a > b) | (a > c)); //false & false
        System.out.println((a > b) | (a < c)); //false & true
        System.out.println((a < b) | (a > c)); //true & false
        System.out.println((a < b) | (a < c)); //true & true
        //相反操作
        System.out.println((a > b)); //false
        System.out.println(!(a > b)); //!false
        System.out.println(!!(a > b)); //!!false
    }
}

控制台输出：

false
false
false
true
false
true
true
true
false
true
false

&和&&的区别

& ：&左边表达式无论真假，&右边表达式都进行运算；

&& ：如果&&左边表达式为真，&&右边表达式参与运算，否则&&右边表达式不参与运算，故称短路与。

| 和 || 的区别同理，||，左边为真，右边不参与运算。

public class Demo15 {
    public static void main(String[] args) {
        System.out.println(false & 1/0 ==1); //报错，说明右边表达式执行了
        System.out.println(false && 1/0 ==1); //不报错，说明右边表达式不执行
        System.out.println(true | 1/0 ==1); //报错，说明右边表达式执行了
        System.out.println(true || 1/0 ==1); //不报错，说明右边表达式不执行
    }
}

运算优先级

表达式的运算都是有优先级的，基本上和数学中的优先级类似，这里需要注意的是，赋值符号。

注意：赋值符号最后运算的，并且是从右向左运算的。

以上就是Java入门第二天的全部内容了。

资料文档地址：Java开发零基础篇：Day02变量和运算符.pdf