java基础学习笔记day04（常量、数据类型转换、运算符）

java基础学习笔记day04（常量、数据类型转换、运算符）

前言：上一次笔记说到变量，那么在java中除了变量还有常量，其实常量在项目开发中用的也很多，但是在一些书面上对常量的介绍很少很少，往后大家在项目中会很多的利用到常量，所以常量也是要好好学习的；那么在众多的常量类型中，区间有大有小，既然有小有大，就应该有互相转换的问题；那这些变量中的运算又是怎么运算的呢，除了我们数学中聊到的加减乘除还有什么运算呢？那么接下来就去聊聊这些吧。

第一章 数据类型转换

java中各个数据类型是可以进行转换的，那么在java中有两种方式进行数据转换，这两种是：自动数据类型转换和强制数据类型转换。

1.1、自动类型转换

在java程序中，数据类型会自动转变，看下面代码：

//声明一个byte类型变量num
byte num = 10;
//将这个byte变量的值赋给一个int类型变量num1
int num1 = num;
System.out.println(num1);

分析：照这个程序运行下去，输出结果num1的值是10；程序不会报错，会正常运行，那么可以看到，在这个程序中，num本来为一个byte变量，但是他在后续代码中赋值给了一个int变量，那么在这个过程中他就发生了自动类型的转换。

所以可以总结道：大类型变量=小类型变量/值 tips：判断变量类型大小是通过存储空间来判定的

接下来再看一个代码：

//声明两个个byte变量i和j
byte i = 5；
byte j = 15；
//声明一个int变量存储变量i和j的和
int sum = i+j;
System.out.println(sum);

分析：这串代码在实际运行的时候输出结果是20；程序也不会报错，byte类型的两个变量相加的值赋给一个int变量，不会报错，所以这里也进行了自动转换，值得一提的是，在java中，正整数的四则运算都会自动转换类型为int类型，小数的四则运算都会自动转换为double类型。

总结：数值之间在进行四则运算时，数据类型会自动向大类型靠拢。 char->int；byte->short->int->long>float->double

1.2、强制类型转换

在java程序中，碰到大区间范围的变量要变成小区间范围的变量时，不会自动转换类型，所以就要强制的进行类型转换，前提是这个变量的字面值没有超过小区间范围变量的小区间。我们看如下代码：

//声明一个int类型的变量num2
int num2 = 16；
//将这个int变量强转后赋值给比int变量区间小的byte类型变量
byte num3 = (byte)num2;
System.out.println(num3);

分析:上诉代码在程序中运行的输出结果是16，在上述代码中我们就将一个int变量num2强制转换为了byte变量num3

总结：强制转换的书写规则：小变量类型 变量名 = (小变量类型)大类型变量名 其中这个大类型变量名一定是要赋过值得

那我们再来看看这个代码：

//声明一个int类型变量num4
int num4 = 129；
//将这个int变量强转后赋值给比int变量区间小的byte类型变量
byte num5 =(byte)num4;
System.out.println(num5);

用cmd去运行下这个代码，发现输出结果不是129而是-127，那这是为什么呢？

分析：原本这个129是被赋给一个int变量类型的，int变量是有4个字节，也就是有32位，所以int变量中129的表达方式是 0000 0000 0000 0000 0000 0000 1000 0001，之后咱们把这个129强制转换成了一个byte变量，byte变量是占一个字节，也就是8位，这个时候129二进制就成为了10000001；而我们说最前面一位是符号位（电脑会这么认为），1代表负数，那么负数在电脑中是以补码的形式存在的，所以我们要先计算出这个10000001的原码，通过计算它的原码是11111111，这个二进制数换算成十进制的数就是-127.

总结：java中数据转换可能会得出错误的答案，所以强转有风险，强转需谨慎

第二章 常量

2.1、什么是常量？

java程序中其值不能发生改变就是常量。在java程序中，有些时候我们不能去改变一个数的常量，避免计算的时候答案发生变化，例如：我们在计算圆的周长面积等，我们规定pi的值不能发生改变，不然岂不是每个人算到的圆周长面积都会不一样吗？所以我们就需要的存在了。

