CoreJava 数据类型

day2.数据类型

一、变量

概念：变量是内存中的一块空间，是存储数据的基本单元
组成：数据类型、变量名、数据
定义：
1. 声明数据类型变量名;
  
  例如：int a;
2. 赋值 = 数据;
  
  例如：a = 4;
3. 其他方式：
  1. 声明并赋值：数据类型变量名 = 值;
    
    例如：int a = 4;
  2. 数据类型变量名，变量名 = 值，变量名
    
    例如：int a = 10,b = 20,c,d = 5;

package day2;

public class TestVar{
	public static void main(String[] args){
		//变量的声明
		int a;
		//变量的赋值
		a = 4;
		//变量声明的同时赋值
		int b = 3;
		//声明多个变量，同时可以赋值
		//一次声明了三个int类型变量，其中c没有赋值，d和e被赋值
		int c , d = 5 , e = 6;
	}
}

二、数据类型

基本数据类型(简答类型，原始类型)
1. 整数类型
  
  关键字字节数取值范围
  
  byte 1B -128~127
  
  short 2B -32768~32767
  
  int 4B -2147483648~2147483647
  
  long 8B -9223372036854775808~9223372036854775807
  
  注意：当声明数据类型为long的时候，数据后面需要加上l或者L，由于字母l和数字1容易发生混淆，建议使用大写的L字母
```
package day2;

public class Test {
	public static void main(String[] args) {
		//当声明一个long类型的数据之后，需要在数据后标识l或者L
		//使用l之后，和数字1容易混淆
		long a = 2147483648l;
		//建议使用L
		long b = 2147483648L;
	}
}
```
2. 浮点数类型(小数)
  
  关键字字节数精确位
  
  float 4B 7位
  
  double 8B 16位
  
  注意：当声明数据类型为float的时候，数据后面需要加上f或者F。
  
  注意：数据类型double之后应该加上d或者D，但由于浮点数默认为double类型，所以之后的d或D可以省略。
```
package day2;

public class Test {
	public static void main(String[] args) {
		//当声明一个float类型的数据之后，需要在数据后标识f或者F
		float a = 1.0f;
		float b = 2.0F;
	}
}
```
3. 字符类型
  
  关键字 char 字节数 2B
  
  字符类型变量的赋值方式：
  1. char c = 'A';使用单引号引起来一个字符
  2. char c = 65;使用整数去表示一个字符
  3. char c = '\u0041'; 使用unicode去表示一个字符
```
package day2;

public class TestChar {
	public static void main(String[] args) {
		//使用单引号引起来一个字符	
		char a = 'A';//ok
		char b = '我';//ok
		char c = '65';//error!!
		//注意：因为引号中只能写单个字符，注意与第二种声明方式的区别！！
		
		//使用整数去表示一个字符
		char d = 65;//此处的65就代表字符A
		//使用unicode去表示一个字符
		char e = '\u0041';
		//注意：这里使用单引号，中间的数字需要以\u开头，后面必须是四位十六进制数
	}
}
```
  转义字符：
  
  \t 水平跳格
  
  \n 换行
  
  \' 单引号
  
  \" 双引号
  
  \\ 反斜杠
4. 布尔类型
  
  关键字 boolean
  
  布尔类型的字面值只有true和false
  
  重要：Java是强类型语言，声明的数据类型和赋值的类型必须一致

关键字	字节数	取值范围
byte	1B	-128~127
short	2B	-32768~32767
int	4B	-2147483648~2147483647
long	8B	-9223372036854775808~9223372036854775807

关键字	字节数	精确位
float	4B	7位
double	8B	16位

引用数据类型(对象类型，复杂类型)

在Java中，除去8种基本数据类型，其他的数据类型都是引用数据类型

例如：String(字符串)，数组，接口等等

字符串(String)：用双引号""引起来的内容称为字符串

字符串是一个或者多个字符的串联，但他们是一个整体

String s = "hello";

package day2;

public class TestString {
	public static void main(String[] args) {
		//用双引号""引起来的内容称为字符串
		//单个字符用双引号之后就不再是char类型，而是String
		String s1 = "我";
		//多个字符是String最常见的形式
		String s2 = "我爱你";
		//当使用双引号之后，25105不再代表“我”字，而是单纯的数字
		String s3 = "25105";
		//当使用双引号之后，1+1不再计算结果，而是单纯的文本
		String s4 = "1+1";	
	}
}

三、数据类型转换

自动类型提升
1. 两个变量互相可以兼容
2. 将范围较小的变量赋值给范围较大的变量
规则：直接赋值

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

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

注意：由于byte和short具有负数，而char的数字表示没有负数，所以他们之间不能自动类型提升
```
package day2;

public class TestAutoCast {
	public static void main(String[] args) {
		//将范围较小的变量赋值给范围较大的变量
		char a = '我';
		int b = a;
		System.out.println(b);//25105
		
		int c = 123456;
		double d = c;
		System.out.println(d);//123456.0
	}
}
```
强制类型转换
1. 两种数据之间必须能够相互兼容
2. 将范围较大的变量赋值给范围较小的变量
规则：目标数据类型变量名 = (目标数据类型)源数据变量名/源数据值;

