[Java知识库]Java修仙，法力无边（光速回顾Java基础~）

Java修仙，法力无边（光速回顾Java基础~）??ヽ(°▽°)ノ?

第一重 炼体（Java基础编程）

1.1 Java基础概述

Sun公司将Java划分为三个平台：JavaSE、JavaEE和JavaME

Java是一门编程语言，分为三大版本

三种Java版本之间的关系：

**JavaSE（标准版）**是JavaEE和JavaME的基础，用来开发C/S架构软件（即电脑桌面应用软件）

**JavaEE（企业版）**是在JavaSE的基础上构建的，用来开发B/S架构软件（企业级应用），在JavaSE的基础上进行了扩展，增加了一下更便捷的应用框架（比如现在常用的SpringMVC），我们可以应用这些框架轻松写出企业级的应用软件

**JavaME（微型版）**也是以JavaSE为基础的，它是一套专门为嵌入式设备设计的API接口规范，主要用于开发移动设备软件和嵌入式设备软件

Java是一门优秀的编程语言，其最主要的特点有以下几点：

1、简单：丢弃了C++中难以理解的运算符重载、多重继承等模糊的概念，特别是Java中不使用指针，而是使用引用，并提供了自动的垃圾回收机制，使程序员不必为内存管理而担忧

2、面向对象：提供了类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（简而言之Java是一个纯粹的面向对象程序设计语言）

3、平台无关：Java语言编写的程序可以运行在各种平台之上，也就是说同一段程序既可以在Windows操作系统上运行，也可以在Linux操作系统上运行

4、多线程：所谓多线程可以简单理解为程序中有多个任务可以并发执行，这样可以在很大程度上提高程序的执行效率

5、动态：Java程序的 基本组成单元 就是 类 ，类又是运行时动态装载的，这使得Java可以在分布环境中动态地维护程序及类库

1.2 JDK简介

JDK：Sun公司提供了一套Java开发环境，简称JDK(Java Development Kit)，它是整个Java的核心，其中包括Java编译器、Java运行工具、Java文档生成工具、Java打包工具等 （开发使用）

JRE：它是Java运行环境，是提供给普通用户使用的。由于用户只需要运行事先编写好的程序，不需要自己动手编写程序，因此JRE工具中只包含Java运行工具，不包含Java编译工具，SUN公司在其JDK工具中自带了一个JRE工具，也就是说开发环境中包含运行环境，这样一来，开发人员只需要在计算机上安装JDK即可，不需要专门安装JRE工具了

JDK安装目录下子目录介绍：

• bin目录：该目录用于存放一些 可执行程序 ，如javac.exe（Java编译器）、java.exe（Java运行工具）、jar.exe（打包工具）和javadoc.exe（文档生成工具）等

• db目录：db目录是一个小型的数据库。从JDK 6.0开始，Java中引入了一个新的成员JavaDB，这是 一个纯 Java 实现、开源的数据库管理系统

• jre目录：“jre”是Java Runtime Environment的缩写，意为Java程序运行时环境。此目录是Java运行时环境的根目录，它包含Java虚拟机，运行时的类包、Java应用启动器以及一个bin目录，但不包含开发环境中的开发工具

• include目录：由于JDK是通过C和C++实现的，因此在启动时需要引入一些C语言的头文件，该目录就是用于存放这些头文件的

• lib目录：lib是library的缩写，意为Java类库或库文件，是开发工具使用的归档包文件

• src.zip文件：src.zip为src文件夹的压缩文件，src中放置的是JDK核心类的源代码，通过该文件可以查看Java基础类的源代码

1.3 Java程序的开发

Java程序运行机制：

源程序（.java文件）-> Java编译器 -> 字节码（.class文件） -> 类装载器 -> 字节码校验器 -> 解释器 -> 操作系统平台

Java程序运行机制—虚拟机：

Java虚拟机可以理解成一个以 字节码为机器指令的CPU

对于不同的运行平台，有不同的虚拟机，实现了**“一 ”次编译，随处运行”**

Java虚拟机机制屏蔽了底层运行平台的差别

（1）Java程序运行时，经过编译和运行两个步骤，将.java的源文件进行编译，最终生成.class的字节码文件，然后由Java虚拟机将字节码文件进行解释执行，并将结果显示出来

（2）Java程序是由 虚拟机负责解释执行 的，而并非操作系统。这样做的好处是可以实现跨平台性，也就是说针对不同的操作系统可以编写相同的程序，只需安装不同版本的虚拟机即可

1.4 Java基本语法

Java程序代码必须放在一个 类 中，可以简单的把一个类理解为一个Java程序，类使用关键词class定义，class之前可以有类的修饰符

Java程序代码=结构定义语句（声明一个类或方法）+功能执行语句（实现具体功能）

1.4.1 Java中的变量

注意：

1、在Java中，一个小数会被默认为double类型的值，因此在为一个float类型的变量赋值时，在所赋值的后面一定要加上字母F（或者小写f），而为double类型的变量赋值时，可以在所赋值的后面加上字母D（或小写d），也可以不加

2、Java使用Unicode字符码系统，Unicode为每个字符制定了一个唯一的数值，在计算时，计算机会自动将字符转化为所对应的数值，如用97表示小写英文字母a

变量的类型转换：

1、隐式类型转换（自动类型转换）：

指的是两种数据类型在转换的过程中不需要显式地进行声明，由编译器自动完成。自动类型转换必须同时满足两个条件，第一是两种数据类型彼此兼容，第二是目标类型的取值范围大于源类型的取值范围

3种可以进行自动类型转换的情况:

（1）整数类型之间可以实现转换。例如，byte类型的数据可以赋值给short、int、long类型的变量；short、char类型的数据可以赋值给int、long类型的变量；int类型的数据可以赋值给long类型的变量
（2）整数类型转换为float类型。例如，byte、char、short、int类型的数据可以赋值给float类型的变量
（3）其他类型转换为double类型。例如，byte、char、short、int、long、float类型的数据可以赋值给double类型的变量

2、强制类型转换

显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换

强制类型转换格式：目标类型 变量 = （目标类型）值

**注意：**如果将取值范围较大的数据类型强制转换为取值范围较小的数据，如将一个int类型的数转为byte类型，极容易造成数据精度的丢失

1.4.2 Java中的运算符

算数运算符：

（1）自增自减时（++）（–）位于操作数的前后问题，先自增还是先进行其他运算

（2）除法运算中，整数之间相除会忽略小数部分

（3）在进行取模（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数）的符号无关。例如，(-5)%3=-2，而5%(-3)=2

赋值运算符：

Java中可以通过一条赋值语句对多个变量进行赋值

合法赋值语句：int x,y,z; x=y=z=5;

非法赋值语句：int x=y=z=5;

逻辑运算符：

（1）在使用“&”进行运算时，不论左边为true或者false，右边的表达式都会进行运算。在使用“&&”进行运算，当左边为false时，右边的表达式就不再进行运算，因此“&&”被称作短路与

（2）运算符“|”和“||”都表示或操作，当运算符两边的任一表达式值为true时，其结果为true。只有两边表达式的值都为false时，其结果才为false，“||”运算符为短路或，当运算符“||”的左边为true时，右边的表达式不再进行运算

（3）运算符“^”表示异或操作，当运算符两边的布尔值相同时（都为true或都为false），其结果为false。当两边表达式的布尔值不相同时，其结果为true（同为false异为true）

1.5 方法

定义：方法就是一段可以重复调用的代码，有些书中也会把方法称为函数

语法格式：

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．){
执行语句
…
return 返回值;
}

方法的重载：参数不同的方法有着相同的名字，调用时根据参数不同确定调用哪个方法，这就是Java方法重载机制

注意：通过传入不同的参数便可以确定调用哪个重载的方法，方法的重载与返回值类型无关

1.6 数组

定义：数组是指一组类型相同的数据的集合，数组中的每个数据被称作元素（可存放任意类型的元素，但同一数组里存放的元素类型必须一致）

Java中数组的声明方式：

• 数据类型[] 数组名 = null;
• 数据类型[]数组名;
  数组名= new数据类型[长度];

注意：若数组不进行初始化，系统默认初始化，不同类型数组元素的默认值

二维数组的定义

第一种方式：
数据类型[][] 数组名 = new数据类型【行数】【列数】;

第二种方式：
数据类型[][] 数组名 = new int【行的个数】【】;

第三种方式：
数据类型[][] 数组名= {{第0行初始值},{第1行初始值},…,{第n行初始值}};
int[][] xx= {{1,2},{3,4,5,6},{7,8,9}};

1.7 炼体阶段案例

【案例1—Product information management system】

介绍：通过数组对产品信息完成初始化，用户后期可通过“Update”功能对原信息进行更新覆盖，也可以通过产品名称查询已录入的或初始化的产品信息，也可以查询基本统计信息

package package_01;
import java.util.Scanner;

public class Class_01 {
	//用static使得变量可被全局查询
	static String[] names = {"iPhone","HuaiWei","Vivo"};	//名称
	static int[] price = {8900,7400,4500};	//售价
	static int[] number = {200,19,120,50,230};	//数量

