java学习第二天——变量，数据类型转换，运算符

JAVA学习第二天

变量

变量：变量是指程序运行期间可改变的量

创建一个变量的格式；

1. 数据类型 变量名；
2. 数据类型 变量名 = 数据值；
3. 数据类型 变量名，变量名，… ；
4. 数据类型 变量名 = 数据值，变量名 = 数据值，… ；
   [ ]: 3为同时声明多个变量语句格式
   [ ]: 4为同时声明多个变量并且赋值的语句个事

使用变量时的注意事项
1.如果创建多个变量，那么变量之间的名称不可以重复
2.对于使用float 和long类型来说，字符后缀的F或L不要丢掉
3.如果使用byte或者short 类型的变量，那么右侧的数据值不能超过左侧的类型取值范围
4.没有进行赋值的变量，不能直接使用，一定要赋值之后，才能使用
【作用域】：从定义一个变量的一行开始，直到所属的大括号结束为止
5.变量使用不能超过作用域的范围
6.可以通过一个语句来创建多个变量，一般情况下不推荐使用、

代码示例

import sun.awt.X11.XSystemTrayPeer;

public class 变量 {
    public static void main(String [] args){
        //创建一个变量
        //格式：数据类型 变量名称
        int num1;
        //向变量当中存入一个数值；
        //格式：变量名称 = 数据值；
        num1 = 10;
        //当打印输出变量名称的时候，显示出来的是变量的内容
        System.out.println(num1);

        //改变变量当中本来的数字，变成新的数字
        num1 = 20;
        System.out.println(num1);

        //使用一步到位的格式来定义变量
        //格式：数据类型 便令名称 = 数据值；
        int num2 = 25;
        System.out.println(num2);//25

        num2 = 35;
        System.out.println(num2);//35

        byte num3 = 30;//注意：右侧的数值范围不能超过左侧的数据类型的取值范围
        System.out.println(num3);//30

        //byte num4 = 400;//左侧炒熟了byte的取值范围，错误

        short num5 = 50;
        System.out.println(num5);//50

        long num6 = 10000000L;
        System.out.println(num6);//10000000

        float num7 = 2.5F;
        System.out.println(num7);//2.5

        double num8 = 1.2;
        System.out.println(num8);//1.2;

        char zifu1 = 'A';
        System.out.println(zifu1);//A

        zifu1 = '中';
        System.out.println(zifu1);//中

        boolean var1 = true;
        System.out.println(var1);//true

        var1 = false;
        System.out.println(var1);//false

        //讲一个变量的数据内容，复制交给另一个变量
        //右侧的变量名称var1已经存在，里面装的是false布尔值
        //将右侧变量里面的布尔值false赋值给左侧的var2
        boolean var2 = var1;
        System.out.println(var2);

        /*
        使用变量的时候，有一些注意事项
        1.如果创建多个变量，那么变量之间的名称不可以重复
        2.对于使用float 和long类型来说，字符后缀的F或L不要丢掉
        3.如果使用byte或者short 类型的变量，那么右侧的数据值不能超过左侧的类型取值范围
        4.没有进行赋值的变量，不能直接使用，一定要赋值之后，才能使用
        【作用于】：从定义一个变量的一行开始，直到所属的大括号结束为止
        5.变量使用不能超过作用域的范围
        6.可以通过一个语句来创建多个变量，一般情况下不推荐使用
         */


        int num10 = 10;//创建一个变量，名叫num10
        //int num10 = 25;//有创建一个新的变量，名字也叫num10，错误

        int num14;//定义了一个变量，但没有赋值
       // System.out.println(num14);//直接使用打印输出是错误的

        //System.out.println(num15)//在创建变量之前，不使用这个变量
        int num15 = 500;
        System.out.println(num15);//500

        {
            int num16 = 60;
            System.out.println(num16);
        }
       // System.out.println(num16);、//已经超出了大括号的范围，超出了作用域，不能使用了
        int a,b,c;//同事创建三个类型为int的变量a，b，c

        //各自分别赋值
        a = 10;
        b = 20;
        c = 30;
        System.out.println(a);//10
        System.out.println(b);//20
        System.out.println(c);//30

        //同时创建三个int变量，并且同事赋值
        int x = 100 , y = 200,z = 300;
    }
}

数据类型转换

当数据类型不一样时，将会发生数据类型转换

数据类型转换分为自动类型转换（隐式）和强制类型转换（显式）

自动转换是程序在执行过程中“悄然”进行的转换，不需要用户提前声明，一般是从位数低的类型向位数高的类型转换；强制类型转换则必须在代码中声明，转换顺序不受限制。

