数据类型与运算符

目录

一、八种基础数据类型

二、字符串类型变量

三、理解类型的转换

四、运算符

五、小结

---

一、八种基础数据类型

类型	基本类型	字节大小	包装类	数值大小
整型	byte	1	Byte	-2^7~2^7-1
	short	2	Short	-2^15~2^15-1
	int	4	Integer	-2^31~2^31-1
	long	8	Long	-2^63~2^63-1
浮点型	float	4	Float	3.4e-38~3.4e38
	double	8	Double	1.7e-308~1.7e308
字符型	char	2	Character
	boolean	无明确	Boolean	true，flase

它们在代码中定义且初始化的格式是：

        byte  aa=15;     //Byte
        short ab=15;     //Short
        int   ac=15;     //Integer **-**
//        int  12a=5;    这样会报错，因为标识符不能作为命名的开头，且这样的命名不符合规范  标识符是：数字，字母，下划线，美元符号
//        int aaa;
//        System.out.println(aaa);  报错：因为没有对变量aaa进行初始化
        long  ad=15L;    //Long      long类型的数据后面要加  L 或l
        float ae=15.0f;  //Float     float类型的数据后面要加 F 或f，否则编译不通过，因为系统把它判定为double类型的数据
        double af=15.0;  //Double
        char ag='A';     //Character **-**
        boolean ah=true; //Boolean   Boolean 类型只有两个变量 true 和 flase ，Java中不能用数字去表示Boolean值

这里提到了变量和常量：变量是在程序运行的时候，可以改变的量；常量是在程序运行过程中，不可以改变的量，常量只能初始化一次；且不管是常量或者是变量，在使用的时候，一定要给它初始化。

单位换算有：

                bit   Byte   KB   MB   GB TM PB

单位换算：     8bit =  1 Byte  

                       1KB= 1024Byte

                       1MB= 1024KB

                        GB=1024MB

这里我们看见除了bit和Byte是用8转换，其余都是1024转换。这样也方便我们记忆。

其中位存放一位二进制数，即0或1，为最小的存储单位。

一个英文字母（不分大小写）占一个字节的空间；

一个中文汉字占两个字节的空间；

英文标点占一个字节；

中文标点占两个字节；

 

常用的浮点类型是double，它和float的关系是：

1.单精度浮点型（float ）专指占用32位存储空间的单精度（single-precision ）值。单精度在一些处理器上比双精度更快而且只占用双精度一半的空间，但是当值很大或很小的时候，它将变得不精确。当你需要小数部分并且对精度的要求不高时，单精度浮点型的变量是有用的。

例如，当表示美元和分时，单精度浮点型是有用的。

2、双精度型（double ）浮点型

双精度型，正如它的关键字“double ”表示的，占用64位的存储空间。在一些现代的被优化用来进行高速数学计算的处理器上双精度型实际上比单精度的快。

所有超出人类经验的数学函数，如sin( )，cos( ) ，tan()和sqrt( )均返回双精度的值。当你需要保持多次反复迭代的计算的精确性时，或在操作值很大的数字时，双精度型是最好的选择。

二、字符串类型变量

基本语法格式：

//创建一个字符串str，为hello
String str="hello";

注意事项：

1.java使用双引号+若干字符的方式表示字符串字面值。

2.和上面类型不同，String不是基本类型，而是引用类型。

3.字符串中的一些特定的不太方便直接表示的字符需要转义。

 

转义示例：

//创建一个字符串My name is "熊猫"
String name ="My name is \"张三\""；

 

转义字符	解释
\n	换行
\t	水平制表符
\'	单引号
\"	双引号
\\	反斜杠

 

字符串的拼接操作：

        String str="hello";
        int  a=5;
        int  b=6;
        //连接用+号连接，这里的a也转换成了字符串格式
        String str1=str+a;
        String str2=str+a+b;
        String str3=str+(a+b);
        System.out.println(str1);//这里打印的结果是：hello5
        System.out.println(str2);//这里打印的结果是:hello56
        System.out.println(str3);//这里打印的结果是:hello11
        //还可以这样拼接字符串
        System.out.println("a="+a+" b="+b);//这里打印的结果是 a=5 b=6
        System.out.println(str+"world");
        System.out.println(a+b);

以上代码说明，当一个+表达式存在在字符串的时候，都是执行字符串的拼接操作。

变量的作用域问题：

        //这里的定义就要涉及到作用域的问题了
        {
//        int a=5;   //因为外面已经定义了a,所以此区域类无法定义a
            a=10;
            System.out.println(a);
        }
        System.out.println(a); //这里值也为10,因为上面区域已经改变了它原有的值
        {
            int  c=10;
        }