	//创建菜单栏方法
		private static void menu() {
			System.out.println("-- Management Information System  --");
			System.out.println("------------------------------------");
			System.out.println("------------  1.Show  --------------");
			System.out.println("------------  2.Update  ------------");
			System.out.println("------------  3.Inquire ------------");
			System.out.println("------------  4.Statistics  --------");
			System.out.println("------------  5.Exist  -------------");
			System.out.println("----------------------------");
			System.out.println("->Please choose your operation：");
		}
		
	
	public static void main(String[] arge) {
		Scanner input = new Scanner(System.in);
		
		//循环名称，用于后面结束整个循环
		outer:
		while(true) {
			//呈现菜单栏
			menu();
			//接收键盘的输入
			int c = input.nextInt();
			//.nextInt  ->  将下一个输入内容扫描位int类型
			
			switch(c) {
			case 1:function1();
			break;
			case 2:function2();
			break;
			case 3:function3();
			break;
			case 4:function4();
			break;
			case 5:break outer;
			}
		}
		
	}
	
	
	//功能1
	private static void function1() {
		//通过遍历打印所有的商品信息
		for(int i=0;i<names.length;i++) {
			String n=names[i];
			int p=price[i];
			int b=number[i];
			System.out.print((i+1)+" . "+"名称："+n+"\t价格："+p+"\t库存："+b+"\n");
			System.out.print("------------------------------------------");
			System.out.print("\n");
		}
	}
	
	//功能2
	private static void function2() {
		Scanner input = new Scanner(System.in);
		System.out.print("Start the Update Operation：");
		for(int i=0;i<names.length;i++) {
			System.out.print("Please input the name：");
			String n = input.next();
			names[i]=n;
			System.out.print("Please input the price：");
			int p = input.nextInt();
			price[i]=p;
			System.out.print("Please input the number：");
			int b = input.nextInt();
			number[i]=b;
		}
		
		//将更新后的数据重新输出
		function1();
	}
	
	//功能3
	private static void function3() {
		Scanner input = new Scanner(System.in);
		System.out.print("--产品信息查询--");
		System.out.print("请输入要查询的产品名称：");
		String x = input.next();
		
		//通过遍历查找产品是否存在
		for(int i=0;i<names.length;i++) {
			if(x.equals(names[i])) {
				String n = names[i];
				int p = price[i];
				int b = number[i];
				System.out.print("->  名称："+n+"\t价格："+p+"\t库存："+b+"\n");
				return ;
			}
		}
		System.out.print("查无此物！");	
	}
	
	//功能4
	private static void function4() {
		int sum=0; //商品总价
		int anverage=0;  //单价总价，为得到均价
		int highestSum=0;  //最高总价
		int highestOne=0;   //最高单价
		
		for (int i = 0; i < names.length; i++) {
			sum+=price[i]*number[i];
			anverage+=price[i];
			if (price[i]*number[i]>highestSum) {
				highestSum=price[i]*number[i];
			}
			if (price[i]>highestOne) {
				highestOne=price[i];
			}
		}
		System.out.println("商品总价："+sum);
		System.out.println("单价均价："+(anverage/names.length));
		System.out.println("最高总价："+highestSum);
		System.out.println("最高单价："+highestOne);
	}
}

【案例2—Shopping In Supermarket】

package package_01;
import java.util.Scanner;

public class Class_02 {
	//数组的编号代表水果的价格
	static int price[]= {3,5,2,7};
	static int length=10;
	static int[] price_sum=new int[length];
	
	//菜单栏方法
	public static void menu() {
		System.out.println("---- Please choose your fruit  ----");
		System.out.println("-----------------------------------");
		System.out.println("---------  1.apple  3$  -----------");
		System.out.println("---------  2.banana  5$  ----------");
		System.out.println("---------  3.pear 2$ --------------");
		System.out.println("---------  4.watermelon  7$  ------");
		System.out.println("------------  5.Exist  ------------");
		System.out.println("-----------------------------------");
		System.out.println("->Please choose your operation：");
	}
	
	public static void main(String [] arge) {
		Scanner input = new Scanner(System.in);
		int i=0;
		int sum=0;
		outer:
		while(true) {
			System.out.print("Please input your choice:");
			int m = input.nextInt();
			System.out.print("Do you want to get more?(choose 'Y'or'N')");
			price_sum[i]=m-1;
			++i;
			String s = input.next();
			if(s.equals("Y")) continue;
			else if(s.equals("N")) break outer;
			else continue;
		}
		System.out.print("Your shopping is over!");
		for(int j=0;j<i;j++) {
			sum+=price[price_sum[j]];
		}
		System.out.print("The sum of your choice:"+sum);
	}

【案例3—Distribution Department】

package package_01;
import java.util.Scanner;

public class Class_03 {
	static String[] major= {"Java","C#","asp.net","Front end"};
	
	public static void main(String []arge) {
		Scanner input = new Scanner(System.in);
		outer:
		while(true) {
			System.out.print("Please enter your major:");
			String m = input.next();
			for(int i=0;i<major.length;i++) {
				if(m.equals(major[i])) {
					System.out.print("Congratulation on jioning "+major[i]+" department!");
					break outer;
				}
			}
			System.out.print("We don't have this department! please check your input and try again!");
		}
	}
}

【案例4—Rock-paper-scissors】

package stjdb;
import java.util.Scanner;
import java.util.Random;

public class Class_04 {
	public static void main(String[] args) {
		System.out.print("-----------------------------------\n");
		System.out.print("--- 1=Rock 2=paper 3=scissors  ----\n");
		System.out.print("-----------------------------------\n");
		Random rand = new Random();
		Scanner input = new Scanner(System.in);
		int r=0;
		int c=0;
		outer:
		while(true) {
			for(int i=0;i<5;i++) {
				int s = rand.nextInt(5)+1;
				System.out.print("--The system has its choice!\n");
				System.out.print("--Please enter your choice:");
				int m = input.nextInt();
				if(m!=1 && m!=2 && m!=3) {
					System.out.print("\nyour input is wrong! please check your input and try again!\n");
					continue;
				}
				else {
					if(m==(s+1) || m==(s-2)){
						r+=1;	//玩家胜局+1
						System.out.print("your victory +1!\n");
						System.out.print("The number of people's victory = "+r+"\n");
					}
					else {
						c++;
						System.out.print("computer's victory +1!\n");
						System.out.print("The number of computer's victory = "+c+"\n");
					}
				}
				System.out.print("-----------------------------------\n");
			}
			if(r==5) {
				System.out.print("you victory!");
				break outer;
			}
			else if(c==5) {
				System.out.print("computer victory!");
				break outer;
			}
			else continue;
			
		}
	}

}

【案例5—Login And Registration】

package stjdb;
import java.util.Scanner;

public class Class_05 {
	//初始化数组（存储原账户密码
	static double[] user_name = new double[10];
	static double[] pass_word = new double[10];
	//菜单栏
	public static void menu() {
		System.out.println("-----------------------------------------------");
		System.out.println("--  Bank User Information Management System  --");
		System.out.println("-----------------------------------------------");
		System.out.println("------------  1.Login  ------------------------");
		System.out.println("------------  2.Registration  -----------------");
		System.out.println("------------  3.Show --------------------------");
		System.out.println("------------  4.Change password  --------------");
		System.out.println("------------  5.Exist  ------------------------");
		System.out.println("-----------------------------------------------");
		System.out.println("->Please choose your operation：");
	}
	
	//功能1
	public static void function1() {
		Scanner input = new Scanner(System.in);
		System.out.println("Please enter your user name:");
		double un = input.nextDouble();
		while(true) {
			outer:
		for(int i=0;i<user_name.length;i++) {
			if(un==user_name[i]) {
				System.out.println("Please enter your password:");
				double pw = input.nextDouble();
				for(int j=0;j<pass_word.length;j++) {
					if(pw==pass_word[j]) {
						System.out.println("Login Succeeded!");
						return;
					}
				}
				System.out.println("Login Failed!  Error:your password is wrong!");
			}
		}
			System.out.println("Your user name is not exist!");
			return;
	}
}
	
	//功能2
	public static void function2() {
		Scanner input = new Scanner(System.in);
		int x=1;
		//首先判断添加的位置
		for(int i=0;i<user_name.length;i++) {
			if(user_name[i]==0) {
				break;
			}
			x++;
		}
		System.out.println("You are the No."+x+" user!");
		outer:
		while(true) {
			System.out.println("Please input your user name:");
			double un_new = input.nextDouble();
			for(int j=0;j<user_name.length;j++) {
				if(user_name[j]==un_new) {
					System.out.println("The user name is existed! please choose an another one!");
					continue outer;
				}
				else {
					user_name[x-1]=un_new;
					System.out.println("Please input your pass:");
					double pw_new = input.nextDouble();
					pass_word[x-1]=pw_new;
					break outer;
				}
			}
		}
		
	}
	
	//功能3
	public static void function3() {
		System.out.println("The information of all user:");
		for(int i=0;i<user_name.length;i++) {
			if(user_name[i]!=0) {
				System.out.println("User name:"+user_name[i]+"\tPass word:"+pass_word[i]);
			}
			else break;
		}
	}
	
	//功能4
	public static void function4() {
		System.out.println("Please input the user of the one you want to change its password");
		Scanner input = new Scanner(System.in);
		double order = input.nextDouble();
		outer:
			while(true) {
				for(int i=0;i<user_name.length;i++) {
					if(user_name[i]==order) {
						System.out.println("Please input your new password:");
						double ps_new = input.nextDouble();
						pass_word[i]=ps_new;
						System.out.println("Change succeeded!");
						break outer;
					}
				}
				System.out.println("The user is not existed!");
			}
	}

