Java基础篇（中）

4、java 关键字

下面列出了 java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。

类别	关键字	说明
访问控制	private	私有的
	protected	受保护的
	public	公共的
类、方法和变量修饰符	abstract	声明抽象
	class	类
	extends	扩充,继承
	final	最终值,不可改变的
	implements	实现（接口）
	interface	接口
	native	本地，原生方法（非 java 实现）
	new	新,创建
	static	静态
	strictfp	严格,精准
	synchronized	线程,同步
	transient	短暂
	volatile	易失
程序控制语句	break	跳出循环
	case	定义一个值以供 switch 选择
	continue	继续
	default	默认
	do	运行
	else	否则
	for	循环
	if	如果
	instanceof	实例
	return	返回
	switch	根据值选择执行
	while	循环
错误处理	assert	断言表达式是否为真
	catch	捕捉异常
	finally	有没有异常都执行
	throw	抛出一个异常对象
	throws	声明一个异常可能被抛出
	try	捕获异常
包相关	import	引入
	package	包
基本类型	boolean	布尔型
	byte	字节型
	char	字符型
	double	双精度浮点
	float	单精度浮点
	int	整型
	long	长整型
	short	短整型
变量引用	super	父类,超类
	this	本类
	void	无返回值
保留关键字	goto	是关键字，但不能使用
	const	是关键字，但不能使用
	null	空

 

5、java 变量类型

java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：

byte 数据类型是8位、有符号的，以二进制补码表示的整数；

最小值是 -128（-2^7）；

最大值是 127（2^7-1）；

默认值是 0；

byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；

例子：byte a = 100，byte b = -50。

short：

short 数据类型是 16 位、有符号的以二进制补码表示的整数

最小值是 -32768（-2^15）；

最大值是 32767（2^15 - 1）；

short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；

默认值是 0；

例子：short s = 1000，short r = -20000。

int：

int 数据类型是32位、有符号的以二进制补码表示的整数；

最小值是 -2,147,483,648（-2^31）；

最大值是 2,147,483,647（2^31 - 1）；

一般地整型变量默认为 int 类型；

默认值是 0 ；

例子：int a = 100000, int b = -200000。

long：

long 数据类型是 64 位、有符号的以二进制补码表示的整数；

最小值是 -9,223,372,036,854,775,808（-2^63）；

最大值是 9,223,372,036,854,775,807（2^63 -1）；

这种类型主要使用在需要比较大整数的系统上；

默认值是 0l；

例子： long a = 100000l，long b = -200000l。

"l"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

float 数据类型是单精度、32位、符合ieee 754标准的浮点数；

float 在储存大型浮点数组的时候可节省内存空间；

默认值是 0.0f；

浮点数不能用来表示精确的值，如货币；

例子：float f1 = 234.5f。

double：

double 数据类型是双精度、64 位、符合ieee 754标准的浮点数；

浮点数的默认类型为double类型；

double类型同样不能表示精确的值，如货币；

默认值是 0.0d；

例子：double d1 = 123.4。

boolean：

boolean数据类型表示一位的信息；

只有两个取值：true 和 false；

这种类型只作为一种标志来记录 true/false 情况；

默认值是 false；

例子：boolean one = true。

char：

char类型是一个单一的 16 位 unicode 字符；

最小值是 \u0000（即为0）；

最大值是 \uffff（即为65,535）；

char 数据类型可以储存任何字符；

例子：char letter = 'a';。

自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级。

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

01.不能对boolean类型进行类型转换。

02. 不能把对象类型转换成不相关类的对象。

03. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

04. 转换过程中可能导致溢出或损失精度，例如：

int i =128;   

byte b = (byte)i;

因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

05. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

(int)23.7 == 23;        

(int)-45.89f == -45

自动类型转换

必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

强制类型转换

01.条件是转换的数据类型必须是兼容的。

02.格式：(type)value type是要强制类型转换后的数据类型

隐含强制类型转换

01.整数的默认类型是 int。

02.浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 f 或者 f。

在java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：

type identifier [ = value][, identifier [= value] ...] ;

格式说明：type为java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。

