第二章基本语法_数据类型

关键字和保留字

关键字

keyword
定义：被Java语言赋予了特殊的含义，用作专门用途的字符串（单词）
特点：所有的关键词都是小写的。
关键字网站：Orcale

保留字

reserved word
现有Java版本尚未使用，但以后版本可能会作为关键字使用。
自己命名标识符时要避免使用这些保留字。
保留字：goto \ const

标识符

定义：Java对各种变量、方法和类等要素命名时使用的字符序列称为标识（zhi）符。
通俗地讲，我们自己起名字的地方都是标识符。
合法标识符的规则：-->如果不遵守规则，会编译不通过。
1. 由26个字母大小写、0-9、_或$符构成。
2. 数字不能开头。
3. 不可以使用关键字和保留字，但是可以包含关键字和保留字。
4. Java中严格区分大小写，长度无限制。
5. 标识符不能包含空格
Java中命名规范：-->如果不遵守规则，编译通过，建议遵守。
1. 包名：多个单词都小写，xxxyyyzzz
2. 类名：大驼峰，XxxYyyZzz
3. 变量名、方法名：小驼峰，xxxYyyZzz
4. 常量名：全大写，XXX_YYY_ZZZ
注意：
1. 命名要有意义，“见名知意”。
2. 标识符可以使用中文，但是不建议。

public class IdentifierTest{
	//变量名、方法名：小驼峰，xxxYyyZzz
	static String userName = "Jon";
	
	//常量名：全大写，XXX_YYY_ZZZ
	static final int USER_ID = 5;
	public static void main(String[] args){
		System.out.println(userName);
		getData();
		System.out.println(USER_ID);
	}
	//变量名、方法名：小驼峰，xxxYyyZzz
	public static void getData(){
		System.out.println("Data");
	}
}

//类名：大驼峰，XxxYyyZzz
class UserTools{
	
}

//由26个字母大小写、0-9、_或$符构成。====编译通过
class A123456_{
	
}

//数字不能开头。====编译失败，第21行，需要标识符
//class 123a{
//	
//}

//不可以使用关键字和保留字，但是可以包含关键字和保留字。====编译失败
//class public{
//	
//}


//不可以使用关键字和保留字，但是可以包含关键字和保留字。====编译通过
class publicAstatic{
	
}


//Java中严格区分大小写，长度无限制。====编译通过
class Static{
	
}

//标识符不能包含空格====编译失败
//class a b{	
//	
//}

变量

变量的概念

内存中一个存储的区域。
改区域的数据可以再同一类型的范围内不断变化。
变量是程序中最基本的存储单元。包含变量类型、变量名、存储的值。

变量的格式

格式：数据类型变量名称 = 变量值;
注意要点：
1. 变量必须先声明、赋值，在使用。
2. 变量定义在作用域内。在作用域内是有效的，出了作用域就无效了。
3. 一个作用域内不能有两个同名的变量。

public class VarTest{

	public static void main(String[] args){
		//变量的声明与赋值
		int myAge = 18;
		System.out.println(myAge);
		
		//编译错误：myClass还没有声明
		//System.out.println(myClass);
		
		//变量的声明
		int myClass;
		//编译错误：myClass还没有被初始化
		//System.out.println(myClass);
		
		myClass = 1;
		System.out.println(myClass);
		//编译错误：myData作用域不在main方法中。
		//System.out.println(myData);
	}
	
	public void getData(){
		int myData = 19961218;
	}

}

数据类型

数据类型的分类-按数据类型

基本数据类型
- 数值型
  - 整数类型：byte、short、int、long
  - 浮点类型：float、double
- 字符型：char
- 布尔型：boolean
引用数据类型
- 类：class
- 接口：interface
- 数组：array

数据类型的分类-按位置

成员变量
局部变量

整形

Java各整数类型有固定的表数范围和字段长度，不收具体OS的影响，以保证java程序的可移植性。

整形分为四种：

byte：1个字节 = 8bit ，范围-128~127
short：2个字节
int：4个字节，常用开发类型，大约21亿
long：8个字节，值后面要加入大写或者小写的L
如果long类型的值不加L，会变成int类型。

public class VarTest1{

	public static void main(String[] args){
		byte b1 = -127;
		byte b2 = 121;
		System.out.println(b1);
		System.out.println(b2);
		
		//编译不通过，超出byte数据范围
		//b2 = 128;
		//System.out.println(b2);
		
		short s1 = 12;
		System.out.println(s1);
		
		int i1 = 1111111;
		System.out.println(i1);
		
		long l1 = 123123123123L;
		System.out.println(l1);
	}
}

浮点型

浮点型分为两种：

float：单精度，4个字节，但是比long类型范围还大，值后面要加F或f；尾数可以精确到7位。
double：双精度，精度是float的两倍，8个字节，开发常用类型。
Float不加F，会编译失败

public class VarTest2{

	public static void main(String[] args){
		//编译错误，float值后面要加大写或者小写F
		//float f1 = 12.2;
		float f1 = 12.2F;
		System.out.println(f1);
		
		double d1 = 12.22222222222;
		System.out.println(d1);
	}
}

字符类型

char类型数据表示通常意义上的“字符”（两个字节）
字符型变量的三种表现形式：

用单引号''括起来的单个字符。
转义字符。
Unicode编码字符。
注意：必须有个值才可以，否则编译失败

public class VarTest3{

	public static void main(String[] args){
		//1.表示一个字符，2个字节
		char c1 = 'A';
		char c2 = '2';
		char c3 = '你';
		char c4 = 'タ';
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(c3);
		System.out.println(c4);
		
		//2.转义字符
		char c5 = '\n';
		System.out.println("Hello"+c5+"World");
		
		//3. UniCode编码
		char c6 = '\u0046';
		System.out.print(c6);
	}
}