//    System.out.println(c);//这里无法编译,因为只在区域内声定义且初始化了c,而大区域中没有变量c的定义以及初始化

对变量的要求:

硬性：

1.一个变量不能只包含数字，字母，下划线。

2.数字不能开头。

2.变量名是大小写敏感的，即num和Num是两个不同的变量

软性：

1.变量名最好是和这个变量相关的，因为图中都是在举例，所以变量名就近取了，但是在实际的项目中，变量名好认知能节约我们的时间。

2.变量名不宜使用拼音。

3.变量名的词性推荐使用名词。

4.变量名推荐小驼峰命名法，即当一个变量名由多个单词构成的时候，除了第一个单词之外，其他单词首字母都大写。

小驼峰示例：

int maxNum=100;
String studentName="小明";

int 和String之间的相互转化：

    /*
    String类型如何转换成int类型，int类型又如何转换为String类型
     */
        int num=15;
        //两种方法：
        //1.利用空字符串，让整个结果变为String类型；
        //2.利用函数String。valueOf(int i)，可以实现从字符串类型到整型的转换
        String str4=""+num;
        String str5=String.valueOf(num);
        System.out.println(str5);//打印的值是：15

        String str6="15";
        //利用函数Integer。valueOf(String str)，可以实现从整型到字符串类型的转换
        int num1=Integer.valueOf(str6);
        System.out.println(str6);//打印的值是：15

三、理解类型的转换

Java作为一个强类型编程语言，当不同类型之间的变量互相赋值的时候，会有较严格的校验。

 /*
    不同整型之间的类型转换，Java作为强类型编程语言，当不同类型之间的变量相互赋值的时候，会有严格的校验
    这种校验，对于小的转换成大的类型，称为隐式转换；对于大的转换成小的类型，往往会出现精度丢失这种情况，强制换这个方式可以实现大转小，也被称为显示转换
     */
        int a1=10;
        long b1=a;
        int c1=(int)b1;  //通过使用强转，编译可以通过
        double d1=1.5;
        a1= (int) d1;    //通过强转，编译可以通过
        System.out.println(a1);//打印的结果是：1；强转会丢失精度，小数点后面的部分被忽略
        boolean e1=true;
//    a1=e1;           //编译不通过，互不相干的类型无法强转****

这种校验，对于小的转换成大的类型，称为隐式转换；对于大的转换成小的类型，往往会出现精度丢失这种情况，强制换这个方式可以实现大转小，也被称为显示转换。

其中byte具有相对的特殊性：

/*
    byte等短字节型的特殊性
     */
        byte a2=2;
        byte a3=3;
//    byte a4=a2+a3;//编译不通过，因为a2+a3的值是int型，提升这里会可能会有损失
        //那这里为什么两个byte类型的相加，会成为一个int值呢？
        //这里是因为计算机cpu每次4个字节进行存取数据，而byte只有一个字节，所以就会把byte进行类型的提升，提升到int类型，然后进行相关运算，所以最终的结果自然是int类型
        //这里不光是byte类型有这个自动提升类型，short也有
        short a22=2;
        short a23=3;
//    short a24=  (a22+a23); //编译不通过，和byte发生的是一样的问题
        //这里的解决方法是:通过强转换
        byte a4= (byte) (a2+a3);
        short a24= (short) (a22+a23);
        //这里会有一个新的问题：
        byte a5=100; //编译通过
//    byte a6=  256;// 这里编译也会不通过，因为byte的值是-128~127，这里给的数字已经超出byte的值
        byte a6= (byte) 128;
        System.out.println(a6);//运行结果：-128，通过强转，程序可以运行，且超出的值会成为一个从负最大开始的值

四、运算符

1.算术运算符

//算术运算符：基本四则运算法则 +  -  *  /  %（取余）
        //笔算或者是心算，被取余的数若是正数，则结果就为0或者正数
        //被取余的数若是负数，则结果就为0或负数
        System.out.println(10%3);    //结果是1
        System.out.println(-10%3);   //结果是-1
        System.out.println(10%-3);   //结果是1
        System.out.println(-10%-3);  //结果是-1
        //double类型的也可以取余
        System.out.println(11.5%2.0);//结果是1.5


        //因为5/2一般都是按整型去计算，小数都被忽略
        System.out.println(5/2);  //结果是2
        System.out.println(5.0/2);//结果是2.5
        System.out.println(5/(float)2);//结果是2.5
        System.out.println((float) 5/2);//结果是2.5
        //只是后面改为double类型，计算时仍按照整型去计算
        System.out.println((double) (5/2));//结果是2.0

        //增量赋值运算符：+= -= *= /= %=
        int a7=10;
        a7+=2;  //即a7=a7+2
        System.out.println(a7);//结果是12

        //自增自减运算符： ++  --
        int a8=1;
        int a9=++a8; //a9=2
        int a10=a8++;//a10=2
        System.out.println(a9+"    "+a10);
        System.out.println(a8);//结果为3