以下列出了一些变量的声明实例。注意有些包含了初始化过程。

 1 int a, b, c;         // 声明三个int型整数：a、 b、c
 2 
 3 int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
 4 
 5 byte z = 22;         // 声明并初始化 z
 6 
 7 string s = "runoob";  // 声明并初始化字符串 s
 8 
 9 double pi = 3.14159; // 声明了双精度浮点型变量 pi
10 
11 char x = 'x';        // 声明变量 x 的值是字符 'x'。

 

java语言支持的变量类型有：

类变量：独立于方法之外的变量，用 static 修饰。

实例变量：独立于方法之外的变量，不过没有 static 修饰。

局部变量：类的方法中的变量。

实例

 1 public class variable{
 2 
 3     static int allclicks=0;    // 类变量
 4 
 5     string str="hello world";  // 实例变量
 6 
 7     public void method(){
 8 
 9         int i =0;  // 局部变量
10 
11     }
12 
13 }

 

java 局部变量

局部变量声明在方法、构造方法或者语句块中；

局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；

访问修饰符不能用于局部变量；

局部变量只在声明它的方法、构造方法或者语句块中可见；

局部变量是在栈上分配的。

局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

实例 1

在以下实例中age是一个局部变量。定义在pupage()方法中，它的作用域就限制在这个方法中。

 1 package com.runoob.test;
 2 
 3 public class test{
 4 
 5    public void pupage(){
 6 
 7       int age = 0;
 8 
 9       age = age + 7;
10 
11       system.out.println("小狗的年龄是: " + age);
12 
13    }
14 
15    public static void main(string[] args){
16 
17       test test = new test();
18 
19       test.pupage();
20 
21    }
22 
23 }

以上实例编译运行结果如下:

小狗的年龄是: 7

 

实例 2

在下面的例子中 age 变量没有初始化，所以在编译时会出错：

 1 package com.runoob.test;
 2 
 3 public class test{
 4 
 5    public void pupage(){
 6 
 7       int age;
 8 
 9       age = age + 7;
10 
11       system.out.println("小狗的年龄是 : " + age);
12 
13    }
14 
15    public static void main(string[] args){
16 
17       test test = new test();
18 
19       test.pupage();
20 
21    }
22 
23 }

以上实例编译运行结果如下:

test.java:4:variable number might not have been initialized

age = age + 7;

         ^

 

实例变量

实例变量声明在一个类中，但在方法、构造方法和语句块之外；

当一个对象被实例化之后，每个实例变量的值就跟着确定；

实例变量在对象创建的时候创建，在对象被销毁的时候销毁；

实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；

实例变量可以声明在使用前或者使用后；

访问修饰符可以修饰实例变量；

实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；

实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；

实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：obejectreference.variablename。

实例

employee.java 文件代码：

import java.io.*;

public class employee{

   // 这个实例变量对子类可见

   public string name;

   // 私有变量，仅在该类可见

   private double salary;

   //在构造器中对name赋值

   public employee (string empname){

      name = empname;

   }

   //设定salary的值

   public void setsalary(double empsal){

      salary = empsal;

   }  

   // 打印信息

   public void printemp(){

      system.out.println("名字 : " + name );

      system.out.println("薪水 : " + salary);

   }

   public static void main(string[] args){

      employee empone = new employee("runoob");

      empone.setsalary(1000);

      empone.printemp();

   }

}

以上实例编译运行结果如下:

$ javac employee.java

$ java employee

名字 : runoob

薪水 : 1000.0

 

类变量（静态变量）

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。

无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。

静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。

静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。

静态变量在第一次被访问时创建，在程序结束时销毁。

与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。

默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。

静态变量可以通过：classname.variablename的方式访问。

类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

实例：

employee.java 文件代码：

 1 import java.io.*;
 2 
 3 public class employee {
 4 
 5     //salary是静态的私有变量
 6 
 7     private static double salary;
 8 
 9     // department是一个常量
10 
11     public static final string department = "开发人员";
12 
13     public static void main(string[] args){
14 
15     salary = 10000;
16 
17         system.out.println(department+"平均工资:"+salary);
18 
19     }
20 
21 }

以上实例编译运行结果如下:

开发人员平均工资:10000.0

注意：如果其他类想要访问该变量，可以这样访问：employee.department。