自动类型装换（隐式）

1.特点：代码不需要进行处理，自动完成

2.规则;数据范围从小到大

强制类型转换（显式）

1.特点;代码需要进行特殊处理，不能自动完成

2.格式：数值范围小的数据类型 数值范围小的变量名 = （数值范围小的变量类型） 原本数值范围大的数据类型；

注意意事项；
    1.强制类型转换一般不推荐使用，因为有可能发生精度损失，数据溢出
    2.byte/short/char这三种数据类型都可以发生数学运算，例如加法”+“
    3.byte/short/char/这三种类型在运算的时候会首先提升为一个int类型，然后计算
    4.boolean不能发生数据类型转换

基本数据类型范围大小比较

double>float>long>int>short，byte，char。（注意这里的数据范围并不是指数据之大小，所以和数据类型所占的字节数没有必然联系

序号 数据类型 大小/位 封装类 默认值（零值） 可表示数据范围
1 byte(字节) 8-bit Byte (byte)0 -128~127
2 short(短整数) 16-bit Short (short)0 -32768~32767
3 int(整数) 32-bit Integer 0 -2147483648~2147483647
4 long(长整数) 64-bit Long 0L -9223372036854775808~9223372036854775807
5 float(单精度) 32-bit Float 0.0F 1.4E-45~3.4028235E38
6 double(双精度) 64-bit Double 0.0D 4.9E-324~1.7976931348623157E308
7 boolean but its “size” isn’t something that’s precisely defined. Boolean flase true或false
8 char(字符) 16-bit Character ‘\u0000’（对应数字0，输出为空） 0~65535

示例代码

/*
当数据类型不一样是，将会发生数据类型转换
自动类型装换（隐式）
    1.特点：代码不需要进行处理，自动完成
    2.规则;数据范围从小到大
强制类型转换（显式）
    1.特点;代码需要进行特殊处理，不能自动完成
    2.格式：数值范围小的数据类型 数值范围小的变量名 = （数值范围小的变量类型） 原本数值范围大的数据类型；
注意意事项；
    1.强制类型转换一般不推荐使用，因为有可能发生精度损失，数据溢出
    2.byte/short/char这三种数据类型都可以发生数学运算，例如加法”+“
    3.byte/short/char/这三种类型在运算的时候会首先提升为一个int类型，然后计算
    4.boolean不能发生数据类型转换
 */
public class 数据类型转换 {
    public static void main(String[] args) {
        System.out.println(1024);//这是一个整数，默认为int
        System.out.println(3.14);//这是一个浮点数，默认就是double


        //左边是long类型，右边默认是int类型，左右数据类型不一样
        //一个等号代表赋值，将右侧int常量，交给左侧long变量进行存储
        //int --》 long 符合了数据范围从小到大的要求
        //这一行代码发生了自动类型转换
        long num1 = 100;
        System.out.println(num1);//100

        //左边是double类型，右边默认是float类型，左右数据类型不一样
        //一个等号代表赋值，将右侧float常量，交给左侧doble变量进行存储
        //float --》 double 符合了数据范围从小到大的要求
        //这一行代码发生了自动类型转换
        double num2 = 2.5F;
        System.out.println(num2);


        //左边是flaot类型，右边默认是long类型，左右数据类型不一样
        //一个等号代表赋值，将右侧long常量，交给左侧float变量进行存储
        //long --》 float 符合了数据范围从小到大的要求
        //这一行代码发生了自动类型转换
        float num3 = 100L;
        System.out.println(num3);

        //强制类型转换

        //等号左边是int类型，右边是long类型，不一样
        //long--》 int数据范围不是从小到大
        //不能发生自动转换
        //100L前加上(int)来强制类型转换
        int num = (int)100L;
        System.out.println(num);//100

        //注意事项

        //long强制转换为int类型
        int num10 = (int) 6000000000L;
        System.out.println(num10);//1705032704 发生数据溢出

        //double-->int 强制类型转换
        int num11 = (int) 3.5;
        System.out.println(num11);//3 发生了进度损失

        char zifu1 = 'A';//这是一个字符型变量，赋值为A
        System.out.println(zifu1 + 1);//66,也就是说大写字母A被当做65来处理了，
        //计算机的底层是用一个数字（二进制）来代表一个字符，就是65
        //一旦char类型发生数学运算，那么字符就会被当成一个数字来使用，就是自动转换为int类型，被翻译成一个数字

        byte num14 = 40;
        byte num15 = 50;

        //byte + byte--->int + int ---->int
        int result1 = num14 + num15;
        System.out.println(result1);//90

        short num16 = 60;
        //byte+short---->int + int ---->int
        //在转换过程中需要保证最终结果没有超过short数值范围
        short result2 = (short)( num16 +num14);


    }
}