强制类型转换可能会导致数据的变化，其可能性如下：
1. 整数与整数之间的转换：整数的长度相互匹配，直接赋值，数据是完整的
2. 整数与整数之间的转换：整数的长度不匹配，数据截断，舍弃高位
3. 整数与浮点数之间的转换：浮点数转整数，数据截断，舍弃小数位
4. 布尔类型不参与转换
```
package day2;

public class TestCast {
	public static void main(String[] args) {
		//整数与整数之间的转换：整数的长度相互匹配，直接赋值，数据是完整的
		int a = 127;
		byte b = (byte) a;
		System.out.println(b);//127
		//整数与整数之间的转换：整数的长度不匹配，数据截断，舍弃高位
		int c = 129;
		byte d = (byte) c;
		System.out.println(d);//-127
		//整数与浮点数之间的转换：浮点数转整数，数据截断，舍弃小数位
		double e = 12.5;
		int f = (int) e;
		System.out.println(f);//12
	}
}
```

四、表达式

概念：由变量、常量、数据、运算符组成的式子，通常会产生一个结果
当两个类型不同的基本数据类型进行数学运算之后，其数据类型的规则如下：
1. 当表达式中有double的时候，结果为double
2. 当表达式中没有double，但是有float的时候，结果为float
3. 当表达式中没有double和float，但是有long的时候，结果为long
4. 当表达式中没有以上三种情况，则结果默认为int类型
  
  int-->long-->float-->double的顺序

五、运算符

算术运算符

包括加 + 、减 - 、乘 * 、除 / 、余（模） %

package day2;

public class TestAdd {
	public static void main(String[] args) {
		//算术运算符
		int a = 3;
		int b = 5;
		int c = a + b;
		System.out.println(c);
		byte d = 3;
		byte e = 4;
		//byte f = d + e;  
		//编译出错，当运算的时候，会将int以下的数据提升为int在做运算，所以结果为int类型
		byte g = (byte) (d + e);
		System.out.println(g);
		
		int i = 5/3;//运算结果先转换为int类型，再存储到变量i中
		System.out.println(i);	
	}
}

赋值运算符

包括包括 = 、 += 、 -= 、 *= 、 /= 、 %=

package day2;

public class TestAdd {
	public static void main(String[] args) {
		int a = 1;
		a += 1;//这句话相当于 a = a + 1;
		System.out.println(a);
		
		byte b = 1;
		b += 1;//自动进行强制类型转换
		System.out.println(b);
	}
}

逻辑运算符

&& 短路与两个表达式的结果都为true则结果为true，如果有false则结果为false

& 非短路与两个表达式的结果都为true则结果为true，如果有false则结果为false

|| 短路或两个表达式的结果有一个为true则结果为true，如果都为false则结果为false

| 非短路或两个表达式的结果有一个为true则结果为true，如果都为false则结果为false

！非表示对表达式的结果取反

短路与非短路的区别：

短路：当前一个表达式已经可以确定结果的时候，不执行后一个表达式

非短路：无论前一个表达式是否可以确定结果，后一个表达式都要执行
```
package day2;

public class TestAnd {
	public static void main(String[] args) {
		int a = 2;
		boolean b = a == 3 && (a +=1) ==2;
		System.out.println(b);//false
		System.out.println(a);//2	因为a +=1没有被执行
		
		int c = 2;
		boolean d = c == 3 & (c +=1) ==2;
		System.out.println(d);//false
		System.out.println(c);//3	因为a +=1得到被执行
	}
}
```

一元运算符

也称自增自减运算符

包括 a++、 ++a、a--、--a
区别：a++是先对值进行使用，然后再自增，++a是先自增再使用自增之后的值

package day2;

public class TestAdd {
	public static void main(String[] args) {
		int a = 1;
		System.out.println(a++);//1
		System.out.println(a);//2
		int b = 1;
		System.out.println(++b);//2
		System.out.println(b);//2
		int c = 1;
		System.out.println(c--);//1
		System.out.println(c);//0
		int d = 1;
		System.out.println(--d);//0
		System.out.println(d);//0
        byte e = 2;
        e++;//此处e的自增结束之后，会自动强转回byte类型
    	System.out.println(e);
	}
}

关系运算符

包括

相等 ==、大于 >、小于 <、大于等于 >=、小于等于 <=、不等于！=
条件运算符

语法：布尔表达式？表达式1：表达式2

解释：当布尔表达式的结果为true的时候执行表达式1，结果为false的时候执行表达式2
```
package day2;

public class TestBoolean {
	public static void main(String[] args) {
		int a = 3;
		boolean c = (a == 3) ? true : false;
		System.out.println(c);
	}
}
```

posted on 2020-11-30 00:25 blueskylabor 阅读(119) 评论(0) 收藏举报

刷新页面返回顶部