Java知识点（一）：变量、八种数据类型、基本数据类型转换

---

Java语言基础

包含java变量（声明、命名、初始化、使用、作用域）；八种数据类型以及基本数据类型中的转换（byte字节型、short短整型、int整数类型、long长整数类型、float单精度浮点型、double双精度浮点型、char字符类型、boolean布尔型）。

---

一、变量

存数的，用于指代内存中的一块存储区域，指代的就是它所存的那个数；变量必须有特定的数据类型，不同的数据类型表示不同的数据存储结构

1.1、声明

变量使用前必须声明，指明其类型

package day01;  // 声明包day01

public class HelloWorld {  // 声明类HelloWorld

	// 主方法，程序入口
	// 程序的执行从main开始，main结束则程序结束
	public static void main(String[] args) {
		int a;  // 声明一个整型变量，名为a
        int b,c,d;  // 声明三个整型变量，名为b，c，d
	}
}

1.2、命名

1）只能包含字母、数字、_和$符，并且不能以数字开头

package day01;

public class Test {
	public static void main(String[] args) {
		int DE = 3;
		int se = 3;
		int _$ = 3;
//		int 3a = 3; //编译错误
	}
}

2）严格区分大小写

package day01;

public class Test {
	public static void main(String[] args) {
		int a = 3;  // 声明整型变量a，并赋值为3
		int A = 3;  // 声明整型变量A，并赋值为3
	}
}

3）不能使用关键字

package day01;

public class Test {
	public static void main(String[] args) {
		int a = 3;
//		int public = 3;  // 编译错误
	}
}

4）可以中文命名，但不建议；建议“见名知意”、驼峰命名法（变量多个：第一个首字母小写，其余大写）

package day01;

public class Test {
	public static void main(String[] args) {
		int age = 3;
		int studyTime = 200;
		int 这是 = 3;
	}
}

1.3、初始化

java变量在使用前必须初始化，第一次赋值

1）声明的同时初始化：

package day01;

public class Test {
	public static void main(String[] args) {
		int a = 100;  // 声明整型变量a并赋值为100
	}
}

2）先声明后初始化：

package day01;

public class Test {
	public static void main(String[] args) {
		int a;  // 声明整型变量a
		a = 100;  // 给变量a赋值为100
	}
}

1.5、使用

1）必须与数据类型匹配

package day01;

public class Test {
	public static void main(String[] args) {
//		int a = 3.1415;  // 编译错误，数据类型不匹配
	}
}

2）对变量的操作就是对它所存的那个数的操作

package day01;

public class Test {
	public static void main(String[] args) {
		int a = 5;  // 声明整型变量a并赋值为5
		int b = a + 10;  // 取出a的值5，加10后，在赋值给b
		a = a + 10;  // 取出a的值5，加10后，在赋值给a
		
		System.out.println(a);  // 输出a的值15
		System.out.println("a");  // a，原样输出
	}
}

3）变量在用之前必须声明并初始化

package day01;

public class Test {
	public static void main(String[] args) {
//		System.out.println(m); //编译错误，m未声明
		int m;
//		System.out.println(m); //编译错误，m未初始化
		m = 100;
		
		System.out.println(m); //输出m的值100
	}
}

1.6、作用域

java变量存在范围，运行超出范围后，变量所占空间将被收回；同名变量，作用域不能重叠

package day01;

public class Test {
	public static void main(String[] args) {
		int a = 10;
		for(int i=0;i<10;i++) {
//			int a = 10;  // 编译错误，同名变量作用域重叠
		}

		for(int i=0;i<10;i++) {
			System.out.print(i);
		}
//		System.out.print(i);  // 编译错误，超出作用域

		for(int i=0;i<10;i++) {
			int b = 10;
		}
		int b = 10;  // 正确
	}
}

二、数据类型

八种基本数据类型

类型名称	字节大小	说明
byte	1字节（8位）	存储1个字节数据
short	2字节（16位）	兼容性考虑，很少使用
int	4字节（32位）	存储整数（常用）
long	8字节（64位）	存储长整数（常用）
float	2字节（32位）	存储浮点数
double	8字节（64位）	存储双精度浮点数
char	2字节（16位）	存储1个字符
boolean	1字节（8位）	存储true、false

2.1、byte——字节型

byte（8位）：字节型，1个字节，-128~127

package day01;

public class Test {
	public static void main(String[] args) {
		byte b1=5,b2=6;
		byte b3=(byte)(b1+b2);
		
		System.out.print(b3);  // 结果为11
	}
}

2.2、short——短整型

short（16位）：短整型，2个字节，-32768~32767

package day01;

public class Test {
	public static void main(String[] args) {
		short a = 300;
//		short b = 32768;  // 编译错误
	}
}

2.3、int——整数类型

int（32位）：整型类型，4个字节，-2147483648~2147483647

1）直接量，即直接写出的常量。整数的直接量默认为int类型，不能超出范围，否则会编译错误

package day01;

public class Test {
	public static void main(String[] args) {
//		int a = 1000000000;  // 编译错误，超出范围
	}
}

2）两个整数相除，结果还是整数，小数位无条件舍弃

package day01;

public class Test {
	public static void main(String[] args) {
		int a = 3/2;
		
		System.out.println(a);  // 结果为1
	}
}

3）运算时超出范围会发生溢出，溢出是需要避免的

package day01;

public class Test {
	public static void main(String[] args) {
		int a = 2000000000;
		int b = 2000000000;
		
		System.out.println(a+b);  // 结果为-294967296，溢出
	}
}

2.4、long——长整数类型

long（64位）：长整型，8个字节，-9223372036854774808~9223372036854774807