ASCLL码

ASCII：American standard code for information interchange 美国信息交换表

Unicode码表;万码表，也是数字字符对照关系表

/*
    数字和字符的对照关系表（编码表）；
    ASCII：American standard code for information interchange 美国信息交换表
    Unicode码表;万码表，也是数字字符对照关系表
 */
public class Ascll码 {
    public static void main(String[] args) {
        char zifu1 = '1';
        System.out.println(zifu1+0);//49,1在ascll码表上49位

        char zifu2 = 'A';
    
        char zifu3 = 'c';
    
        //左侧int类型，右侧char类型
        //char-->int 范围从小到大
        //发生自动类型转换
        int num = zifu3;
        System.out.println(num);//99
    
        char zifu4 = '中';//正确写法
        System.out.println(zifu4+0);//20013,
    }
}

结果展示

49
99
20013

Process finished with exit code 0

运算符

赋值运算符

赋值运算符

基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量

int a = 30;

复合赋值运算符

+=  a += 1  相当于  a = a + 1 其余同理

-=

/=

%=

注意事项

1.只有变量才可以使用赋值运算符，常量不能进行赋值

2，复合赋值运算符其中隐含了一个强制类型转换

示例代码

public class 赋值运算符 {
    public static void main(String[] args) {
        int a = 10;
        //a = 10 + 5 =15
        a += 5;
        System.out.println(a);//15

        byte num = 30;
        //num = num + 5
        //num = byte+int
        //num = int + int
        //num = int
        //num = (byte)int
        num += 5;
    }
}

结果展示

15


Process finished with exit code 0

比较运算符

== 等于【两个等号才是相等，一个等号是赋值】

“<” 小于

“>” 大于

"<= " 小于等于

"= " 大于等于

"!= " 不等于

自增自减运算符

自增运算符：++

自荐运算符:–

基本含义：让一个变量涨一个数字1，或者让一个变量讲一个数字1

使用格式：写在变量名称之前和之后，例如：++num，或者num++

使用方法：

1.单独使用；不和其他任何操作混合自己独立成为一个步骤

2.混合使用：和其他操作混合，例如与赋值混合，或与打印操作混合

    A。如果是【前++】，那么变量马上+1，然后再拿结果计算

    B。如果是【后++】，那么先用原来了数值运算之后在+1

注意事项：

只有变量才可以使用自增自减运算符，常量不可以

示例代码

public class 自增自减运算符 {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1);//10
        ++num1;//单独使用,前++
        System.out.println(num1);//11
        num1++;//单独使用。后++
        System.out.println(num1);//12

        //--------------
        //混合使用
        int num2 = 20;
        //前++,立马加1，在打印
        System.out.println(++num2);//21
        System.out.println(num2);//21

        int num3 = 30;
        //后++，先打印，在加1
        System.out.println(num3++);//30
        System.out.println(num3);//31

        //和赋值操作混合
        int num4 = 40;
        //前--，先减1，在赋值
        int result1 = --num4;
        System.out.println(result1);//39
        System.out.println(num4);//39

        //后--，先赋值，在减1
        int num5 = 50;
        int result2 = num5--;
        System.out.println(result2);//50
        System.out.println(num5);//49

        int x = 10;
        int y = 20;
        int result3 = ++x + y--;
        System.out.println(result3);//31
        System.out.println(x);//11
        System.out.println(y);//19



    }
}

结果展示

10
11
12
21
21
30
31
39
39
50
49
31
11
19

Process finished with exit code 0

逻辑运算符

与 （并且） && 全en都是true 才是true 否则是false

或 （或者） || 有一个是true就是true 全都是false 才是false

非 （去反） ！ 本来是false变成true 本来是true 变成false

&& 和 || 具有短路效果，如果根据左边已经可以判断出最终结果，那么不再执行右边的代码

注意事项：

1，逻辑运算符只能用一个布尔值

2与，或需要左右各自有一个布尔值，但是去反只要有唯一的一个布尔值即可

示例代码

public class 逻辑运算符 {
    public static void main(String[] args) {
        System.out.println(true && false);
        System.out.println(true && true);
        System.out.println(true || true);
        System.out.println(true || false);
        System.out.println(!true);
        System.out.println(!false);
        int a =10;
        int b = 10;
        if(a > 10 && b++ > 10){

        }
        System.out.println(a);
        System.out.println(b);
    }
}

结果展示

false
true
true
true
false
true
10
10

Process finished with exit code 0

三元运算符