	public static void main(String[] args) {
		user_name[0]=1981885492;
		pass_word[0]=123456;
		Scanner input = new Scanner(System.in);
		outer:
		while(true) {
			menu();
			int a = input.nextInt();
			switch(a) {
			case 1:function1();
				break;
			case 2:
				function2();
				break;
			case 3:
				function3();
				break;
			case 4:
				function4();
				break;
			case 5:
				break outer;
			}
			
		}
	}

}

第二重 筑基（面向对象思想）

2.1 面向对象思想

面向对象：把构成问题的事务按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题，在程序中使用对象映射现实中的事物，使用对象的关系描述事物之间的联系，这种思想就是面向对象

面向对象的三大特性：封装、继承、多态

（1）封装性（面向对象的核心思想）：

• 第一层含义指把对象的属性和行为看成是一个密不可分的整体，将这两者“封装”在一起（即封装在对象中）
• 另外一层含义指“信息隐藏”，将不想让外界知道的信息隐藏起来。例如，驾校的学员学开车，只需要知道如何操作汽车，无需知道汽车内部是如何工作的

（2）继承性：继承性主要描述的是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展，继承不仅增强了代码的复用性、提高开发效率，还降低了程序产生错误的可能性，为程序的维护以及扩展提供了便利

（3）多态：指的是在一个类中定义的属性和方法被其它类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义

2.2 类与对象

类与对象：为了做到让程序对事物的描述与事物在现实中的形态保持一致，面向对象思想中提出了两个概念，即类和对象，在Java程序中类和对象是最基本、最重要的单元。类表示某类群体的一些基本特征抽象，对象表示一个个具体的事物

类用于描述多个对象的共同特征，它是对象的模板。对象用于描述现实中的个体，它是类的实例。对象是根据类创建的，一个类可以对应多个对象

面向对象思想与类的关系：面向对象的思想中最核心的就是对象，而创建对象的前提是需要定义一个类，类是Java中一个重要的引用数据类型，也是组成Java程序的基本要素，所有的Java程序都是基于类的

1.类的定义

类中可以定义成员变量和成员方法，其中，成员变量用于描述对象的特征，成员变量也被称作对象的属性；成员方法用于描述对象的行为，可简称为方法

（特征 -> 属性 / 行为 -> 方法）

成员变量与局部变量：：定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。如果在某一个方法中定义的局部变量与成员变量同名，这种情况是允许的，此时，在方法中通过变量名访问到的是局部变量，而并非成员变量（成员变量在类中，局部变量在类的方法会中）

2.对象的创建及使用（对象是类的实例，对象是类的模板）

基本语法：类名 对象名称 = new 类名();

对象的内存分配：使用new关键字创建的对象是在堆内存分配空间

类是引用数据类型：引用数据类型就是指内存空间可以同时被多个栈内存引用

3.对象的引用传递

 class Student {
	String name;       	// 声明姓名属性
     int age;           		// 声明年龄属性
	void read() {  
		System.out.println("大家好，我是"+name+"，年龄"+age);
	}
 }
 class Example02 {
	public static void main(String[] args) {
		Student stu1 = new Student (); //声明stu1对象并实例化
		Student stu2 = null;          //声明stu2对象，但不对其进行实例化
		stu2 = stu1;                       // stu1给stu2分配空间使用权。
		stu1.name = "小明";          // 为stu1对象的name属性赋值
		stu1.age = 20;
		stu2.age = 50;
		stu1.read();                  	  // 调用对象的方法
		stu2.read();
	}
 }

对象的引用传递的实质：

首先声明stu1并为stu1分配内存空间，然后stu1对象为stu2对象分配使用权，stu1和stu2指向同一内存（引用的实质）

4.访问控制

针对类、成员方法和属性，Java提供了4种访问控制权限，分别是private、default、protected和public，这4种访问控制权限按级别由小到大依次排列

（1）private（当前类访问级别）：属于私有访问权限，用于修饰类的属性和方法，类的成员一旦使用了private的访问权限，则该类成员只能在本类中进行访问

（2）default：如果一个类中的属性或方法没有进行任何的访问权限声明，则默认为default的访问权限，默认的访问权限可以被本包中的其他类访问，但是不能被其他包中的类访问

（3）protected：属于受保护的访问权限，一个类中的成员若使用了protected访问权限，则只能被本包及不同包的子类访问

（4）public：属于公共访问权限，若使用了该访问权限，则该成员可以在所有类中被访问，不管是否在同一包中

2.3 封装

封装：封装是指一种将抽象性函数式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止本类的代码和数据被外部类定义的代码随机访问

Java开发中，在定义一个类时，将类中的属性私有化，即使用private关键字修饰类的属性，被私有化的属性只能在类中被访问。如果外界想要访问私有属性，则必须通过setter和getter方法设置和获取属性值

2.4 构造方法

构造方法：实例化一个对象后，如果要为这个对象中的属性赋值，则必须通过直接访问对象的属性或调用setter方法才可以，如果需要在实例化对象时为这个对象的属性赋值，可以通过构造方法实现

构造方法（也被成为构造器）是类的一个特殊成员方法，在类实例化对象时自动调用

构造方法是一个特殊的成员方法，在定义时，有以下几点需要注意：
（1）构造方法的名称必须与类名一致。
（2）构造方法名称前不能有任何返回值类型的声明。
（3）不能在构造方法中使用return返回一个值，但是可以单独写return语句作为方法的结束

无参构造方法与有参构造方法：

1. 无参构造方法：

1 class Student{
2	public Student() {  
3		System.out.println("调用了无参构造方法");
4	}
5 }
6 public class Example05 {
7	public static void main(String[] args) {
8             System.out.println("声明对象...");
9		    Student stu = null;           	//声明对象
10         System.out.println("实例化对象...");
11         stu = new Student();     			//实例化对象
12	}
13 }

2. 有参构造方法：

class Student{
    private String name;
    private int age;
    public Student(String n, int a) 5{
        name = n;
        age = a;
    }
    public void read(){
        System.out.println("我是:"+name+",年龄:"+age);
    }
}

public class Example06 {
    public static void main(String[] args) {
        Student stu = new Student("张三",18);    // 实例化Student对象
        //在实例化的时候就传入初始化值
        stu.read();
    }
}

构造方法的重载：

与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法，只要每个构造方法的参数或参数个数不同即可。在创建对象时，可以通过调用不同的构造方法为不同的属性赋值

class Student{
    private String name;
    private int age;
    public Student() { }
    public Student(String n) {
        name = n;
    }
    public Student(String n, int a) {
        name = n;
        age = a;
    }
    public void read(){
        System.out.println("我是:"+name+",年龄:"+age);
    }
}
public class Example07 {
    public static void main(String[] args) {
        Student stu1 = new Student("张三");
        Student stu2 = new Student("张三",18);   // 实例化Student对象
        stu1.read();
        stu2.read();
    }
}

需要注意的是，构造方法通常使用public进行修饰

2.5 this关键字与static关键字

1.this关键字

当成员变量与局部变量发生重名问题时，需要使用到this关键字分辨成员变量与局部变量（有参构造函数就是一个典型的例子）

参数名称与对象成员变量名称相同，编译器无法确定哪个名称是当前对象的属性

Java中的this关键字语法比较灵活，其主要作用主要有以下3种。
（1）使用this关键字调用本类中的属性
（2）this关键字调用成员方法
（3）使用this关键字调用本类的构造方法

构造方法是在实例化对象时被Java虚拟机自动调用，在程序中不能像调用其他成员方法一样调用构造方法，但可以在一个构造方法中使用“this(参数1,参数2…)”的形式调用其他的构造方法

class Student {
	private String name;
	private int age;
	public Student () {
		System.out.println("实例化了一个新的Student对象。");
	}
	public Student (String name,int age) {
		this();                  // 调用无参的构造方法
		this.name = name;
    	this.age = age;
	}
	public String read(){
        return "我是:"+name+",年龄:"+age;
	}
}

public class Example11 { 
	public static void main(String[] args) {
	    Student stu = new Student ("张三",18); // 实例化 Student对象
         System.out.println(stu.read());
	}
}

注意：在使用this调用类的构造方法时，应注意以下几点

（1）只能在构造方法中使用this调用其他的构造方法，不能在成员方法中通过this调用其他构造方法

（2）在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。下面程序的写法是错误的

（3）不能在一个类的两个构造方法中使用this互相调用

2.static关键字

在定义一个类时，只是在描述某事物的特征和行为，并没有产生具体的数据。只有通过new关键字创建该类的实例对象时，才会开辟栈内存及堆内存，在堆内存中要保存对象的属性时，每个对象会有自己的属性。如果希望某些属性被所有对象共享，就必须将其声明为static属性。如果属性使用了static关键字进行修饰，则该属性可以直接使用类名称进行调用

static可以修饰属性和方法（被修饰后分别称为静态属性和静态方法）

（1）静态属性：

在Java程序中使用static修饰属性，则该属性称为静态属性（也称全局属性），静态属性可以使用类名直接访问，访问格式如下：
类名.属性名

只需改变一个对象的静态属性，所有对象的此属性都会被修改

（2）静态方法：

同静态变量一样，静态方法也可以通过类名和对象访问，具体如下所示。
类名.方法 或 实例对象名.方法

class Student {
    private String name;                         		// 定义name属性
    private int age;                              		// 定义age属性
    private static String school = "A大学";   	// 定义school属性