1）长整型直接量为在数字后加L或l

package day01;

public class Test {
	public static void main(String[] args) {
		long a=100000000000L;
	}
}

2）算数运算时有可能超出范围，建议在第1个数字后面加L

package day01;

public class Test {
	public static void main(String[] args) {
		long a=1000000000*3*10L;
//		System.out.println(g);  // 溢出

		long b=1000000000L*3*10;
		System.out.println(b);  // long类型，输出300亿
	}
}

3）System.currentTimeMillis()用于获取自1970.1.1零时到此时此刻所经历的毫秒数

package day01;

public class Test {
	public static void main(String[] args) {
		long times=System.currentTimeMillis();
		
		System.out.println(times);  // 1680342363097
	}
}

2.5、float——单精度浮点型

float（32位）：单精度浮点型，4个字节，表示float型需要加F或f

package day01;

public class Test {
	public static void main(String[] args) {
		float = 3.14F;
	}
}

2.6、double——双精度浮点型

double（64位）：双精度浮点型，8个字节

1）浮点数直接量默认为double型

package day01;

public class Test {
	public static void main(String[] args) {
		double a = 3.14;
	}
}

2）double型数据运算时，可能会发生舍入误差

package day01;

import java.math.BigDecimal;  // 用来对超过16位有效位的数进行精确的运算

public class Test {
	public static void main(String[] args) {
		double a = 3.0;  // 双精度浮点型变量double可以处理16位有效数
		System.out.println(a-2.9);  // 0.10000000000000009
		
		BigDecimal num1 = new BigDecimal("3.0");  // BigDecimal的初始化时尽量使用String
		BigDecimal num2 = new BigDecimal("2.9");
		
		// 加法
		BigDecimal result1 = num1.add(num2);
		System.out.println("num1 + num2 = " + result1);
		
		// 减法
		BigDecimal result2 = num1.subtract(num2);
		System.out.println("num1 - num2 = " + result2);
		
		// 乘法
		BigDecimal result3 = num1.multiply(num2);
		System.out.println("num1 * num2 = " + result3);
		
		// 除法（保留20位小数）
		// ROUND_HALF_UP：向“最接近的”数字四舍五入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式
		BigDecimal result4 = num1.divide(num2,20,BigDecimal.ROUND_HALF_UP);
		System.out.println("num1 / num2 = " + result4);
	}
}

注：如需要进行精确计算，可以使用BigDecimal

2.7、char——字符类型

char（16位）：2个字节，字符类型事实上是一个16位无符号整数，对应的是字符编码

1）采用Unicode字符集编码，Unicode是世界通用的定长字符集，每个字符（char）都有一个对应的码（int），表现形式为char字符，实质上是int码

package day01;

public class Test {
	public static void main(String[] args) {
		char c7=65;
		
		System.out.println(c7);  // A
	}
}

2）字符必须放在单引号中，有且仅有一个

package day01;

public class Test {
	public static void main(String[] args) {
		char c1='女';
		char c2='f';
		char c3='6';
		char c4=' ';
//		char c5='中国';  // 编译错误，单引号内只能包含一个字符
//		char c6='';  // 编译错误，单引号内必须有值
	}
}

3）特殊符号需要通过\来转义，如：‘\n’‘\t’‘\’‘\b’‘\r’‘/'’‘"’‘\u4e2d’

package day01;

public class Test {
	public static void main(String[] args) {
		char c8='\\';
		
		System.out.println(c8);  // \
	}
}

4）数字编码：‘0’:48，‘1’:49…

package day01;

public class Test {
	public static void main(String[] args) {
		char a = 48;
		char b = 49;

		System.out.println(a);  // 0
		System.out.println(b);  // 1
	}
}

5）英文编码：‘A’:65，‘B’:66…

package day01;

public class Test {
	public static void main(String[] args) {
		char a = 65;
		char b = 66;
		
		System.out.println(a);  // A
		System.out.println(b);  // B
	}
}

6）字符是整数，可以参运算

package day01;

public class Test {
	public static void main(String[] args) {
		char a = 'A' + 1;
		
		System.out.println(a);  // B
	}
}

2.8、boolean——布尔型

boolean（8位）：布尔型，1个字节，只能取值为true和false

package day01;

public class Test {
	public static void main(String[] args) {
		boolean b1 = true;
		boolean b2 = false;
//		boolean b3 = 250;  // 超出取值范围
		
		System.out.println(b1);  // true
		System.out.println(b2);  // false
	}
}

三、基本类型间的转换

类型从小到大依次为：byte，short（char），int，long，float，double

1）自动类型转换：从小类型到大类型可以自动完成

2）强制类型转换：从大类型到小类型需要强制转换，强转有可能会溢出和精度丢失

package day01;

public class Test {
	public static void main(String[] args) {
		long a = 1024L * 1024 * 1024 * 4;
		int b = (int)a;  // 会造成溢出！结果为0
		double pi = 3.1415926535;
		float f = (float)pi;  // 会造成精度丢失，结果为3.1415927
		
		System.out.println(b);  // 0
		System.out.println(f);  // 3.1415927
	}
}

3）整数直接量可以直接赋值给byte，short，char，但不能超范围

package day01;

public class Test {
	public static void main(String[] args) {
		byte a = 2;
		short b = 2000;
		char c = 65;
	}
}

4）byte，short，char型变量参与运算时，先一律转为int再运算

package day01;

public class Test {
	public static void main(String[] args) {
		byte b1=5,b2=6;
		byte b3=(byte)(b1+b2);
		
		System.out.println(b3);  // 11
	}
}

注：b1+b2实际为5+6，整型相加默认为int型，而b3为byte型，所以需要强转

---