看如下代码：

//我们去计算一个圆的面积
public class Demon{
    public static void main(String[] args){
        //定义一个int变量存放圆的半径r
        int r = 5；
        //声明一个double变量存放pi的值
        final double pi = 3.14；
        //声明一个变量存放圆的面积的值
        double area= pi*r*r;
        System.out.println(area);
    }
}

咱们这个代码在程序中就保持了pi的值不发生改变。

2.2、常量的分类

• 字面常量：保持这个常量在程序运行的时候发生不变就好，不要去给这个变量再去赋值就好
• 通过final来固定这个变量的值不发生改变

看如下代码：

public class Demon{
    public static void main(String[] args){
        //定义一个int变量存放圆的半径r
        int r = 5；
        //声明一个double变量存放pi的值
        final double pi = 3.14；
        //声明一个变量存放圆的面积的值
        double area= pi*r*r;
        System.out.println(area);
        //改变变量pi的值
        pi = 3.1415926；
        System.out.println(pi);
     }
}

这个代码在程序中编译就会报错，原因是在final修饰过的变量其值不能进行修改，这个变量就变成了常量了。

2.3、常量的命名规则

常量的命名规则其他都和表示符命名规则差不多，只是有一点不一样：他是每个首字母大写，且每个单词后面要加上下划线_来隔开，例如：Chang_Liang。

第三章 运算符

3.1、运算符的分类

• 赋值运算符 =

• 算数运算符 + - * / % ++ –

• 关系运算符 > < >= <= != == instanceOf

• 逻辑运算符 & | ！ ^ && ||

• 拓展/扩展运算符 += -= *= /= %= >>= <<= ^= !=

• 位运算 & | ^ >> << <<< !

• 条件运算符 ?:

3.2、赋值运算符

• 赋值运算符就是=，就是将等式右边的值赋给左边的变量，等式右边可以是一个数，也可以是各种四则运算。

• 赋值运算符是少许几个自右向左运算的运算符

3.3、算数运算符

i、+号

+号在java中有三种用法，我们看如下程序：

public class Demon01{
    public static void main(String[] args){
        //给一个int变量num6赋值
        int num6 = +3；
        //定义一个变量int，其值为0
        int num7 = 0；
        num7 = num7+num6；
        System.out.println("num6的值是"+num6);
        System.out.println("num7的值是"+num7);
    }
}

依次执行上述程序，输出结果num6的值是3，num7的值是3。

通过上述程序，我们可以总结+号的用法有三种：

• +号代表正号，也可以省略不写；
• 加法运算，和数学中的加法运算一致；
• 连接符号，当+号左右两边有字符串的时候，+号代表的就是连接符号，他会将左右两边的值或者字符串拼接在一起

ii、-号

-号在java程序编写的时候有两种作用，我们看如下程序：

public class Demon02{
    public static void main(String[] args){
        //给一个int变量num8赋值
        int num8 = -3；
        //定义一个变量int，其值为5
        int num9 = 5；
        num9 = num9-num8；
        System.out.println("num8的值是"+num8);
        System.out.println("num9的值是"+num9);
    }
}

依次执行上面的程序，我们得到结果num8的值是-3，num9的值是5。

通过上述程序，我们可以总结-号的用法有三种：

• -号代表负号，不可以省略
• 减法运算，和数学中的减法运算一致

iii、*、%、/

这三个就不去意义列举了，他们在java中的作用都很单一，*号表示乘法运算，与数学里的乘法一致，/号表示除法运算，与数学里的除法运算一致，%号表示取余运算，与数学里的取余运算一致。

iv、++、–

在java中++、–都是单目运算符，就是左右两边只能接一个操作数。

看如下代码：

public class Demon03{
    public static void main(String[] args){
        int i=5;
        //用++运算符(不作为单独的一句话)
        i++;
        System.out.println(i);
        //用++运算符表示一句话的时候
        int result = ++i；
        int result1 = i++;
        System.out.println(result);
        System.out.println(result1);
    }
}

使用cmd运行上述代码，输出的i的值是6，result的值是7；result1的值是7。