    //通过有参构造函数，将外部的类的实例化数据传入改变
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    public void info(){
        System.out.println("姓名:" +this.name+"，年龄:" + this.age+"，学校:" + school);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public static String getSchool() {
        return school;
    }

    public static void setSchool(String school) {
        Student.school = school;
    }
}
class Example15 {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",18);     // 创建学生对象
        Student stu2 = new Student("李四",19);
        Student stu3 = new Student("王五",20);
        stu1.setAge(20);
        stu2.setName("小明");
        Student.setSchool("B大学");
        stu1.info();
        stu2.info();
        stu3.info();
    }
}

注意：静态方法只能访问静态成员，因为非静态成员需要先创建对象才能访问，即随着对象的创建，非静态成员才会分配内存，而静态方法在被调用时可以不创建任何对象

2.6 代码块

代码块，简单来讲，就是用“{}”括号括起来的一段代码，根据位置及声明关键字的不同，代码块可以分为4种：普通代码块、构造块、静态代码块、同步代码块

（1）普通代码块就是直接在方法或是语句中定义的代码块

（2）构造代码块就是直接在类中定义的代码块

class Student{
    String name;    				//成员属性
    {
        System.out.println("我是构造代码块");       //与构造方法同级
    }
    //构造方法
    public Student(){
        System.out.println("我是Student类的构造方法");
    }
}
public class Example12  {
    public static void main(String[] args) 13{
        Student stu1 = new Student();
        Student stu2 = new Student();
    }
}

注意：在实例化Student类的对象stu1和stu2时，构造块的执行顺序大于构造方法（与构造块和构造方法在类中的位置没有关系），每当实例化一个类时，都会在执行构造方法之间执行构造块

（3）静态代码块

用static关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。在程序中，通常使用静态代码块对类的成员变量进行初始化

【案例3-4 学生投票系统】

package stjdb;
import java.util.Scanner;

public class Class_06 {
	static int[] book_price= {15,23,18,7,32};
	static int[] book_inventory= {2,1,0,3,2};
	static String[] book_name = {"Science","Natural","Geography","Action","Suspense"};
	//首先创建图书类，便于后面引用该类，来实例化不同的具体书籍
	class Book{
		String name;
		double price;
		int inventory;
		
		public Book(String name,double price,int inventory) {
			this.name=name;
			this.price=price;
			this.inventory=inventory;
		}
	}
	
	public static void menu() {
		System.out.println("------------------------------------------------------------------------");
		System.out.println("------------------------  Book Purchase System  ------------------------");
		System.out.println("------------------------------------------------------------------------");
		System.out.println("-----------|       Name     |     Price     |     Inventory      |------");
		System.out.println("------------------------------------------------------------------------");
		System.out.println("-----------|   1.Science    |     15        |     2              |------");
		System.out.println("-----------|   2.Natural    |     23        |     1              |------");
		System.out.println("-----------|   3.Geography  |     18        |     0              |------");
		System.out.println("-----------|   4.Action     |     7         |     3              |------");
		System.out.println("-----------|   5.Suspense   |     32        |     2              |------");
		System.out.println("------------------------------------------------------------------------");
		System.out.println("->Start your shopping , please input your choice：");
	}
	
	//实例化Book对象
	public class Example {
		Book book_01 = new Book("Science",15,100);
		Book book_02 = new Book("Natural",15,100);
		Book book_03 = new Book("Geography",15,100);
		Book book_04 = new Book("Action",15,100);
		Book book_05 = new Book("Suspense",15,100);
	}
	
	public static void Main(String[] args) {
		Scanner input = new Scanner(System.in);
		outer1:
		while(true) {
			menu();
			int sum=0;
			String order = input.next();
			outer2:
			for(int i=0;i<book_name.length;i++) {
				if(order==book_name[i] && book_inventory[i]>0) {
					System.out.println("Are you sure to add "+book_name[i]+" to the shopping cart? (YES or NO)");
					String select = input.next();
					if(select=="YES") {
						sum+=book_price[i];
						System.out.println("Purchase successful !  Your total: "+sum);
						System.out.println("Do you want to continue your shopping ? (YES or NO)");
						String select2 = input.next();
						if(select2=="YES") {
							continue outer1;
						}
						else {
							break outer1;
						}
					}
					else if(select == "NO") {
						System.out.println("Cancellation succeeded !");
						continue outer1;
					}
					else {
						System.out.println("Your input is wrong!");
						break outer2;
					}
				}
			}	
		}	
	}	
}

2.7 类的继承

在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系

定义：在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类。子类继承父类的属性和方法，使得子类对象（实例）具有父类的特征和行为

在继承中需要注意的点：

（1）在Java中，类只支持单继承，不允许多重继承。也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的

（2）多个类可以继承一个父类

（3）在Java中，多层继承也是可以的，即一个类的父类可以再继承另外的父类。例如，C类继承自B类，而B类又可以继承自A类，这时，C类也可称作A类的子类。例如下面这种情况是允许的

（4）在Java中，子类和父类是一种相对概念，一个类可以是某个类的父类，也可以是另一个类的子类

方法的重写：在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写

注意：在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型，且在子类重写的方法不能拥有比父类方法更加严格的访问权限

super关键字

当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，为了解决这个问题，Java提供了super关键字，super关键字可以在子类中调用父类的普通属性、方法以及构造方法

super关键字的几种用法：

（1）使用super关键字访问父类成员变量和方法：

语法：super.成员方法(参数1,参数2…)

// 定义Animal类
class Animal {		
    String name = "牧羊犬";
    //定义动物叫的方法		
    void shout() {			  
        System.out.println("动物发出叫声");
    }
}
// 定义Dog类继承动物类
class Dog extends Animal {    
    //重写父类Animal中的shout()方法,扩大了访问权限
    public void shout() {			 
        super.shout();      //调用父类中的shout()方法
        System.out.println("汪汪汪……");  
    }
    public void printName(){
        System.out.println("名字:"+super.name);      //调用父类中的name属性
    }
}
// 定义测试类
public class Example05 {	
    public static void main(String[] args) {
        Dog dog = new Dog();  // 创建Dog类的实例对象
        dog.shout();            // 调用dog重写的shout()方法
        dog.printName();        // 调用Dog类中的printName()方法
    }
}

（2）使用super关键字方法父类中指定的构造方法

语法：super(参数1,参数2…)

 // 定义Animal类
 class Animal {
    private String name;
    private int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
 	 public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
       return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    21 public String info() {
        return "名称："+this.getName()+",年龄： "+this.getAge();
   }
 }