0不能作为除数，否则编译不通过。

2.关系运算符

        //关系运算符： == >= <= > < !=
        //关系运算符的表达式返回值都是boolean类型
        int a11=1;
        int a12=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

3.逻辑运算符

        //逻辑运算符： && || !
        //逻辑运算符的操作数（往往是关系运算符的结果）和返回值都是boolean
        //规则：  A && B 两个操作数都为真时，结果为真       （逻辑与）
        //       A||B两个操作数其中一个为真，结果为真       （逻辑或）
        //       ！A操作数为真时结果为假，操作数为假时结果为真（逻辑非）

        int a13=1;
        int a14=2;
        int a15=3;
        System.out.println(a13>a14 && a14>a15);//结果为false
        System.out.println(a13<a14 || a13>a15);//结果为true
        System.out.println(!(a13<a14));//结果为false
        //---------短路求值--------

        //当操作数为boolean的时候，如果之间用  & or |时，也表示逻辑运算，但是它们不支持短路求值

        System.out.println(a13>a14 && a13/0==0 );//按道理后面的除以0，编译不会通过，但是因为实际上，当判断值已经为假时，无需计算右侧表达式
        System.out.println(a13<a14 || a14/0==0);//按道理后面的除以0，编译不会通过，但是因为实际上，当判断值已经为真时，无需计算右侧表达式

4.位运算符

        //位运算符： & | ~ ^
        //java中对操作的操作的最小单位不是字节，而是二进制，位操作表示按二进制位运算
        // &：按位与     |：按位或     ~：取反     ^：异或
        //&:如果两个二进制位都是1.则结果为1.否则结果为0.
        //|:如果两个二进制位都是0,则结果为0,否则结果为1.
        // ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0
        //^:如果两个数字的二进制位相同,则结果为0,相异则结果为1.
        int a16=1;
        int a17=2;
        System.out.println(a16 & a17);//结果为0   01  & 10
        System.out.println(a16 | a17);//结果为3   01  | 10

5.移位运算

        //移位运算:  << >> >>>
        //左移<<:最左侧位不要，最右侧添0
        //右移>>:最右侧位不要，最左侧补符号位（正数补0，负数补1）
        //无符号右移>>>:最右侧位不要，最左侧补0

        int a18=0x15;
        System.out.printf("%x\n",a18<<1);//运行结果为  2a  (结果为16进制的数)
        System.out.printf("%x\n",a18>>1);//运行结果为   a
        System.out.printf("%x\n",a18>>>1);//运行结果为  a
        //1.左移1位，相当于原数字*2，左移N位，相当于原数字*2的N次方。
        //2.右移1位，相当于原数字/2，右移N位，相当于原数字/2的N次方。
        //3.由于计算机计算移位效率高于计算乘除，当某个代码正好乘除2的N次方的时候可以用移位运算代替。
        //4.移动负数位或者移位位数过大都没有意义。

6.条件运算符

即表达式1如果成立，就执行表达式2，否则执行表达式3。

        //条件运算符：  表达式1？表达式2：表达式3
        //也被称为三目运算符

        int a19=10;
        int a20=20;
        int maxM =a>b? a:b;

7.运算符的优先级

运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号即可。

五、小结

熟悉八大基本数据类型的字节数、包装类、数值范围，对String类也要很熟悉，后面很多时候都会用到String类的方法去打印结果，去结合字符串和其他类型的数据，隐式类型转换和显式类型也是需要我们去注意的，在混用类型的计算中，规避因为类型提升带来的一系列的问题，混用类型一般不推荐。在运算符这块，掌握并能熟练应用这6种运算符，以及了解之间的优先级，能区分前置自增和后置自增之间的区别，像&&这类的运算操作时必须是boolean类型，不能用非零或为0的数去取代true和flase；要区分清楚当什么情况下&、|能代替逻辑运算的功能。同时，在代码前面写注释，不管是对于初学者还是程序员来说，都能更清楚的知道这行代码的功能。