布尔类型

boolean，两个值，true或false

public class VarTest4{

	public static void main(String[] args){
		boolean bool = true;
		if(bool){
			System.out.println("已婚");
		}else{
			System.out.println("未婚");
		}

	}
}

基本数据类型转换

前提：这里只讨论基本数据类型的运算。不包括boolean。

自动类型提升

总结：当容量小的数据类型的变量和容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
顺序：byte\short\char --> int --> long --> float --> double
特别的，byte\short\char之间做运算（包括两个一样类型的数据），都会提升为int类型。
说明：容量大小，指的是数据的范围大小，float容量大于long容量

public class VarTest5{

	public static void main(String[] args){
		int i1 = 10;
		byte b1 = 127;
		//编译错误，
		//byte b2 = i1 + b1;
		int i2 = i1 + b1;
		System.out.println(i2);
		
		short s1 = 12;
		//编译错误
		//short s2 = s1 + i1;
		
		long l1 = 1234;
		//编译错误
		//int i3 = i1 + l1;
		long l2 = i1 + l1;
		System.out.println(l2);
		
		float f1 = 12.3f;
		//编译错误
		// long l3 = f1 + l1;
		float f2 = f1 + l1;
		System.out.println(f2);
		
		double d1 = 12.33;
		//编译错误
		//float f3 = d1 +f1;
		double d2 = d1 + f1;
		System.out.println(d2);
		
		char c1 = 'a';//97
		//char 和int做运算
		//编译错误
		//char c2 = c1 +i1;
		int i4 = c1 + i1;
		System.out.println(i4);
		//也就说明char和int做运算，会提升到int，所以插入比int容量小
		
		//char和short作运算
		//会报错，提示int类型
		//char c2 = c1 + s1;
		//short s2 = c1 + s1;
		int i5 = c1 + s1;
		System.out.println(i5);
		//也就是说明char和short作比较会提升到int类型
		
		//char和byte 做运算
		//错误，提示int类型
		//byte b3 = b1 + c1;
		//错误，提示int类型
		//char c3 = b1 + c1;
		int i6 = b1 + c1;
		System.out.println(i6);
		
	}
}

强制类型转换

自动提升的逆运算
注意：强制类型转换可能会损失精度。

public class VarTest6{

	public static void main(String[] args){
		double d1 = 123.999;
		//编译错误
		//int i1 = d1;
		
		int i1 = (int)d1;
		System.out.println(i1);
	}
}

注意

整形常量，默认类型为int类型
浮点型常量，默认类型为double类型

字符串类型String

引用数据类型
声明String类型变量，必须使用一对""
String类型可以与8中基本数据类型做运算，而且只能做连接运算：+
运算后的结构仍然是String类型

public class StringTest{

	public static void main(String[] args){
		String s1 = "Hello World";
		System.out.println(s1);
		
		//连接运算
		String firstName = "Gorry";
		String lastName = "Wang";
		int userId = 123;
		String info = firstName + lastName +":"+userId;
		System.out.println(info);
	}
}

练习

/*
Sting练习
*/
public class StringTest2{

	public static void main(String[] args){
		//练习1
		char c1 = 'a';
		int i1 = 10;
		String s1 = "Hello";
		System.out.println(c1+i1+s1);//107Hello
		System.out.println(c1+s1+i1);//aHello10
		
		//练习2
		//打印*	*
		System.out.println("*	*");//ok
		System.out.println('*' + '\t' + '*');//no
		System.out.println('*' + "\t" + '*');//ok
		System.out.println("*" + '\t' + '*');//ok
	}
}

进制

对于整数，有四种表示方式：

二进制，满二进一，以0b或0B开头。
十进制，满十进一。
八进制，满八进一，以数字0开头。
十六进制，满十六进一，以0x或0X开头。

public class NumTest{
	public static void main(String[] args){
		int i1 = 123;
		int i2 = 0B101;
		int i3 = 0123;
		int i4 = 0X123;
		System.out.println("num1:"+i1);
		System.out.println("num2:"+i2);
		System.out.println("num3:"+i3);
		System.out.println("num4:"+i4);
	}
}

DAY02问题

标识符的命名规则有哪些？

由26个字母大小写、1-9、$、_组成的。
不能数字开头。
不能使用关键字和保留字，但是可以包含。
严格区分大小写。
不可以包含空格
不遵守以上规则会编译报错

标识符的命名规范有哪些？

包名：xxxyyyzzz
类名、接口名：XxxYyyZzz
方法名、变量名：xxxYyyZzz
常量：XXX_YYY_ZZZ
不遵守以上规则编译和运行都会通过。

Java变量按照数据类型怎么划分？并指出Java的基本类型有哪8种，并指出各自占用的内存空间大小。

划分为基本数据类型和引用数据类型
基本数据类型：byte、short、int、long、float、double、char、boolean
byte（1字节）
short（2字节）
char（2字节）
int（4字节）
long（8字节）
float（4字节）
double（8字节）
boolean（true和false，最后会转换成int类型，4字节）

说明基本数据类型变量之间自动提升的运算规则。

前提不包含boolean
byte、short、char→int→long→float→double

说明基本数据类型之间强制转换的使用规则和墙砖可能出现的问题。

使用规则：强转符，值前面使用：(转换的变量类型)
出现的问题：可能会损失值得精度。

本文由 Gorrywang 创作，严禁转载与复制！
最后编辑时间为: Jul 25,2020