 // 定义Dog类继承动物类
 class Dog extends Animal {
    private String color;
    public Dog(String name, int age, String color) {
        super(name, age);
        this.setColor(color);
    }
    public String getColor() {
        return color;
    }
 public void setColor(String color) {
        this.color = color;
    }
    //重写父类的info()方法
    public String info() {
        return super.info()+",颜色："+this.getColor();    //扩充父类中的方法
    }
 }
 // 定义测试类
 public class Example06 {
    public static void main(String[] args) {
        Dog dog = new Dog("牧羊犬",3,"黑色"); // 创建Dog类的实例对象
        System.out.println(dog.info());
    }
 }

使用super（name，age）；

继承了父类中的 this.name=name; 和 this.age=age;

并且可以在super（）；语句之后添加拓展的构造语句

注意：通过super()调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次

2.8 final关键字

可以使用final关键字声明类、属性、方法，在声明时需要注意以下几点：
（1）使用final修饰的类不能有子类
（2）使用final修饰的方法不能被子类重写
（3）使用final修饰的变量（成员变量和局部变量）是常量，常量不可修改

final关键字是一种限制和修饰，可以让一个类不能有子类，且如果父类的方法被final关键字修饰，那么它就不能再被子类重写该方法，被其修饰的变量称为常量，其值不能再发生改变

注意：在使用final声明变量时，要求全部的字母大写。如果一个程序中的变量使用public static final声明，则此变量将成为全局变量，如下面代码所示。

public static final String NAME = "哈士奇";

2.9 抽象类与接口

当定义一个类时，常常需要定义一些成员方法描述类的行为特征，但有时这些方法的实现方式是无法确定的

抽象方法：抽象方法用abstract关键字修饰的方法，抽象方法在定义时不需要实现方法体

语法：abstract void 方法名称（参数）;

注意：当一个类包含了抽象方法，该类必须是抽象类。抽象类和抽象方法一样，必须使用abstract关键字进行修饰

abstract class 抽象类名称{
    访问权限 返回值类型 方法名称(参数){
           return [返回值];
    }
    访问权限 abstract 返回值类型 抽象方法名称(参数);     //抽象方法，无方法体
}

抽象类的定义规则如下：
（1）包含一个以上抽象方法的类必须是抽象类
（2）抽象类和抽象方法都要使用abstract关键字声明
（3）抽象方法只需声明而不需要实现
（4）如果一个类继承了抽象类，那么该子类必须实现抽象类中的全部抽象方法（接口）

使用abstract关键字修饰的抽象方法不能使用private修饰，因为抽象方法必须被子类实现，如果使用了private声明，则子类无法实现该方法

接口：如果一个抽象类的所有方法都是抽象的，则可以将这个类定义接口。接口是Java中最重要的概念之一，接口（并不是一个独立的东西）是一种特殊的类，由全局常量和公共的抽象方法组成，不能包含普通方法

JDK 8对接口进行了重新定义，接口中除了抽象方法外，还可以有默认方法和静态方法(也叫类方法)，默认方法使用default修饰，静态方法使用static修饰，且这两种方法都允许有方法体

接口的声明：使用interface关键字声明

public interface 接口名 extends 接口1,接口2... {
    public static final 数据类型 常量名 = 常量值; 
    //静态方法
    public default 返回值类型 抽象方法名(参数列表);
    //抽象方法
    public abstract 返回值类型 方法名(参数列表){
        //默认方法的方法体
    }
    public abstract 返回值类型方法名(参数列表){
        //类方法的方法体
    }
}

注意： 接口中的变量默认使用“public static final”进行修饰，即全局常量。接口中定义的方法默认使用“public abstract”进行修饰，即抽象方法。如果接口声明为public，则接口中的变量和方法全部为public

“extends 接口1,接口2…”表示一个接口可以有多个父接口，父接口之间使用逗号分隔。Java使用接口的目的是为了克服单继承的限制，因为一个类只能有一个父类，而一个接口可以同时继承多个父接口

多学一点：经常看到编写接口中的方法时省略了public ，但是接口中的方法访问权限永远是public。与此类似，在接口中定义常量时，可以省略前面的“public static final”，此时，接口会默认为常量添加“public static final”

接口的使用： 接口的使用必须通过子类，子类通过implements关键字实现接口，并且子类必须实现接口中的所有抽象方法。需要注意的是，一个类可以同时实现多个接口，多个接口之间需要使用英文逗号(,)分隔

修饰符 class 类名 implements 接口1,接口2,...{
    ...
}

接口实例：

//定义抽象类Animal（注意这里声明时忽略了public）
interface Animal{
    int ID = 1;
    String NAME = "牧羊犬";
    void shout();
    static int getID(){
        return ID;
    }
    public void info();
    //上面有两个抽象方法不用设置函数体
}
interface Action{
    public void eat();
}
//定义Dog类实现Animal接口和Action接口
class Dog implements Animal,Action{
    //Animal接口里eat方法的重写
    public void eat(){
        System.out.println("骨头");
    }
    //Action接口里shout方法的重写
    public void shout(){
        System.out.println("汪汪汪");
    }
    //Animal接口里info方法的重写
    public void info(){
        System.out.println("名称"+NAME);
    }
}
//定义测试类
class Example11{
    public ststic void main(String args[]){
        Systrm.out.println("编号"+Animal.getID());
        //接口中的静态方法 getID(); 则可以直接使用接口名调用
        Dog dog = new Dog();
        dog.info();
        dog.shout();
        dog.eat();
    }
}

注意：接口的实现类，必须实现接口中的所有方法，否则程序编译报错！

如果在开发中一个子类既要实现接口又要继承抽象类，则可以按照以下格式定义子类：

修饰符class 类名 extends 父类名implements 接口1,接口2,... {
    ...
}

2.10 多态

多态性是面向对象思想中的一个非常重要的概念，在Java中，多态是指不同对象在调用同一个方法时表现出的多种不同行为,在同一个方法中，这种由于参数类型不同而导致执行效果不同的现象就是多态

多态的两种主要形式：（1）方法的重载；（2）对象的多态性——方法重写

对象类型的转换：（1）向上转型：子类–>父类；（2）向下转型：父类–>子类

转换格式:

• 对象向上转型: 父类类型 父类对象 = 子类实例;
• 对象向下转型:

父类类型 父类对象 = 子类实例;

子类类型 子类对象 = (子类)父类对象;

向上转型实例:

//定义Animal类
class Animal{
    public void shout(){
    	System.out.println("喵喵...");
    }
}
//定义Dog类
class Dog extends Animal{
    //方法shout的重写
    public void shout(){
        System.out.println("汪汪...");
    }
}
//定义测试类
public class Example15{
    public static void main(String args[]){
        Dog dog = new Dog();//创建了dog对象
        Animal an = dog;//将dog向上转型为Animal类型的对象an
        an.shout();//使用父类对象an调用了shout();方法,但实际上调用的是被重写过的shout();方法
    }
}

注意：如果对象发生了向上转型关系后，所调用的方法一定是被子类重写过的方法（即其本质不变）

父类Animal的对象an是无法调用Dog类中的eat()方法的，因为eat()方法只在子类中定义，而没有在父类中定义

向下转型实例:

//定义类Animal
class Animal{
    public void shout(){
        System.out.println("喵喵...");
    }
}
//定义Dog类
class Dog extends Animal{
    //方法shout的重写
    public void shout(){
        System.out.println("汪汪...");
    }
    public void eat(){
        System.out.println("吃骨头");
    }
}
//定义测试类
public class Example16{
    public static void main(String args[]){
        Animal an = new Dog();//此时发生了向上转型,将Dog类的实例转换成了Animal类的实例an
        //Animal an = new Dog();
        //是Dog dog = new Dog();  Animal an  = dog; 的简写形式
        Dog dog = (Dog)an;//此时发生了向下转型,将Animal类的实例an转换为Dog类的实例dog
        dog.shout();
        dog.eat();
    }
}

在向下转型时，不能直接将父类实例强制转换为子类实例，否则程序会报错，必须首先用父类创建一个子类实例，再把这个实例用子类再实例一遍

instanceof关键字

Java中可以使用instanceof关键字判断一个对象是否是某个类（或接口）的实例
语法 : 对象 instanceof类（或接口）
在上述格式中，如果对象是指定的类的实例对象，则返回true，否则返回false

2.11 Object类

Java提供了一个Object类，它是所有类的父类，每个类都直接或间接继承Object类，因此Object类通常被称之为超类。当定义一个类时，如果没有使用extends关键字为这个类显式地指定父类，那么该类会默认继承Object类

2.12 内部类

在Java中，允许在一个类的内部定义类，这样的类称作内部类，内部类所在的类称作外部类，成员内部类可以访问外部类的所有成员

1.成员内部类：在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。成员内部类可以访问外部类的所有成员

class Outer {
    int m = 0; 		// 定义类的成员变量
    // 下面的代码定义了一个成员方法，方法中访问内部类
    void test1() {
        System.out.println("外部类成员方法");
    }
    // 下面的代码定义了一个成员内部类
    class Inner {
        int n = 1;
        void show1() {
            // 在成员内部类的方法中访问外部类的成员变量
            System.out.println("外部成员变量m = " + m);
        }
        void show2() {
            // 在成员内部类的方法中访问外部类的成员变量
            System.out.println("内部成员方法");
        }
    }
    void test2() {
        Inner inner = new Inner();
        System.out.println("内部成员变量n = " + inner.n);
        inner.show2();
    }
}
public class Example20 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = new outer.new Inner();
        inner.show1();
        outer.test2();
    }
}

如果想通过外部类访问内部类，则需要通过外部类创建内部类对象，创建内部类对象的具体语法格式如下：
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

（如上第28行代码）

2.局部内部类：也叫作方法内部类，是指定义在某个局部范围中的类，它和局部变量一样，都是在方法中定义的，有效范围只限于方法内部

class Outer{
    int m = 0;
    void test1(){
        System.out.println("外部类成员方法");
    }
    void test2(){
        class Inner{
            int n = 1;
            void show(){
                //在成员内部类的方法中访问外部类的成员变量
                System.out.println("外部成员变量m="+m);
                test1();
            }
        }
        Inner inner = new Inner();
        System.out.println("局部内部成员变量n="+inner.n);
        inner.show();
    }
}
public class Examp21{
    public static void main(String args[]){
        Outer outer  = new Outer();
        outer.test2();
    }
}

3.静态内部类

所谓静态内部类，就是使用static关键字修饰的成员内部类，与成员内部类相比，在形式上，静态内部类只是在内部类前增加了static关键字，但在功能上，静态内部类只能访问外部类的静态成员，通过外部类访问静态内部类成员时，可以跳过外部类直接访问静态内部类

创建静态内部类对象的基本语法格式如下：
外部类名.静态内部类名 变量名 = new 外部类名().静态内部类名();

静态内部类实例：