• 在java中++代表变量在原来的基础上自增1，而–则代表变量在原来的基础上自减1；
• 当++和–不作为一条语句使用在java程序中的时候，++和–在变量前面和变量后面都没关系，都会自增或者自减
• 当++和–做为一条完整的语句使用在java程序中的时候，++和–在前面的话，会先为变量自增，然后再赋值，而++和–在后面的话，会先赋值，后变量自增。

3.4、扩展运算符

扩展运算符本质上是算数运算符和位运算符+赋值运算符的一个结合体。

看如下代码：

//计算两个分数之和
public class Demon04{
    public static void main(String[] args){
        int iScore = 78;
        int jScore = 67;
        int sum = 0;
        sum += iScore;
        sum += jScore;
        System.out.println(sum);
    }
}    
    

运行上述代码，输出结果为145。其实上述代码中sum+=iScore就等同于sum=sum+iScore。

利用扩展运算符，会使得变量之间发生强制类型转换，看如下代码：

int i =1000；
byte j = 0；
j +=i；
System.out.println(j);

运行上述代码，j的值不会等于1000；j的值得到的是一个负数，计算结果出现错误。

通过上述两个代码，我们总结扩展运算符的优缺点：

• 优点：

  • 提高了程序的编译速度；
  • 提高了程序的编写速度

• 缺点：

  • 不利于理解意思

• 优缺点：

  • 使用扩展运算符会是变量之间发生强制类型转换，有可能导致运算结果发生错误改变

3.5、关系运算符

看如下代码：

public class Demon04{
    public static void main(String[] args){
        boolean flag = 6>5;
        System.out.println(flag);
        boolean flag1 = 4!=5;
          System.out.println(flag1);
         boolean flag2 = 4==5;
         System.out.println(flag2);
    }
}

运行上面的代码，运行结果flag的值是true，flag1的值是true，flag2的值是flase。

总结：

• 关系运算符最后得出的结果是一个boolean类型的值；
• != == 既可以比较基本数据类型 也可以比较引用类型
• < > >= <= 只能比较基本数据类型 (布尔类型除外)

3.6、逻辑运算符

逻辑运算符有： & | ！ ^ && || ；其中&、|、^这三个运算符可以是位运算符也可以是逻辑运算符，当这三个运算符左右两边为数字的时候，它们为位运算符，其他时候是逻辑运算符。

看如下代码：

public class Demon05{
    public static void main(String[] args){
        System.out.println(true&true); //答案是true       
        System.out.println(true&false);//答案是false        
        System.out.println(false&true);//答案是false      
        System.out.println(false&false);//答案是false               
        System.out.println(true&&true); //答案是true        
        System.out.println(true&&false);//答案是false         
        System.out.println(false&&true);//答案是false        
        System.out.println(false&&false);//答案是false 
        System.out.println(true|true);//答案是true        
        System.out.println(true|false);//答案是true        
        System.out.println(false|true);//答案是true        
        System.out.println(false|false);//答案是false 
        System.out.println(true||true);//答案是true         
        System.out.println(true||false);//答案是true         
        System.out.println(false||true);//答案是true         
        System.out.println(false||false);//答案是false 
        System.out.println(!true);//答案是false         
        System.out.println(!false);//答案是true  
        System.out.println(true^true);//答案是false 相同为假，相反为真        
        System.out.println(true^false);//答案是true         
        System.out.println(false^true);//答案是true         
        System.out.println(false^false);//答案是false  
    }
}

运行上述代码，可以总结出：

• &和&& 左右两边的操作数都为true，其结果才为true；
• |和||左右两边的操作数有一个为true，其结果就为true；
• ^ 左右两边的操作数相同为false，不同为true；
• ！取反，true->false false->true ；

注意事项：

• &&当左边第一个操作数为false的情况下不会对第二个操作数进行运算，因为结果一定 为false；
• ||当左边第一个操作数为true的情况下不会对第二个操作数进行运算，因为结果一定为 true；
• 所以我们在编写程序的时候，一般使用的是&&和||，而不会使用&和|。