2.Java的基础数据类型以及转换，运算符

Dasher jensen

已于 2022-07-19 10:51:42 修改

阅读量289

点赞数

分类专栏： JAVA学习笔记文章标签：大数据 java

于 2022-07-19 10:45:44 首次发布

本文链接：https://blog.csdn.net/unstoppableyi/article/details/125760018

版权

JAVA学习笔记专栏收录该内容

23 篇文章 0 订阅

订阅专栏

基本数据类型

Java中有两大数据类型：基本数据类型、引用类型

基本数据类型（8种）

1.byte 1个字节 -128~+127

2.short 2个字节 -32768~+32767

3.int 4个字节（32位）

4.long 8个字节

在java中所有整型数值默认为int类型

5.float 4个字节

6.double 8个字节

在java中所有浮点型数值默认为double类型

（浮点运算的精确度(正无限大和负无限大)）

当相同字节数的浮点类型数据比整型的数据类型保存的数值要大用科学计算法的表示：

eg：5100.00 --->5.1*10^3---->5.1e3

7.布尔：boolean true|false

8.char 16个字节

注意：

1、char类型可以存放中文，是以ASCII的形式编码

ASCII ((American Standard Code for Information Interchange): 美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统。

二进制---》10进制---》字符

2、字符类型数据在程序中是以什么形式保存？（字母、标点符号、数字）

--char可以存放中文中文使用了UTF-8编码进行存放

(UNIcode 万国码（16进制编码，在注释中也不能用/u）)

--使用UTF-8形式的编码 ‘\uxxxx’ 比如：中---->'\u4e2d'

基本数据类型实列演示（JAVA）

public class data{
    //提供Java程序的入口 main方法  在java中声明一个变量，必须指定类型
    //1、整型数据默认类型是int   【不能直接将大的赋值给小的】
    public static void main(String[] args){
        //输出语句  java是强语言（类型很重要）  // 错误: 不兼容的类型: 从int转换到byte可能会有损失
        byte b = 18;//-128~127
        short s = 189;//-32768~32767
        int i = 5555;
        long l = 6598649981L;// 错误: 过大的整数: 6598649981
        System.out.println("b="+b);

        //错误: 不兼容的类型: 从int转换到byte可能会有损失
        //不确定性  ：不确定两个变量相加后的结果是多少，所以编译出错
        /*byte item1 = 102;byte item2 = 103;
        byte item3 = item1+item2;
        System.out.println("item3="+item3);*/

        //浮点型：小数类型--单精度--双精度
        //2、浮点型默认是double类型
        float f = 5.65f;// 错误: 不兼容的类型: 从double转换到float可能会有损失
        double d = 4450.66;
        double demo = 5.1E4;//科学计数法
        System.out.println("f="+f);
        System.out.println("demo="+demo);

        //布尔--true|false
        boolean bItem = (2>3);

        //char -单字符   使用单引号'' 使用ASCII码   UNIcode 万国码 
        char cItem = '\u4e2d';
        int iItem = cItem;
        System.out.println("cItem="+cItem); 
    }
}

自动类型提升顺序

小容量的数据类型可以赋值给大容量的数据类型，会自动转换

//基本类型提升的顺序1 ：

byte-->short-->int-->long-->float-->double

//基本类型提升的顺序2 ：

char-->int-->long-->float-->double

强制类型转换

--大容量的数据类型赋值给小容量的数据类型会有类型兼容问题，不能直接赋值，除非通过强制类型转换

语法格式：

类型1 变量a = (类型1) 变量b

类型1 变量a = (类型1) (表达式)

//执行两数相加   表达式中的类型自动提升  先将iItem提升为float
        float result = f+iItem;//114.0f   不兼容的类型: 从float转换到int可能会有损失
        System.out.println("result="+result);

        int item = 156; //0000000... 1001 1100【32位】
        // (转换的类型)变量 156-127=29【不是】【-100】
        // 1001 1100【8位】==-1-64-32-2-1=-100
        byte b = (byte)item;//错误: 不兼容的类型: 从int转换到byte可能会有损失
        System.out.println("b="+b); 

        //浮点数--赋值给整数--小数会被截取掉
        double bItem = 15.66;
        int res = (int)bItem;
        System.out.println("res="+res);//15

ps：基本数据类型转换遵循的原则：

　　1 容量小的类型自动转换成容量大的数据类型，数据类型按照容量大小排序是

　　　　byte,short,char<int<long<float<double; 注意这是是容量大小不是所占字节数

　　2 容量大的数据类型转换成容量小的数据类型时，要加上强制转换符，但是可能造成精度降低，或者溢出。

　　3 有多种数据类型混合运算是，系统将自动所有数据转换成最大的那个类型，然后进行运算。

　　4 实数常量，系统默认为double；

　　5 整数常量，系统默认为int；

运算符的使用

算术运算符 + - * / %

+的作用：实现加法运算，实现字符串的拼接

扩展后的赋值运算符：

注意：扩展后的赋值运算符中包含强制类型转换操作

item += 3;不完全等于item = item +3;

而是等于item = (item的类型)(item +3);

位运算符

左移一位相当于乘一次2,且左移是无符号的，因为一移就会把符号挤掉


        //左移、有符号右移  、无符号右移【双目运算符】
        int x = 5;
        int y = -3;
        int res4 = y<<1;//左移一位,低位补0   0000 0011  --》 0000 1100
        System.out.println(res4);

        int res5 = y>>1;//有符号右移一位,高位补符号位   0000 0011  --》 0000 0001   
        //(-3)1111 1101  --》 1111 1110  ==-2
        System.out.println(res5);

        int res6 = y>>>1;//无符号右移一位,高位补0   (3)0000 0011  --》 (1)0000 0001  
        //(-3)1111 1101  --》 0111 ... 1110  ==大的数值(因为int为32位，中间省略了若干个0 )
        System.out.println(res6);

比较运算符 (> <>= <= == !=）

>：大于，只支持左右两边操作数是数值类型。如果前面变量的值大于后面变量的值，则返回trueo
>=：大于等于，只支持左右两边操作数是数值类型。如果前面变量的值大于等于后面变量的值，则返回trueo
<：小于，只支持左右两边操作数是数值类型。如果前面变量的值小于后面变量的值，则返回true。
> <=：小于等于，只支持左右两边操作数是数值类型。如果前面变量的值小于等于后面变量的值，则返回trueo
> =：等于，如果进行比较的两个操作数都是数值类型，即使它们的数据类型不相同，只要它们
的值相等，也都将返回trueo例如97 = W返回true, 5.0 == 5也返回true。如果两个操作数都是引用类型，那么只有当两个引用变量的类型具有父子关系时才可以比较，而且这两个引用必须指向同一个对象才会返回true。Java也支持两个boolean类型的值进彳亍比较，例如,true = false将返回false

注意：基本类型的变量、值不能和引用类型的变量、值使用==进行比较；boolean类型的变
量、值不能与其他任意类型的变量、值使用=进行比较；如果两个引用类型之间没有父
i子继承关系，那么它们的变量也不能使用==进行比较。

> !=：不等于，如果进行比较的两个操作数都是数值类型，无论它们的数据类型是否相同，只要
它们的值不相等，也都将返回trueo如果两个操作数都是引用类型，只有当两个引用变量的类
型具有父子关系时才可以比较，只要两个引用指向的不是同一个对象就会返回true。

Systern. out. println (" 5 是否大于 4.0： " + (5 > 4.0)); // 输出 true
Systern. out. printin (" 5 和 5.0 是否相等：” + (5 = 5.0)); // 输出 true
System.out.printin ("97 和乜，是否相等：” + (97 = ' a*)) ; // 输出 true
System. out. printIn (rue 和 false 是否相等："+ (true = false)) ; // 输出 false
//创建2个ComparableOperatorTest对象，分别赋给tl和t2两个引用
ComparableOperatorTest tl = new ComparableOperatorTest();
ComparableOperatorTest t2 = new ComparableOperatorTest();
// tl和t2是同一个类的两个实例的引用，所以可以比较
//但tl和t2引用不同的对象，所以返回false
System, out.printin ("tl 是否等于 t2： “ + (tl == t2));
//直接将tl的值赋给t3,即让t3指向tl指向的对象
ComparableOperatorTest t3 = tl;
// tl和七3指向同一个对象，所以返回true
System, out .println ("tl 是否等于 t3： ” + (tl == t3));

逻辑运算符（短路和非短路的概念）

短路与如果前面的表达式为假，则后面不需要在判断，直接短路

短路或前面为真，则直接短路，不执行后面的逻辑判断

短路与非短路的差别

短路只要知道前面第一个结果，后面第二个结果就不用算了。非短路是全部都需要判断

  //逻辑运算符-- 与或非
        非短路的与和或
        if((2>3)|(3<5)){
            System.out.println("结果为true");  
        }

        //短路与
        if((2>3)&&(3<(5/0))){
            System.out.println("短路与结果为:true");  
        }
        //短路或
        if((2<3)||(3<(5/0))){
            System.out.println("短路或结果为:true");  
        }

        if(!(2>3)){//非即为取反
            System.out.println("取反结果为:true");   
        }

三目运算符（三个操作元素，相当于判断语句）

书写格式

(逻辑表达式)?数值1:数值2

解释： 如果表达式为真则赋值数值1，为假则赋值数值2

 //三目运算符：判断语句+赋值语句  
        int score = 86;
        String resscore = score>=60?"及格":"不及格";
        //练习  ： >=90优秀  >=80良好   >=60及格  其余不及格
        String scoreLevel = score>=90?"优秀":(score>=80?"良好":(score>=60?"及格":"不及格"));

        //大于85 A   大于60 B  其余 C  三目运算符的嵌套
        String level = score>85?"A":(score>60?"B":"C");

        System.out.println("resscore="+resscore);
        System.out.println("scoreLevel="+scoreLevel);

自增自减操作

如果自增或自减符号和其他运算符一起操作时，会有顺序的先后：

++在变量的后面，所以先进行算术运算再进行自增操作

++在变量的前面，所以先进行进行自增操作再算术运算


        //自增  自减
        int i = 3;
        //i++;
        //System.out.println("i="+i);
        //当自增和自减与其他运算再同一个表达式时，要注意先后顺序
        //int item = 3+i++;//先进行算术运算，然后在自增
        //int item = ++i+3;//先进行自增，然后在算术运算
        int item = ++i;//包括赋值运算也是要注意顺序
        System.out.println("item="+item);
        System.out.println("i="+i);