class Outer{
    static int m = 0;
    static class Inner{
        int n = 1;
        void show(){
            System.out.println("外部静态变量m="+m);
            //有static关键字修饰的静态内部类只能访问有static修饰的外部类的静态变量
        }
    }
}
public class Example{
    public static void main(String args[]){
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}

4.匿名内部类

匿名内部类是没有名称的内部类，在Java中调用某个方法时，如果该方法的参数是接口类型，除了可以传入一个接口实现类，还可以使用实现接口的匿名内部类作为参数，在匿名内部类中直接完成方法的实现

创建匿名内部类的基本语法格式如下：
new 父接口(){
//匿名内部类实现部分
}

interface Animal{
    void shout();
}
public class Example23{
    public static void main(String[] args){
        String name = "小花";
        animalShout(new Animal(){
            @Override
            public void shout() {
                System.out.println(name+"喵喵...");
            }
        });
    }
    public static void animalShout(Animal an){
        an.shout();
    }
}

匿名类的编写步骤：
**（1）**在调用animalShout()方法时，在方法的参数位置写上new Animal(){}，这相当于创建了一个实例对象，并将对象作为参数传给animalShout()方法，在new Animal()后面有一对大括号，表示创建的对象为Animal的子类实例，该子类是匿名的。具体代码如下所示：
animalShout(new Animal(){});

**（2）**在大括号中编写匿名子类的实现代码，具体如下所示：
animalShout(new Animal() {
public void shout() {
System.out.println(“喵喵……”);
}
});

2.13 异常

在程序运行的过程中，也会发生各种非正常状况，例如，程序运行时磁盘空间不足、网络连接中断、被装载的类不存在等。针对这种情况， Java语言引入了异常，以异常类的形式对这些非正常情况进行封装，通过异常处理机制对程序运行时发生的各种问题进行处理

算术异常案例：

public class Example24 {                      
    public static void main(String[] args) {
        int result = divide(4, 0);    // 调用divide()方法
        System.out.println(result);    
    }
    //下面的方法实现了两个整数相除
    public static int divide(int x, int y) { 
        int result = x / y;     	// 定义一个变量result记录两个数相除的结果
        return result;           	// 将结果返回
    }
}

程序发生了算术异常（ArithmeticException），该异常是由于文件4-24中的第3行代码调用divide()方法时传入了参数0，运算时出现了被0除的情况。异常发生后，程序会立即结束，无法继续向下执行。

上述程序产生的ArithmeticException异常只是Java异常类中的一种，Java提供了大量的异常类，这些类都继承自java.lang.Throwable类
接下来通过一张图展示Throwable类的继承体系

Throwable有两个直接子类Error和Exception，其中，Error代表程序中产生的错误，Exception代表程序中产生的异常

● Error类称为错误类，它表示Java程序运行时产生的系统内部错误或资源耗尽的错误，这类错误比较严重，仅靠修改程序本身是不能恢复执行的。举一个生活中的例子，在盖楼的过程中因偷工减料，导致大楼坍塌，这就相当于一个Error。例如，使用java命令去运行一个不存在的类就会出现Error错误

● Exception类称为异常类，它表示程序本身可以处理的错误，在Java程序中进行的异常处理，都是针对Exception类及其子类的。在Exception类的众多子类中有一个特殊的子类—RuntimeException类，RuntimeException类及其子类用于表示运行时异常。 Exception类的其他子类都用于表示编译时异常

Throwable类中的常用方法如下表

try…catch 和 finally

为了解决异常，Java提供了对异常进行处理的方式一一异常捕获，异常捕获使用try…catch语句实现，try…catch具体语法格式如下

try{
    //程序代码块
}catch(ExceptionType(Exception类及其子类) e){
    //对ExceptionType的处理
} 

finally关键字：在程序中，有时候会希望有些语句无论程序是否发生异常都要执行，这时就可以在try…catch语句后，加一个finally代码块

public class Example26 {
    public static void main(String[] args) {
        //下面的代码定义了一个try…catch…finally语句用于捕获异常
        try {
            int result = divide(4, 0);       //调用divide()方法
            System.out.println(result);
        } catch (Exception e) {               //对捕获到的异常进行处理
            System.out.println("捕获的异常信息为：" + e.getMessage());
            return;                             //用于结束当前语句，程序第13行代码就不会执行了，而finally代码块中的代码仍会执行，不受return语句影响
        } finally {                             
            System.out.println("进入finally代码块");
        }
        System.out.println("程序继续向下执行…");
    }
    //下面的方法实现了两个整数相除
    public static int divide(int x, int y) {
        int result = x / y;           //定义一个变量result记录两个数相除的结果
        return result;                 //将结果返回
    }
}

注意：finally中的代码块在一种情况下是不会执行的，那就是在try…catch中执行了System.exit(0)语句。System.exit(0)表示退出当前的Java虚拟机，Java虚拟机停止了，任何代码都不能再执行了

throws关键字

在实际开发中，大部分情况下我们会调用别人编写方法，并不知道别人编写的方法是否会发生异常。针对这种情况，Java允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常，这样调用者在调用方法时，就明确地知道该方法有异常，并且必须在程序中对异常进行处理，否则编译无法通过

throws关键字声明抛出异常的语法格式如下：
修饰符 返回值类型 方法名(参数1，参数2…)throws 异常类1, 异常类2…{
//方法体…
}
从上述语法格式中可以看出，throws关键字需要写在方法声明的后面，throws后面需要声明方法中发生异常的类型

throws关键字实例：

public class Example28 {
    public static void main(String[] args) {
        //下面的代码定义了一个try…catch语句用于捕获异常
        try {
            int result = divide(4, 2);   //调用divide()方法
            System.out.println(result); 
        } catch (Exception e) {           //对捕获到的异常进行处理
            e.printStackTrace();          //打印捕获的异常信息
        }
    }
    //下面的方法实现了两个整数相除，并使用throws关键字声明抛出异常
    public static int divide(int x, int y) throws Exception {
        int result = x / y;      //定义一个变量result记录两个数相除的结果
        return result;            //将结果返回
    }
}

（1）由于使用了try…catch对divide()方法进行了异常处理，因此程序可以编译通过

（2）如果没有使用try…catch对divide()方法进行异常处理，在main()方法继续使用throws关键字将Exception抛出，程序虽然可以通过编译，但从运行结果可以看出，在运行时期由于没有对“/by zero”的异常进行处理，最终导致程序终止运行

运行时异常与编译时异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gbUmndsq-1645365280299)(光速回顾Java基础.assets/image-20211002151329142-16450503084191.png)]

• 编译时异常：

在Exception类中，除了RuntimeException类及其子类，Exception的其他子类都是编译时异常，编译时异常的特点是Java编译器会对异常进行检查，如果出现异常就必须对异常进行处理，否则程序无法通过编译
处理编译时期的异常有两种方式，具体如下：
（1）使用try…catch语句对异常进行捕获处理。
（2）使用throws关键字声明抛出异常，调用者对异常进行处理。

• 运行时异常：

RuntimeException类及其子类都是运行时异常。运行时异常的特点是Java编译器不会对异常进行检查。也就是说，当程序中出现这类异常时，即使没有使用try…catch语句捕获或使用throws关键字声明抛出，程序也能编译通过，运行时异常一般是由程序中的逻辑错误引起的，在程序运行时无法恢复

自定义异常

JDK中定义了大量的异常类，虽然这些异常类可以描述编程时出现的大部分异常情况，但是在程序开发中有时可能需要描述程序中特有的异常情况

例如，前面讲解的程序中的divide()方法，不允许被除数为负数，为了解决这个问题，Java允许用户自定义异常，但自定义的异常类必须继承自Exception或其子类

自定义异常：

//自定义一个异常类，这个异常类继承于Exception
public class DivideMinusException extends Exception{
    public DivideByMinusException(){
        super();	// 调用Exception无参的构造方法
    }
    public DivideByMinusException(String message){
        super(massage);	// 调用Exception有参的构造方法
    }
}

在实际开发中，如果没有特殊的要求，自定义的异常类只需继承Exception类，在构造方法中使用super()语句调用Exception的构造方法即可。
自定义异常类中使用throw关键字在方法中声明异常的实例对象，格式如下：
throw Exception异常对象

用throw关键字抛出异常对象时，需要使用try…catch语句对抛出的异常进行处理，或者在divide()方法上使用throws关键字声明抛出异常，由该方法的调用者负责处理

自定义异常实例：

public class Example{
    public static void main(String args[]){
        //定义一个try...catch语句用于捕获异常
        try{
            int result = devide(4,-2);
            System.out.println(result);
        }
        catch(DivideNyMinusException e){	//对捕获到的异常进行处理
            System.out.println(e.getMessage);	//打印捕获的异常信息
        }
    }
    public static int divide(int x,int y) throw DivideByMinusException{	
        if(y<0){
            throw new DivideByMinusException("除非是负数");	//捕捉到异常后的行为
        }
        int result = x/y;
        return result;
    }
}

第三重 凝神（Java常用API）

3.1 字符串类

Java中定义了三个封装字符串的类，分别是String、StringBuffer和StringBuilder，它们位于java.lang包中，并提供了一系列操作字符串的方法，这些方法不需要导包就可以直接使用

3.1.1 String类

String类的初始化：

1.使用字符串常量直接初始化一个String对象：String str1 = “abc”;

2.使用String类的构造方法初始化字符串对象

String类的常用操作：

1.字符串的获取功能：在Java程序中，需要对字符串进行一些获取的操作，如获得字符串长度、获得指定位置的字符等

实例：

1 public class Example02 {
2	public static void main(String[] args) {
3		String s = "ababcdedcba"; // 定义字符串s
4         // 获取字符串长度，即字符个数
5		System.out.println("字符串的长度为：" + s.length());
6		System.out.println("字符串中第一个字符:" + s.charAt(0));
7		System.out.println("字符c第一次出现的位置:" + s.indexOf('c'));
8		System.out.println("字符c最后一次出现的位置:" + s.lastIndexOf('c'));
9		System.out.println("子字符串ab第一次出现的位置：" + 
10         s.indexOf("ab"));
11		System.out.println("子字符串ab字符串最后一次出现的位置：" + 
12         s.lastIndexOf("ab"));
13 	}
14 }

• str.length -> 获取字符串长度

• str.chatAt(0) -> 获取字符串第一个字符（注意是从0开始数）

• str.indexxOf(‘a’) -> 获取字符 ’ a ’ 第一次出现的位置

• str.lastIndexxOf(‘a’) -> 获取字符 ’ a ’ 最后一次出现的位置

2.字符串转换操作：程序开发中，经常需要对字符串进行转换操作。例如，将字符串转换成数组的形式，将字符串中的字符进行大小写转换等

实例：

