Java数据类型
目录
- 注释
- 标识符
- Java中的关键字/保留字
- 变量的本质
- 变量的分类
- 变量的作用域
- 常量(Constant)
- 基本数据类型(primitive data type)
- 整型变量/常量
- 浮点型变量/常量
- 字符型变量/常量
- boolean类型变量/常量
- null常量
注释
为了方便程序的阅读，Java语言允许程序员在程序中写上一些说明性的文字，用来提高程序的可读性，这些文字性的说明就称为注释。 注释不会出现在字节码文件中，即Java编译器编译时会跳过注释语句。 在Java中根据注释的功能不同，主要分为单行注释、多行注释和文档注释。
-
单行注释：使用“//”开头，“//”后面的单行内容均为注释。
-
多行注释： 以“/*”开头以“*/”结尾，在“/*”和“*/”之间的内容为注释，我们也可以使用多行注释作为行内注释。但是在使用时要注意，多行注释不能嵌套使用。
-
文档注释： 以“/**”开头以“*/”结尾，注释中包含一些说明性的文字及一些JavaDoc标签(后期写项目时，可以生成项目的API)
/**
* Welcome类（我是文档注释）
* @author 作者
* @version 1.0
*/
public class Welcome {
//我是单行注释
public static void main(String[] args/*我是行内注释 */) {
System.out.println("Hello World!");
}
/*
我是多行注释！
我是多行注释！
*/
}标识符
标识符是用来给变量、类、方法以及包进行命名的，如Welcome、main、System、age、name、gender等。标识符需要遵守一定的规则：
-
标识符必须以字母、下划线_、美元符号$开头。
-
标识符其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合。
-
Java 标识符大小写敏感，且长度无限制。
-
标识符不可以是Java的关键字。
标识符的使用规范
-
表示类名和接口名的标识符：每个单词的首字母大写，如Man, GoodMan，ArrayList，Iterator。
-
包名所有字母一律小写。例如：cn.itcast.test。
-
常量名所有字母都大写，单词之间用下划线连接。例如：DAY_OF_MONTH。
-
表示变量名和方法名的标识符：第一个单词首字母小写，从第二个单词开始开始每个首字母大写，我们称之为“驼峰原则”，如eat()，eatFood()，lineNumber，getLineNumber。
-
在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。例如使用userName表示用户名，password表示密码。
Java不采用通常语言使用的ASCII字符集，而是采用Unicode这样标准的国际字符集，一个字符占两个字节，不论中文、英文还是其他字符。因此，这里字母的含义不仅仅是英文，还包括汉字等等。但是不建议大家使用汉字来定义标识符！
//合法的标识符格式
int a = 3;
int _123 = 3;
int $12aa = 3;
int 变量1 = 55; //合法，但是不建议使用中文命名的标识符//不合法的标识符格式
int 1a = 3; //不能用数字开头
int a# = 3; //不能包含#这样的特殊字符
int int = 3; //不能使用关键字练习:
/**
* 测试标识符的用法
* @author 作者
*
*/
public class TestIdentifer {
public static void main(String[] args) {
int a123 = 1;
//int 123abc = 2; //数字不能开头
int $a = 3;
int _abc = 4;
//int #abc = 5;
int 年龄 = 18; //可以使用汉字，但是一般不建议
//int class = 2; //关键字不能作为标识符
}
}
Java中的关键字/保留字
Java关键字是Java语言保留供内部使用的，是编程语言里事先定义好并赋予了特殊含义的单词，如class用于定义类。 关键字也可以称为保留字，它们的意思是一样的，Java中保留了许多关键字，我们不能使用关键字作为变量名或方法名。
| Java中的关键字/保留字 | |||||
|---|---|---|---|---|---|
| abstract | assert | boolean | break | byte | case |
| catch | char | class | const | continue | default |
| do | double | else | extends | final | finally |
| float | for | goto | if | implements | import |
| instanceof | int | interface | long | native | new |
| null | package | private | protected | public | return |
| short | static | strictfp | super | switch | synchronized |
| this | throw | throws | transient | try | void |
| volatile | while | ||||
所有的关键字都是小写的。 程序中的标识符不能以关键字命名。
不需要刻意去记！随着学习的深入，自然就非常熟悉了。
变量的本质
变量本质上就是代表一个”可操作的存储空间”，空间位置是确定的，但是里面放置什么值不确定。我们可通过变量名来访问“对应的存储空间”，从而操纵这个“存储空间”存储的值。
变量的定义：在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元称之为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。
Java是一种强类型语言，每个变量都必须声明其数据类型。变量的数据类型决定了变量占据存储空间的大小。 比如，int a=3; 表示a变量的空间大小为4个字节。
变量作为程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储空间。
·变量的声明格式为：
type varName [=value][,varName[=value]...];
//[]中的内容为可选项，即可有可无
数据类型 变量名 [=初始值] [,变量名 [=初始值]…];声明变量：
double salary;
long earthPopulation;
int age;不同数据类型的常量会在内存中分配不同的空间，声明变量的内存示意图:
注意事项
-
每个变量都有类型，类型可以是基本类型，也可以是引用类型.
-
变量名必须是合法的标识符.
-
变量声明是一条完整的语句，因此每一个声明都必须以分号结束.
不提倡这种"一行声明多个变量"风格，逐一声明每一个变量可以提高程序可读性。
int i ,j; // 两个变量的数据类型都是int可以将变量的声明和初始化放在同一行中.
int age = 18;
double e = 2.718281828;变量的分类
从整体上可将变量划分为局部变量、成员变量(也称为实例变量)和静态变量。
| 局部变量、成员变量、静态变量的区别 | |||
| 类型 | 声明位置 | 从属于 | 生命周期 |
| 局部变量 | 方法或语句块内部 | 方法/语句块 | 从声明位置开始，直到方法或语句块执行完毕，局部变量消失 |
| 成员变量 (实例变量) |
类内部，方法外部 | 对象 | 对象创建，成员变量也跟着创建。对象消失，成员变量也跟着消失 |
| 静态变量 (类变量) |
类内部，static修饰 | 类 | 类被加载，静态变量就有效；类被卸载，静态变量消失 |
· 局部变量(local variable)
方法或语句块内部定义的变量。生命周期是从声明位置开始到到方法或语句块执行完毕为止。局部变量在使用前必须先声明、初始化(赋初值)再使用。
public void test() {
int i;
int j = i+5 ; // 编译出错，变量i还未被初始化
}
public void test() {
int i;
i=10;
int j = i+5 ; // 编译正确
}· 成员变量（也叫实例变量 member variable）
方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。如果不自行初始化，它会自动初始化成该类型的默认初始值。
| 实例变量的默认初始值 | |
| 数据类型 | 实始值 |
| int | 0 |
| double | 0.0 |
| char | ‘\u0000’ |
| boolean | false |
public class Test {
int i;
}· 静态变量（类变量 static variable）
使用static定义。从属于类，生命周期伴随类始终，从类加载到卸载。(注：讲完内存分析后我们再深入！先放一放这个概念！)如果不自行初始化，与成员变量相同会自动初始化成该类型的默认初始值。
public class LocalVariableTest {
public static void main(String[ ] args) {
boolean flag = true; // 声明boolean型变量并赋值
char c1, c2; // 声明char型变量
c1 = '\u0041'; // 为char型变量赋值
c2 = 'B'; // 为char型变量赋值
int x; // 声明int型变量
x = 9; // 为int型变量赋值
int y = x; // 声明并初始化int型变量
float f = 3.15f; // 声明float型变量并赋值
double d = 3.1415926; // 声明double型变量并赋值
}
} 练习:
/**
* 测试变量
* @author 作者
*/
public class TestVariable {
int a; //成员变量, 从属于对象； 成员变量会自动被初始化
static int size; //静态变量，从属于类
public static void main(String[] args) {
{
int age1; //局部变量，从属于语句块；
age1 = 18;
}
int salary = 3000; //局部变量，从属于方法
int age2 = 13;
System.out.println(age2);
int i;
// int j = i + 5; // 编译出错，变量i还未被初始化
}
}变量的作用域
变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域便是这个变量的作用域。
public static void main(String[] args){ //x的作用域
int x = 4;
{ //y的作用域
int y = 9;
……
}
……
}常量(Constant)
常量通常指的是一个固定不变的值，是不能改变的数据。例如：1、2、3、’a’、’b’、true、false、”helloWorld”等。
在Java语言中，主要是利用关键字final来定义一个常量。 常量包括整型常量、浮点数常量、布尔常量、字符常量等，一旦被初始化后不能再更改其值。
声明格式为:
final type varName = value;常量的声明及使用:
public class TestConstants {
public static void main(String[] args) {
final double PI = 3.14;
// PI = 3.15; //编译错误，不能再被赋值！
double r = 4;
double area = PI * r * r;
double circle = 2 * PI * r;
System.out.println("area = " + area);
System.out.println("circle = " + circle);
}
}为了更好的区分和表述，一般将1、2、3、’a’、’b’、true、false、”helloWorld”等称为字面常量，而使用final修饰的PI等称为符号常量。
变量和常量命名规范（规范是程序员的基本准则，不规范会直接损害你的个人形象）：
所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则: monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则: Man, GoodMan
方法名：首字母小写和驼峰原则: run(), runRun()
基本数据类型(primitive data type)
Java是一种强类型语言，它对变量的数据类型有严格的限定. 每个变量都必须声明其数据类型, 在为变量赋值时必须赋予和变量同一种类型的值, 否则程序会报错. Java的数据类型可分为两大类: 基本数据类型（primitive data type）和引用数据类型（reference data type）.
Java中定义了3类8种基本数据类型
-
数值型－ byte、 short、int、 long、float、 double
-
字符型－ char
-
布尔型－boolean
数据类型的分类
引用数据类型的大小统一为4个字节，记录的是其引用对象的地址！
整型变量/常量
整型用于表示没有小数部分的数值，它允许是负数。整型的范围与运行Java代码的机器无关，这正是Java程序具有很强移植能力的原因之一。与此相反，C和C++程序需要针对不同的处理器选择最有效的整型。整型分为4种不同的类型:字节型（byte）、短整型（short）、整型（int）和长整型（long）。
占用空间: 不同类型的变量分别占用的内存大小。取值范围:变量存储的值不能超出的范围。
Java 语言整型常量的四种表示形式
-
十进制整数，如：99, -500, 0
-
八进制整数，要求以 0 开头，如：015
-
十六进制数，要求 0x 或 0X 开头，如：0x15
-
二进制数，要求0b或0B开头，如：0b01110011
Java语言的整型常数默认为int型，声明long型常量可以后加‘ l ’或‘ L ’ 。
长整型常数的声明:
long a = 55555555; //编译成功，在int表示的范围内(21亿内)。
long b = 55555555555; //不加L编译错误，已经超过int表示的范围。
//我们修改成long类型的常量即可：
long b = 55555555555L;浮点型变量/常量
带小数的数据在Java中称为浮点型。浮点型可分为float类型和double类型。
| 浮点型数据类型 |
||
| 类型 |
占用存储空间 |
表数范围 |
| float |
4字节(32位) |
-3.403E38~3.403E38 |
| double |
8字节(64位) |
-1.798E308~1.798E308 |
float类型又被称作单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度很难满足需求。而double表示这种类型的数值精度约是float类型的两倍，又被称作双精度类型，绝大部分应用程序都采用double类型。浮点型常量默认类型也是double。
Java浮点类型常量有两种表示形式
-
十进制数形式，例如:3.14 314.0 0.314
-
科学记数法形式，如314e2 314E2 314E-2
使用科学记数法给浮点型变量赋值:
double f = 314e2; //314*10^2-->31400.0
double f2 = 314e-2; //314*10^(-2)-->3.14float类型的数值有一个后缀F或者f ,没有后缀F/f的浮点数值默认为double类型。也可以在浮点数值后添加后缀D或者d, 以明确其为double类型。在程序中也可以为一个浮点数类型变量赋予一个整数数值。
//float类型赋值时需要添加后缀F/f
float f = 3.14F;
double d1 = 3.14;
double d2 = 3.14D;浮点类型float，double的数据不适合在不容许舍入误差的金融计算领域。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。
//浮点数的比较一
float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d); //结果为false
//浮点数的比较二
float d1 = 423432423f;
float d2 = d1+1;
if(d1==d2){
System.out.println("d1==d2"); //输出结果为d1==d2
}else{
System.out.println("d1!=d2");
}运行以上两个示例，发现比较一的结果是“false”，而比较二的输出结果是“d1==d2”。这是因为由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。 浮点数一般都存在舍入误差，很多数字无法精确表示(例如0.1)，其结果只能是接近， 但不等于。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。并不是所有的小数都能可以精确的用二进制浮点数表示。
java.math包下面的两个有用的类：BigInteger和BigDecimal，这两个类可以处理任意长度的数值。BigInteger实现了任意精度的整数运算。BigDecimal实现了任意精度的浮点运算。
不要使用浮点数进行比较 ! 很多新人甚至很多理论不扎实的有工作经验的程序员也会犯这个错误 ! 需要比较请使用BigDecimal类 !
使用BigDecimal进行浮点数的比较:
import java.math.BigDecimal;
public class Main {
public static void main(String[] args) {
BigDecimal bd = BigDecimal.valueOf(1.0);
bd = bd.subtract(BigDecimal.valueOf(0.1));
bd = bd.subtract(BigDecimal.valueOf(0.1));
bd = bd.subtract(BigDecimal.valueOf(0.1));
bd = bd.subtract(BigDecimal.valueOf(0.1));
bd = bd.subtract(BigDecimal.valueOf(0.1));
System.out.println(bd); //0.5
System.out.println(1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1); //0.5000000000000001
}
}浮点数使用总结
-
默认是double类型。
-
浮点数存在舍入误差，数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。
-
避免比较中使用浮点数，需要比较请使用BigDecimal类。
字符型变量/常量
char字符型在内存中占2个字节，在Java中使用英文半角格式的单引号来表示字符常量，存储一个单一字符。例如’A’是一个字符，它与”A”是不同的，”A”表示含有一个字符的字符串。
char 类型用来表示在Unicode编码表中的字符。Unicode编码被设计用来处理各种语言的文字，它占2个字节，可允许有65536个字符。
赋值为0~65535范围内的整数，计算机会自动将这些整数转化为所对应的字符，如数值97对应的字符为'a'。
char eChar = 'a';
char cChar = '中';
char chChar = 97;Unicode具有从0到65535之间的编码，他们通常用从’\u0000’到’\uFFFF’之间的十六进制值来表示（前缀为u表示Unicode）。
字符型的十六进制值表示方法:
char c = '\u0061';转义字符
Java 语言中还允许使用转义字符 ‘\’ 来将其后的字符转变为其它的含义。常用的转义字符及其含义和Unicode值 :
| 转义字符 |
||
| 转义符 |
含义 |
Unicode值 |
| \b |
退格（backspace） |
\u0008 |
| \n |
换行 |
\u000a |
| \r |
回车 |
\u000d |
| \t |
制表符（tab） |
\u0009 |
| \“ |
双引号 |
\u0022 |
| \‘ |
单引号 |
\u0027 |
| \\ |
反斜杠 |
\u005c |
char c2 = '\n'; //代表换行符我们学的String类，其实是字符序列(char sequence)。字符串常量。
/**
* 测试字符类型
* @author 作者
*
*/
public class TestPrimitiveDataType3 {
public static void main(String[] args) {
char a = 'T';
char b = '上';
char c = '\u0061';
System.out.println(c);
//转义字符
System.out.println(""+'a'+'\n'+'b');
System.out.println(""+'a'+'\t'+'b');
System.out.println(""+'a'+'\''+'b'); //a'b
//String就是字符序列
String d = "abc";
}
}
boolean类型变量/常量
boolean类型变量用来存储布尔值，含两个常量值，true和false，在内存中占一位（不是一个字节），不可以使用 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。 boolean 类型用来判断逻辑条件，一般用于程序流程控制 。
boolean flag ;
flag = true; //或者flag=false;
if(flag) {
// true分支
} else {
// false分支
}
请不要这样写：if ( flag == true )，只有新手才那么写。关键也很容易写错成if(flag=true)，这样就变成赋值flag 为true而不是判断！老鸟的写法是if ( flag )或者if ( !flag)
null常量
null常量只有一个值null，表示对象的引用为空。
转载自http://www.sxt.cn/Java_jQuery_in_action/Java_operator.html