1 public class Example03 {
2	public static void main(String[] args) {
3		String str = "abcd";
4		System.out.print("将字符串转为字符数组后的结果:");
5		char[] charArray = str.toCharArray(); // 字符串转换为字符数组
6		for (int i = 0; i < charArray.length; i++) {
7			if (i != charArray.length - 1) {
8				// 如果不是数组的最后一个元素,在元素后面加逗号
9				System.out.print(charArray[i] + ",");
10			} else {
11				// 数组的最后一个元素后面不加逗号
12				System.out.println(charArray[i]);
13		
14		}
15		System.out.println("将int值转换为String类型之后的结果:" + 
16         String.valueOf(12));
17		System.out.println("将字符串转换成大写之后的结果:" + 
18         str.toUpperCase());
19         System.out.println("将字符串转换成小写之后的结果:" + 
20		str.toLowerCase());
21	}
22 }

• str.toCharArray -> 字符串转换为数组
• str.toUpperCase - > 字符串内容转换为大写形式
• str.toLowerCase - > 字符串内容转换为小写形式

valueOf()方法有多种重载的形式，float、double、char等其他基本类型的数据都可以通过valueOf()方法转为String字符串类型

3.字符串的替换和去除空格操作：程序开发中，用户输入数据时经常会有一些错误和空格，这时可以使用String类的replace()和trim()方法，进行字符串的替换和去除空格操作

实例：

1 public class Example04 {
2	public static void main(String[] args) {
3		String s = "itcast";
4		// 字符串替换操作
5		System.out.println("将it替换成cn.it的结果:" + s.replace("it", 
6         "cn.it"));
7		// 字符串去除空格操作
8		String s1 = "     i t c a s t     ";
9		System.out.println("去除字符串两端空格后的结果:" + s1.trim());
10		System.out.println("去除字符串中所有空格后的结果:" + s1.replace(" ", 
11         ""));
12	}
13 }

• str.replace(“a”,"b) - > 注意顺序，是用后面的替换前面的
• str.trim -> 去除字符串两端空格
• str.replace(" “,”") -> 去除字符串中所有的空格（其实是通过replace语句将空格字符" “用空字符”"替代了）

4．字符串的判断操作：操作字符串时，经常需要对字符串进行一些判断，如判断字符串是否以指定的字符串开始、结束，是否包含指定的字符串，字符串是否为空等

实例：

1 public class Example05 {
2	public static void main(String[] args) {
3		String s1 = "String"; // 声明一个字符串
4		String s2 = "Str";
5		System.out.println("判断是否以字符串Str开头:" + 
6                                 s1.startsWith("Str"));
7		System.out.println("判断是否以字符串ng结尾:" + s1.endsWith("ng"));
8		System.out.println("判断是否包含字符串tri:" + s1.contains("tri"));
9		System.out.println("判断字符串是否为空:" + s1.isEmpty());
10		System.out.println("判断两个字符串是否相等" + s1.equals(s2));
11	}
12 }

• str.starWith(“a”) -> 判断字符串是否以"a"开头
• str.endWith(“b”) -> 判断字符串是否以"b"结束
• str.contains(“c”) -> 判断字符串是否包含"c"
• str.isEmpty() -> 判断字符串是否为空
• str1.equals(str2) -> 判断两个字符串是否相等

在程序中可以通过“==”和equals()两种方式对字符串进行比较，但这两种方式有明显的区别

（1）equals()方法用于比较两个字符串中的字符是否相等

（2）==方法用于比较两个字符串对象的地址是否相同

也就是说，对于两个内容完全一样的字符串对象，使用equals判断的结果是true，使用==判断的结果是false。

5．字符串的截取和分割：在String类中，substring()方法用于截取字符串的一部分，split()方法用于将字符串按照某个字符进行分割

实例：

1 public class Example06 {
2	public static void main(String[] args) {
3		String str = "石家庄-武汉-哈尔滨";
4		// 下面是字符串截取操作
5		System.out.println("从第5个字符截取到末尾的结果：" + 
6                                  str.substring(4));
7		System.out.println("从第5个字符截取到第6个字符的结果：" + 
8                                  str.substring(4, 6));
9		// 下面是字符串分割操作
10		System.out.print("分割后的字符串数组中的元素依次为:");
    11		String[] strArray = str.split("-"); // 将字符串转换为字符串数组
12		for (int i = 0; i < strArray.length; i++) {
13			if (i != strArray.length - 1) {
14				// 如果不是数组的最后一个元素,在元素后面加逗号
15				System.out.print(strArray[i] + ",");
16			} else {
17				// 数组的最后一个元素后面不加逗号
18				System.out.println(strArray[i]);
19			}
20		}
21	}
22 }

• str.substring(3,5) -> 从第四个字符截取到第五个字符（注意第一个参数为下标，第二个参数为位置）

• str.substring(3) -> 从第四个字符开始一直截取到最后一个字符

• str.split("-") -> 以"-"为分隔符，将原字符串分割为一段一段的小字符串

  （常与 String[] strArry = str.split("-")联用，意在将分割出来的小段字符串依次存入数组）

  String字符串在获取某个字符时，会用到字符的索引，当访问字符串中的字符时，如果字符的索引不存在，则会发生StringIndexOutOfBoundsException（字符串角标越界异常）

3.1.2 StringBuffer类

由于字符串是常量，因此一旦创建，其内容和长度是不可改变的。如果需要对一个字符串进行修改，则只能创建新的字符串。为了对字符串进行修改，Java提供了一个StringBuffer类**（也称字符串缓冲区）**

StringBuffer与String的最大区别在于其内容和长度都是可变的，其类似于一个字符容器，对其内容进行修改时不会产生新的StringBuffer对象

实例：

1public class Example08 {
2	public static void main(String[] args) {
3		System.out.println("1、添加------------------------");
4		add();
5		System.out.println("2、删除------------------------");
6		remove();
7		System.out.println("3、修改------------------------");
8		alter();
9	}
10 public static void add() {
11	StringBuffer sb = new StringBuffer(); // 定义一个字符串缓冲区
12	sb.append("abcdefg"); // 在末尾添加字符串
13	System.out.println("append添加结果：" + sb);
14	sb.insert(2, "123"); // 在指定位置插入字符串
15	System.out.println("insert添加结果：" + sb);
16 }
17 public static void remove() {
18	StringBuffer sb = new StringBuffer("abcdefg");
19	sb.delete(1, 5); // 指定范围删除
20	System.out.println("删除指定位置结果：" + sb);
21	sb.deleteCharAt(2); // 指定位置删除
22	System.out.println("删除指定位置结果：" + sb);
23	sb.delete(0, sb.length()); // 清空缓冲区
24	System.out.println("清空缓冲区结果：" + sb);
25 }
26		public static void alter() {
27		StringBuffer sb = new StringBuffer("abcdef");
28		sb.setCharAt(1, 'p'); // 修改指定位置字符
29		System.out.println("修改指定位置字符结果：" + sb);
30		sb.replace(1, 3, "qq"); // 替换指定位置字符串或字符
31		System.out.println("替换指定位置字符（串）结果：" + sb);
32		System.out.println("字符串翻转结果：" + sb.reverse());
33	}
34 }

1. 添加操作
   • sb.append(“abc”) -> 在字符串尾部追加"abc"
   • sb.insert(3,“a”) -> 在下标为3的位置添加"a"
2. 删除操作
   • sb.delete(1,5) -> 指定位置删除（与String类的1substring方法相似，第一个参数为下标，第二个参数为位置）
   • sb.delete(2) -> 指定位置删除，删除下标为2的字符
   • sb.delete(0,sb.length) -> 清空缓冲区的操作
3. 修改操作
   • sb.setChar(1,“a”) -> 指定位置修改，将下标为1的字符修改为"a"
   • sb.replace(1,3,“qq”) -> 指定位置修改，将下标1到位置3的字符段修改为"qq"

3.1.3 StringBuilder类

StringBuilder类与StringBuffer类相似，StringBuilder类也可以对字符串进行修改，StringBuffer类和StringBuilder类的对象都可以被多次修改，并不产生新的未使用对象

StringBuilder类是JDK5中新加的类，它与StringBuffer之间最大不同在于StringBuffer的方法是线程安全的，也就是说StringBuilder不能被同步访问，而StringBuffer可以

但是相较于StringBuffer而言StringBuilder有速度优势

3.1.5 String、StringBuffer和StringBuilder三种字符串类的比较

（1）String类表示的字符串是常量，一旦创建后，内容和长度都是无法改变的。而StringBuilder和StringBuffer表示字符容器，其内容和长度可以随时修改

? 字符串仅用于表示数据类型 -> 使用String类

? 需要对字符串中的字符进行增删操作 -> 使用StringBuffer与StringBuilder类

? 有大量字符串拼接操作，不要求线程安全的情况 -> 采用StringBuilder更高效

? 有大量字符串拼接操作，如果需要线程安全 -> 使用StringBuffer

(StringBuffer多线程安全性大于StringBuilder)

（2）对于euals()方法的使用我们已经有所了解，但是在StringBuffer类与StringBuilder类中并没有被Object类的equals()方法覆盖，也就是说，equals()方法对于StringBuffer类与StringBuilder类来言并不起作用

（3）String类对象可以用操作符“+”进行连接，而StringBuffer类对象之间不能

3.2 System类与RunTime类

3.2.1 System类

System类定义了一些与系统相关的属性和方法，它所提供的属性和方法都是静态的，因此，想要引用这些属性和方法，直接使用System类调用即可

System类的常用方法：

1. arraycopy()方法：

arraycopy()方法用于将数组从源数组复制到目标数组，声明格式如下：

static void arraycopy(Object src,int srcPos,Object dest,
int destPos,int length)

● src：表示源数组。
● dest：表示目标数组。
● srcPos：表示源数组中拷贝元素的起始位置。
● destPos：表示拷贝到目标数组的起始位置。
● length：表示拷贝元素的个数。

在进行数组复制时，目标数组必须有足够的空间来存放拷贝的元素，否则会发生角标越界异常

实例：

public class Example10 {
    public static void main(String[] args) {
        int[] fromArray = { 10, 11, 12, 13, 14, 15 }; // 源数组
        int[] toArray = { 20, 21, 22, 23, 24, 25, 26 }; // 目标数组
        System.arraycopy(fromArray, 2, toArray, 3, 4); // 拷贝数组元素
        // 打印拷贝后数组的元素
        System.out.println("拷贝后的数组元素为：");
        for (int i = 0; i < toArray.length; i++) {
            System.out.println(i + ": " + toArray[i]);
        }
    }
}
//指定了从源数组中索引为2的元素开始拷贝，并且拷贝4个元素存放在目标数组中索引为3的位置

? 2.currentTimeMillis()方法:

currentTimeMillis()方法用于获取当前系统的时间，返回值是long类型的值，该值表示当前时间与1970年1月1日0点0分0秒之间的时间差，单位是毫秒，通常也将该值称作时间戳

实例：

public class Example11 {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();// 循环开始时的当前时间
        int sum = 0;
        for (int i = 0; i < 1000000000; i++) {
            sum += i;
        }
        long endTime = System.currentTimeMillis();// 循环结束后的当前时间
        System.out.println("程序运行的时间为："+(endTime - startTime)+"毫
                           秒");
     }
}

? 3.getProperties()和getProperty()方法

System类的getProperties()方法用于获取当前系统的全部属性，该方法会返回一个Properties对象，其中封装了系统的所有属性，这些属性是以键值对形式存在的。getProperty() 方法用于根据系统的属性名获取对应的属性值

（系统的Properties类）

? 4.gc()方法

在Java中，当一个对象成为垃圾后仍会占用内存空间，时间一长，就会导致内存空间的不足。针对这种情况，Java中引入了垃圾回收机制，有了这种机制，程序员不需要过多关心垃圾对象回收的问题，Java虚拟机会自动回收垃圾对象所占用的内存空间

除了等待Java虚拟机进行自动垃圾回收外，还可以通过调用System.gc()方法通知Java虚拟机立即进行垃圾回收，当一个对象在内存中被释放时，它的finalize()方法会被自动调用，因此可以在类中通过定义finalize()方法观察对象何时被释放

实例

class Person {
    // 下面定义的finalize方法会在垃圾回收前被调用
    public void finalize() {
        System.out.println("对象将被作为垃圾回收...");
    }
}
public class Example13{
    public static void main(String[] args) {
        // 下面是创建了两个Person对象
        Person p1 = new Person();
        Person p2 = new Person();
        // 下面将变量置为null，让对象成为垃圾
        p1 = null;
        p2 = null;
        // 调用方法进行垃圾回收
        System.gc();
        for (int i = 0; i < 1000000; i++) {
            // 为了延长程序运行的时间
        }
    }
}

Java虚拟机的垃圾回收操作是在后台完成的，程序结束后，垃圾回收的操作也将终止

System类还有一个常见的方法exit(int status)，该方法用于终止当前正在运行的Java虚拟机，其中参数status用于表示当前发生的异常状态，通常指定为0，表示正常退出，否则表示异常终止

3.2.2 RunTime类

表示虚拟机运行时的状态，它用于封装JVM虚拟机进程。每次使用java命令启动虚拟机都对应一个Runtime实例，并且只有一个实例，因此在Runtime类定义的时候，它的构造方法已经被私有化了(单例设计模式的应用)，对象不可以直接实例化。若想在程序中获得一个Runtime实例，只能通过以下方式:

Runtime run = Runtime.getRuntime();

Runtime类的常用方法

Runtime类的使用：

? 1.获取当前虚拟机信息

Runtime类可以获取当前Java虚拟机的处理器的个数、空闲内存量、最大可用内存量和内存总量的信息

1 public class Example14 {
2	public static void main(String[] args) {
3		Runtime rt = Runtime.getRuntime(); // 获取
4		System.out.println("处理器的个数: " + rt.availableProcessors()+"个
5         ");
6		System.out.println("空闲内存数量: " + rt.freeMemory() / 1024 / 1024 
7         + "M");
8		System.out.println("最大可用内存数量: " + rt.maxMemory() / 1024 / 
9         1024 + "M");
10         System.out.println("虚拟机中内存总量: " + rt.totalMemory() / 1024 / 
11         1024 + "M");
12	}
13 }

? 2.操作系统进程

Runtime类中提供了一个exec()方法，该方法用于执行一个dos命令，从而实现和在命令行窗口中输入dos命令同样的效果。例如，通过运行“notepad.exe”命令打开一个Windows自带的记事本程序

1 import java.io.IOException;
2 public class Example15{
3	public static void main(String[] args) throws IOException {
4		Runtime rt = Runtime.getRuntime(); // 创建Runtime实例对象
5		rt.exec("notepad.exe"); // 调用exec()方法
6	}
7 }

查阅API文档会发现，Runtime类的exec()方法返回一个Process对象，该对象就是exec()所生成的新进程，通过该对象可以对产生的新进程进行管理，如关闭此进程只需调用destroy()方法即可

public class Example {
	     public static void main(String[] args) throws Exception {
	       Runtime rt = Runtime.getRuntime(); // 创建一个Runtime实例对象
	       Process process = rt.exec("notepad.exe");//得到表示进程的Process对象
	       Thread.sleep(3000); // 程序休眠3秒
	       process.destroy(); // 杀掉进程
	}
}

3.3 Math类与Random类

3.3.1 Math类

实例

public class Example16 {
    public static void main(String[] args) {
        System.out.println("计算绝对值的结果: " + Math.abs(-10));
        System.out.println("求大于参数的最小整数: " + Math.ceil(5.6));
        System.out.println("求小于参数的最大整数: " + Math.floor(-4.2));
        System.out.println("对小数进行四舍五入后的结果: " + Math.round(-4.6));
        System.out.println("求两个数的较大值: " + Math.max(2.1, -2.1));
        System.out.println("求两个数的较小值: " + Math.min(2.1, -2.1));
        System.out.println("生成一个大于等于0.0小于1.0随机值: " + 
                           Math.random());
        System.out.println("开平方的结果: "+Math.sqrt(4));
        System.out.println("指数函数的值: "+Math.pow(2, 3));
    }
}

3.3.2 Random类

Java的java.util包中有一个Random类，它可以在指定的取值范围内随机产生数字

Random类的两个构造方法:

其中第一个构造方法是无参的，通过它创建的Random实例对象每次使用的种子是随机的，因此每个对象所产生的随机数不同

如果希望创建的多个Random实例对象产生相同的随机数，则可以在创建对象时调用第二个构造方法，传入相同的参数即可

第一种构造方法：

import java.util.Random;
public class Example17 {
    public static void main(String args[]) {
        Random r = new Random(); // 不传入种子
        // 随机产生10个[0,100)之间的整数
        for (int x = 0; x < 10; x++) {
            System.out.println(r.nextInt(100));
        }
    }
}

第二种构造方法：

import java.util.Random;
public class Example18 {
    public static void main(String args[]) {
        Random r = new Random(13); // 创建对象时传入种子
        // 随机产生10个[0,100)之间的整数
        for (int x = 0; x < 10; x++) {
            System.out.println(r.nextInt(100));
        }
    }
}

Random类的nextDouble()方法返回的是0.0和1.0之间double类型的值

nextFloat()方法返回的是0.0和1.0之间float类型的值

nextInt(int n)返回的是0（包括）和指定值n（不包括）之间的值（左闭右开区间）

import java.util.Random;
public class Example19 {
    public static void main(String[] args) {
        Random r1 = new Random(); // 创建Random实例对象
        System.out.println("产生float类型随机数: " + r1.nextFloat());
        System.out.println("产生double类型的随机数:" + r1.nextDouble());
        System.out.println("产生int类型的随机数:" + r1.nextInt());
        System.out.println("产生0~100之间int类型的随机数:" + 
                           r1.nextInt(100));
    }
}

3.4 日期时间类

在开发中经常需要处理日期和时间，Java提供了一套专门用于处理日期时间的API，在日期时间类中了包含LocalDate类、LocalTime类、Instant类、Duration类以及Period类等，这些类都包含在java.time包中

3.4.1 Instant类

Instant 类代表的是某个时刻（时间戳），其内部是由两个Long字段组成，第一部分保存的是标准Java计算时代（就是1970年1月1日开始）到现在的秒数，第二部分保存的是纳秒数

3.4.2 LocalData类

LocalData类仅用来表示日期。通常表示的是年份和月份，该类不能代表时间线上的即时信息,只是日期的描述

在LocalData类中提供了两个获取日期对象的方法now()和of(int year, int month, int dayOfMonth)

LocalData还提供了日期格式化、增减年月日等一系列的常用方法

实例：

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class Example21 {
    public static void main(String[] args) {
        //获取日期时分秒
        LocalDate now = LocalDate.now();
        LocalDate of = LocalDate.of(2015, 12, 12);
        System.out.println("1. LocalData的获取及格式化的相关方法--------");
        System.out.println("从LocalData实例获取的年份为："+now.getYear());
        System.out.println("从LocalData实例获取的月份："
                           +now.getMonthValue());
        System.out.println("从LocalData实例获取当天在本月的第几天："+
                           now.getDayOfMonth());
        System.out.println("将获取到的Loacaldata实例格式化为："+
                           now.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日")));
        System.out.println("2. LocalData判断的相关方法----------------");
        System.out.println("判断日期of是否在now之前："+of.isBefore(now));
        System.out.println("判断日期of是否在now之后："+of.isAfter(now));
        System.out.println("判断日期of和now是否相等："+now.equals(of));
        System.out.println("判断日期of是否时闰年："+ of.isLeapYear());
        //给出一个符合默认格式要求的日期字符串
        System.out.println("3. LocalData解析以及加减操作的相关方法---------");
        String dateStr="2020-02-01";
        System.out.println("把日期字符串解析成日期对象后为"+
                           LocalDate.parse(dateStr));
        System.out.println("将LocalData实例年份加1为："+now.plusYears(1));
        System.out.println("将LocalData实例天数减10为："
                           +now.minusDays(10));
        System.out.println("将LocalData实例指定年份为2014："+
                           now.withYear(2014));
    }
}

3.4.3 LocalTime类 与 LocalDataTime类

LocalTime类用来表示时间，通常表示的是小时分钟秒。与LocalData类一样，该类不能代表时间线上的即时信息，只是时间的描述。在LocalTime类中提供了获取时间对象的方法，与LocalData用法类似。
同时LocalTime类也提供了与日期类相对应的时间格式化、增减时分秒等常用方法，这些方法与日期类相对应

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
public class Example22 {
    public static void main(String[] args) {
        // 1. 获取当前时间，包含毫秒数
        LocalTime time = LocalTime.now();
        LocalTime of = LocalTime.of(9,23,23);
        System.out.println("从LocalTime获取的小时为："+time.getHour());
        System.out.println("将获取到的LoacalTime实例格式化为："+
                           time.format(DateTimeFormatter.ofPattern(" HH:mm:ss")));
        System.out.println("判断时间of是否在now之前："+of.isBefore(time));
        System.out.println("将时间字符串解析为时间对象后为："+ 
                           LocalTime.parse("12:15:30"));
        System.out.println("从LocalTime获取当前时间，不包含毫秒数："+
                           time.withNano(0));
    }
}