异常、经常使用类、GUI、正则

时间 2019-11-12

原文原文链接

1、异常

一、概述：
异常：就是程序在运行时出现不正常状况。将问题封装成对象就是异常。
异常由来：问题也是现实生活中一个具体事务，也能够经过 java 的类的形式进行描述。并封装成对象。其实就是 java 对不正常状况进行描述后的对象体现。

严重的问题：java 经过Error 类进行描述。通常不编写针对性代码对其进行处理。

非严重问题：java 经过Exception 类进行描述。可使用针对性的处理方式处理。

Error 类和 Exception 类都具备一些共性内容，向上抽取部分是父类 Throwable。Exception 类的错误表明那些诸如算术错误、数据格式错误、非法参数、非法存取等与程序有关的错误。Throwable 类是 java 语言中全部错误或异常的超类。这也就构成了 Java 的异常体系：

Throwable java

|---Error //一般出现重大问题如：运行的类不存在或者内存溢出等。正则表达式

|---Exception //运行时出现的一块儿状况 shell

|---RuntimeException //特殊异常类，抛时不须要声明数据库

Exception和Error的子类名都是以父类名做为后缀。编程

异常体系的特色：设计模式

1）异常体系中的全部类以及创建的对象都具有可抛性。数组

2）也就是说能够被throw和throws关键字所操做。安全

3）只有异常体系具有这个特色。

二、异常分类：

1）编译时被检测异常：网络

该异常在编译时，若是没有处理(没有抛也没有try)，编译失败。该异常被标识，表明着能够被处理。多线程

2）运行时异常(编译时不检测)：

在编译时，不须要处理，编译器不检查。该异常的发生，建议不处理，让程序中止，须要对代码进行修正例如：RuntimeException以及其子类。

三、异常处理：

格式：

try{

//须要被监测的代码

}catch(异常类常量){

//处理异常的代码（处理方式）

}finally{

//必定会执行的代码

}

Note:

1) catch 小括号中的参数表明要捕获哪一种异常，应该写 Exception 或其某个子类的对象。

2) 若发生异常，则 try 语句块的执行发生在发生问题的位置中断，后面若还有语句将被忽略，执行流程转移到捕获该异常的 catch 语句块中。

3) 若不发生异常，则 catch 语句块中的代码不会被执行。

4) 不管是否发生异常 finally 块中的代码必定会被执行。通常用于关闭资源码（好比：关闭数据库），由于资源必须释放。

5) try语句块不能单独出现，catch 和 finally 必须至少有一个跟在 try 后面。

6) catch 语句块能够写多个，每一个 catch 捕捉不一样的异常，一次跟在 try 语句块的后面，发生异常时，程序将从上向下找到最早匹配的 catch 语句块去执行，所以子类级别的异常要写在前面，父类级别的异常靠后。

7) finally 只有一种状况不会执行：当执行到System.exit(0);后fianlly 不会再执行。

四、throw和throws

throw定义在函数内，用于抛出异常对象。

throws定义在函数上，用于抛出异常类，能够抛出多个用逗号隔开。

当函数内容有throw抛出异常对象，并未进行try处理。必需要在函数上声明，不然编译失败。
Note：throws 和 throw 的区别：
throws 使用在函数上（写在小括号和大括号之间）。throw 使用在函数内。
throws 后面跟的异常类。能够跟多个。用逗号隔开。throw 后跟的是异常对象。

使用格式：

返回值类型方法名称 throws 异常类{

if(发生异常){

throw 异常类对象;

}

Note： RuntimeException除外。也就说，函数内若是抛出的RuntimeExcpetion异常，函数上能够不用声明。

常见方法操做：

String getMessage（）；//获取异常的信息。返回字符串。

toString（）；//获取异常类名和异常信息，返回字符串。

printStackTrace(); //获取异常类名和异常信息，以及异常出如今程序中的位置.返回值void.

//其实JVM默认的异常处理机制，就是在调用printStackTrace方法，打印异常的堆栈的跟踪信息。

printStackTrace(PrintStream s)// 一般用该方法将异常内容保存在日志文件中，以便查阅。

五、自定义异常类

由于项目中会出现特有的问题，而这些问题并未被 java 所描述并封装对象。因此对于这些特有的问题能够按照 java 的对问题封装的思想。将特有的问题，进行自定义的异常封装。
1）自定义异常必须是自定义类继承 Exception。
缘由：异常体系有一个特色，由于异常类和异常对象都被抛出，他们都具有可抛性。这个可抛性是 Throwable 这个体系中独有特色，只有 Throwable 体系中的类和对象才能够被 throws 和 throw 操做。
2）自定义异常时：若是该异常的发生，没法在继续进行运算，就让自定义异常继承RuntimeException。

3) 当自定义了异常类继承Exception后，若是未在类中定义异常信息，那么经过toString方法打印出来的结果就只有自定义的异常类名，不会显示异常信息。
4) 要定义自定义异常的信息时，可使用父类已经定义好的功能。异常信息传递给父类的构造函数。由于父类中已经把异常信息的操做都完成了。因此子类只要在构造时，将异常信息传递给父类经过super语句。那么就能够直接经过getMessage方法获取自定义的异常信息。

示例以下：

class MyException extends Exception {
	private String msg;

	MyException(String msg) {
		super(msg);// 返回自定义的输入信息
	}
}

六、异常的好处：
  1）将问题进行封装。
  2）将正常流程代码和问题处理代码相分离，方便于阅读。
七、异常的处理原则：
  1）处理方式有两种：try 或者 throws。
  2）调用到抛出异常的功能时，抛出几个，就处理几个。一个 try 对应多个 catch。多个 catch，父类的 catch 放到最下面。
  3）catch 内，须要定义针对性的处理方式。不要简单的定义 printStackTrace，输出语句。也不要不写。
  4）当捕获到的异常，本功能处理不了时，能够继续在 catch 中抛出。
八、异常的注意事项：
1）问题能在内部解决就解决，坚定再也不往外抛出。
2）catch是用于处理异常的，若是没有catch就表明异常没有被处理，若是该一场是编译时异常那必需要进行声明。
3）在子父类覆盖时：子类抛出的异常必须是父类的异常的子类或者子集。若是父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能再抛。
小练习示例：

/*
老师使用电脑讲课。

描述电脑：
	一、电脑运行
	二、电脑重启
描述电脑问题：
	一、电脑蓝屏了
	二、电脑起火了

描述老师：
	一、老师使用电脑
	二、老师讲课。
描述老师可能出现的问题：
	一、老师不能继续讲课了，他让同窗们本身作练习。

*/

//电脑蓝屏了
class BlueScreenException extends Exception
{
	BlueScreenException(String message)
	{
		super(message);
	}
}
//电脑起火了
class FireBreakingException extends Exception
{	
	FireBreakingException(String message)
	{
		super(message);
	}
}

//老师没法继续上课
class StopTeachException extends Exception
{	
	StopTeachException(String message)
	{
		super(message);
	}
}
class Computer
{
	int start=1;
	//电脑启动
	void run()throws BlueScreenException,FireBreakingException
	{
		if(start==2)
			throw new BlueScreenException("Computer_BlueScreen");
		else if(start==3)
			throw new FireBreakingException("Computer_FireBreaking");
		System.out.println("Computer_run");
	}
	//电脑重启
	void reset()
	{	
		start=1;
		System.out.println("Computer_reset");
	}
}

class Teacher
{
	private String name;
	private Computer cpt;

	//对老师进行初始化
	Teacher(String name)
	{
		this.name=name;
		cpt=new Computer();
	}

	//老师开始讲课
	public void teach()throws StopTeachException
	{
		try
		{
			cpt.run();
			
		}
		catch (BlueScreenException e)
		{
			//System.out.println(e.getMessage());
			cpt.reset();
		}
		catch (FireBreakingException e)
		{
			test();
			//System.out.println(e.getMessage());
			throw new StopTeachException("Teather_StopTeach："+e.getMessage());
		}

		System.out.println(name+"Teacher_teaching");
	}
	void test()
	{
		System.out.println("学生作练习");
	}

}
class ExceptionTest
{
	public static void main(String[] args) 
	{
		Teacher t=new Teacher("毕老师");
		try
		{
			t.teach();
		}
		catch (StopTeachException e)
		{
			System.out.println(e.toString());
			System.out.println("换老师或者放假");
		}
	}
}

2、经常使用类

一、Object类：
概述：存在于java.lang包中，是全部类的根类、超类。Java 中的每个类都直接或间接地使用Object做为父类，全部对象都实现这个类的方法。全部类对 Object类的继承都是java默认的，无需使用 extends 明确表示。Object 类中提供了 11 个成员方法，也就是说全部其余类都具有这 11 个方法。其中最经常使用的方法：
public boolean equals(Object obj); //比较两个对象是否相等
public String toString(); //返回该对象的字符串表示
void finalize(); // 当垃圾回收器肯定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
Class getClass(); //获取对象的字节码文件的描述类，后面再讲反射的时候还会在说这个类。String name = s.getClass().getName();
int hashCode(); // 获取对象的哈希值。其实就是对象的内存地址值十进制表示若自定义类中有与 Object 类中相同的方法功能，没有必要从新定义。
//只要沿袭父类中的功能，创建本身特有的内容便可，也就是覆盖。
equals()：咱们获取对象后，比较它的地址值意义不大。因此也会对这个方法进行重写。重写要完成什么功能，是根据需求定的。
"==" 和 equals 的用法：
"==":
1) 能够用于比较基本数据类型，比较的就是基本数据类型的值是否相等。
2) 能够用于比较引用数据类型，比较的是对象的地址值是否相等。
equals:
1) equals 只能用于比较引用数据类型的。
2) Object 提供的 equals 是用于比较对象地址值是否相同。
3) 自定义类中，若是重写了 equals 方法，那么就是按照你本身的需求来比较的。
toString()：
表示格式：getClass().getName()+"@"+Integer.toHexString(hashCode());通常咱们输出对象名的时候，其实底层调用的就是该对象的 toString()方法。这种返回没有意义，因此，咱们会重写这个方法，显示类的成员变量信息。
二、String类：
概述：多个字符组成的一个序列，叫字符串。生活中不少数据的描述都采用的是字符串的，并且咱们还会对其进行操做。字符串是一个特殊的对象，是一个被 final 修饰的类，因此不可能有子类。字符串一旦初始化就不能够被改变（此处指的是内存中的地址值不可改变）。

构造方法：

1）String():无参构造
eg： String s = new String();
s = "hello";
  2）String(byte[] bys): 传一个字节数组做为参数
eg： byte[] bys = {97,98,99,100,101};
  String s = new String(bys);
  3）String(byte[] bys,int index,int length): 把字节数组的一部分转换成一个字符串
eg：byte[] bys = {97,98,99,100,101};
String s = new String(bys,1,2);
  4）String(char[] chs): 传一个字符数组做为参数
eg：char[] chs = {'a','b','c','d','e'};
       String s = new String(chs);
  5）String(char[] chs,int index,int length): 把字符数组的一部分转换成一个字符串
eg：char[] chs = {'a','b','c','d','e'};
String s = new String(chs,1,3);
  6）String(String str): 把一个字符串传递过来做为参数
eg：String ss = new String(s);
  7）直接把字符串常量赋值给字符串引用对象(最经常使用)
eg：String s = "hello";
常见方法：

1）获取

1.1字符串中包含的字符数，也就是字符串的长度

int length（）：//获取长度。

1.2根据位置获取位置上的某个字符

char charAt（int index）：//当访问到字符串中不存在的角标时，会发生字符串角标越界的错误。

1.3根据字符获取该字符存在字符串的位置

int indexOf（int ch）：//返回的是ch在字符串中第一次出现的位置。//传入的是字符对应的ASCII码。//若是没有找到，返回-1。

int indexOf（int ch，int fromIndex）：//从fromIndex指定位置开始，获取ch在字符串中出现的位置。

int indexOf（String str）：//返回的是str在字符串中第一次出现的位置。

int indexOf（String str，int fromIndex）：//从fromIndex指定位置开始，获取str在字符串中出现的位置。

int lastIndexOf（）：//反向索引

2）判断

2.1字符串中是否包含某一个子串

boolean contains（str）；

Note：indexOf（str）能够索引str第一次出现的位置，若是返回-1表示该str不在字符串中存在。因此，也能够用于对指定判断是否包。如：if（str.indexOf（“aa”）！=-1）并且该方法既能够判断，又能够获取出现的位置。若是只为判断，用contains。

2.2字符串中是否有内容

boolean isEmpty()；//原理就是判断长度是否为0。

2.3字符串是不是以指定内容开头

boolean startsWith（str）；

2.4字符串是不是以指定内容结尾

boolean endsWith（str）；

2.5判断字符串内容是否相同，复写了Object类中的equals方法

boolean equals（str）；

2.6判断内容是否相同，并忽略大小写。

boolean equalsIgnoreCase（）；

3）转换

3.1将字符数组转成字符串

构造方法：String(char[])；

String(char[],offset,count)；//将字符数组中的一部分转成字符串。

静态方法：

static String copyValueOf(char[])；

static String copyValueOf(char[] data,int offset ,int count )；

static String valueOf(char[])；

3.2将字符串转成字符数组

char[] toCharArray()；

3.3将字节数组转成字符串

String(byte[])；

String(byte[],offset,count)；//将字节数组中的一部分转成字符串。count表示个数。

3.4将字符串转成字节数组

byte[] getBytes()；

3.5将基本数据类型转成字符串

String valueOf(int)；

String valueOf(double)；

Note：字符串和字节数组在转换过程当中，是能够指定编码表的。

4）替换

String replace(oldchar,newchar)；//返回的是一个新字符串。若是要替换的字符不存在，返回的仍是原字符串。

5）切割

String[] split(regex)；//涉及到正则表达式的点，不能做为切割字符串的regex。

6）子串，获取字符串中的一部分

String substring(begin)；//从指定位置开始到结尾。若是角标不存在，会出现字符串角标越界异常。

String substring(begin,end)；//包含头，不包含尾。

7）转换，去除空格，比较

7.1将字符串转成大写或小写

String toUpperCase();

String toLowerCase();

7.2将字符串两端的多个空格去除

String trim();

7.3对两个字符串进行天然顺序的比较

int compareTo(String);

基于上述知识点，几个小练习演示以下所示：

/*
 * 练习：一、字符串反转
 *       二、获取一个字符串在另外一个字符串中出现的次数
 *       三、有两个字符串，找出两个字符串中最大相同那个字符串
 */

public class StringTest {

	// 一、字符串反转
	public static String reverseString(String str) {
		char[] ar = str.toCharArray();// 将字符串转成字符数组
		reverse(ar);// 将字符数组进行反转
		return new String(ar);// 返回反转后的字符串
	}

	// 逐个调换字符数组中的对应位置的字符
	public static void reverse(char[] ar) {
		for (int i = 0, j = ar.length - 1; i < j; i++, j--) {
			swap(ar, i, j);
		}
	}

	// 自定义反转数组中的两个元素
	private static void swap(char[] ar, int i, int j) {
		char temp = ar[i];
		ar[i] = ar[j];
		ar[j] = temp;
	}

	// 二、获取一个字符串在另外一个字符串中出现的次数
	public static int getNumOfString(String str, String key) {
		int num = 0;// 定义计数器
		int index = 0;// 定义脚标，用于记录查询位置
		while ((index = str.indexOf(key, index)) != -1) {
			// indexOf(key) 或者indexOf(key,beginIndex)均可以
			// str = str.substring(index + key.length());
			index = index + key.length();// 下一次的查询其实位置是前一次查询返回值加上字符串长度，以此保证每次都是日后偏移查询
			num++;// 查到一次，计数器自增1
		}
		return num;
	}

	// 三、有两个字符串，找出两个字符串中最大相同那个字符串
	public static String getMaxSubString(String str1, String str2) {
		// 不论传进来的两个字符串谁更长，自定义maxString、minString来指向长字符串和短字符串
		String maxString = str1.length() > str2.length() ? str1 : str2;
		String minString = maxString == str1 ? str2 : str1;

		String maxSubString = null;
		for (int i = 0; i < minString.length(); i++) {// 控制在最短字串长度内
			// 依次递减短字符串子串
			for (int j = 0, k = minString.length() - i; k <= minString.length(); j++, k++) {
				maxSubString = minString.substring(j, k);// 获取短字符串的子串
				if (maxString.indexOf(maxSubString) != -1) {// 若是包含在长字符串中则代表找到了
					return maxSubString;
				}
			}
		}
		return "-1";
	}

	public static void main(String[] args) {
		String str = "abc cde";
		String s1 = "ascasfhelloasfasf v";
		String s2 = "ashellolkkd";
		System.out.println(reverseString(str));
		System.out.println(getNumOfString(str, "c"));
		System.out.println(getMaxSubString(s2, s1));
	}
}

结果以下所示：

三、StringBuffer类
概述：字符缓冲区类，是一个容器，一个线程安全的可变字符序列。 StringBuffer 能够对字符串内容进行增删改查等操做，不少方法和 String 相同。

特色：长度是可变化的。能够直接操做多个数据类型。最终会经过 toString 方法变成字符串。

常见操做：

1）存储

StringBuffer append()：将指定数据做为参数添加到已有数据的结尾处。

StringBuffer insert(intoffset ,数据)：能够将数据插入到指定offset位置。

2）删除

StringBufferedelete(start,end)：删除缓冲区中的数据，包含start，不包含end。

StringBuffer deleteCharAt(index)：删除指定位置的字符。//清空缓冲区：对象.delete(0,对象.length());

3）获取

char charAt(int index)；

int indexOf(String str)；

int lastIndexOf(String str)；

int length()；

String substring(int start,int end)；

4）修改

StringBuffer replace(int start,int end,String str)；

void setCharAt(int index,char ch)；

5）反转

StringBuffer reverse()；

6）将缓冲区中指定数据存储到指定字符数组中

voidgetChars(int srcBegin, int srcEnd,char[] dst,int dstBegin)
四、StringBuilder类
概述：StringBuilder在JDK1.5 版本以后出现的，一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用做 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种状况很广泛）。若是可能，简易优先采用 StringBuilder 类，由于此类比 StringBuffer 效率高。
StringBuilder 和 StringBuffer 的功能是同样的，可是有区别：
StringBuffer(JDK1.0)是线程安全的。通常用于多线程。
StringBuilder(JDK1.5)不保证线程安全。通常用于单线程。
Note：通常来讲，咱们写的程序都是单线程的，因此，用 StringBuilde，效率高，之后开发建议使用 StringBuilder。

五、System类
概述：System类包含一些有用的类字段和方法。它不能被实例化。在System类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。其中的属性和方法全是静态。
字段摘要：
  err “标准”错误输出流
  in “标准”输入流；默认是键盘
  out “标准”输出流；默认是控制台
方法：
  static void setIn(InputStream in) 从新分配“标准”输入流
  static void setOut(PrintStream out) 从新分配“标准”输出流
  static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
  static long currentTimeMillis(); 返回以毫秒为单位的当前时间。
  exit(int status); 退出当前虚拟机。0 以外的表示非正常退出。
  static void gc(); 运行垃圾回收器
  getProperty(); 获取指定键提示的系统属性
  static Properties getProperties(); 获取系统属性信息，肯定当前的系统属性。
//由于 Properties 是 Hashtable 的子类，也就是 Map 集合的一个子类对象。那么能够经过map 的方法取出该集合中的元素。该集合中存储都是字符串。没有泛型定义。
六、Runtime类
概述：每一个 Java 应用程序都有一个 Runtime 类实例，使应用程序可以与其运行的环境相链接。能够经过 getRuntime()方法获取当前运行时，应用程序不能建立本身的Runtime 类实例。
理解：此类没有提供构造函数。因不能直接 new 建立本身的类对象，会联想到类中全部方法都是静态的。可是该类中还有非静态方法。说明该类确定会提供了方法获取本类对象。并且该方法是静态的，并返回值类型是本类类型。由这个特色能够看出该类使用了单例设计模式完成。该方式为：static Runtime getRuntime(); //返回与当前 Java 应用程序相关的运行时对象。
其余方法：
  Process exec(String conmand); //在单独的进程中执行指定的字符串命令。

Note：在使用时容易发生异常，须要在方法上抛出异常。其中的参数大多数为 String 类型，能够是一个应用程序或者其地址，做用是执行打开一个应用程序。Process 是一个抽象类，不须要本身去实现它，由于计算机底层自动实现了该类。其中的方法有：Abstract void destroy()用以杀掉子进程。
七、Date类
概述：表示特定的瞬间，精确到毫秒。在 JDK1.1 开始，使用 Calendar 类实现日期和时间字段之间转换。使用 DateFormat 类来格式化和解析日期字符串。Date 中的相应大部分方法已废弃。UTC 为世界标准时间。GMT 为民间标准（格林威治标准时）
构造方法:
public Date(); //分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
  public Date(long Date); //分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00GMT）以来的指定毫秒数。
方法摘要：
  int compareTo(Date anotherDate) // 比较两个日期的顺序。
  boolean equals(Object obj) //比较两个日期的相等性。
  public void getTime(); //返回当前时间的毫秒值
  public void setTime(); //设置当前毫秒值
  boolean after(Date when); //测试此日期是否在指定日期以后。
  boolean before(Date when);// 测试此日期是否在指定日期以前。
long 与 Date 类型转换：
  System.currentTimeMillions();//获取系统当前时间，返回值 long 类型
  Date.getTime();(注：需先建立 Date 对象)
Date 与 String 类型转换：
  public final String format(Date date);
获取系统时间的两种方法的区别：
第一种：
  Date time=new Date(); //建立时间对象

  System.out.println(time); //输出系统时间
第二种：
  long l=System.currentTimeMillis();//获取系统当前时间
  Date d=new Date(l);
  System.out.println(d);
分析：两种方法的 Date 时间运行的结果相同,它们都建立时间对象 Date，区别在于第二种方法时间对象引用了系统的 long 型时间。而 System.currentTimeMillis()方法返回值为 long 型，还能够利用此方法计算应用程序的运行时间。
八、DateFormat与SimpleDateFormat类
DateFormat：使用与语言无关的方式格式化和并解析日期和时间。是一个日期格式化子类的抽象类。该类能够进行格式化也能够解析字符串。
方法：
String format(Date date);//将 Date 日期格式化为日期时间字符串。

SimpleDateFormat：是一个以与语言环境有关的方式来格式化和解析日期的具体类。它容许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

方法：
  SimpleDateFormat(); // 用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
  SimpleDateFormat(String pattern); //参数 Date，建立格式对象。用给定的模式和默认语言环境的日期格式符号构造
格式化日期时间步骤：
  1)在建立对象时指定一个格式：YYYY 年 MM 月 dd 日 HH：mm:ss (若是调用格式化器无参构造，此步骤省略)
  2)建立一个格式器 SimpleDateFormat
  3)建立一个日期对象 Date d
  4)使用格式化器的 formate 方法格式化 d，获得想要的格式字符串。
Note：hh 表示 12 小时制（1—12），HH 表示 24 小时制（0—23），更多日期和时间模式请参考SimpleDateFormat类的API说明
示例以下：

import java.text.SimpleDateFormat;
import java.util.Date;

/*
 * Date类：
 * 一、获取系统当前时间
 * 二、利用SimpleDateFormat类格式化指定时间
 */
public class DateDemo {
	public static void main(String[] args) {

		// 第一种获取方式
		Date date1 = new Date();

		// 第二种获取方式
		long time = System.currentTimeMillis();
		Date date2 = new Date(time);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
		String needDate = sdf.format(date2);
		System.out.println("系统时间戳：" + date2);
		System.out.println("格式化时间：" + needDate);
		System.out.println("格式化模板：" + sdf.toPattern());
	}
}

结果以下：

九、Calendar类
概述：Calendar 是一个抽象类。时间点（某一时刻）
方法：
getInstance(); //获取日历（使用默认时区和语言环境获取一个日历），不是经过子类建立，而是经过父类方法 getInstance()返回一个 Calendar对象。
int get(int field);//参数是日历字段值 ,月份的统计是从 0 到 11 的
void set(); //设置日历字段。
abstract void add(int field,int amount); //根据日历规则，为给定的日历字段添加或者减去指定的时间量。
如下返回值类型为 int：
年： calendar.get(Calendar.YEAR);
月: calendar.get(Calendar.MONTH);
日: calendar.get(Calendar.DAY_OF_MONTH);
星期: calendar.get(Calendar.DAY_OF_WEEK);
时： calendar.get(Calendar.HOUR_OF_DAY);
分： calendar.get(Calendar.MINUTE);
秒： calendar.get(Calendar.SECOND);
示例以下：

import java.util.Calendar;

/*
 * Calendar类：
 * 	set() 给指定日历设置给定值
 * 	get() 获取指定字段
 * 
 * 	add() 在指定时间上加上一个指定的值再显示
 */
public class CalendarDemo {

	public static void main(String[] args) {

		// 获取某年2月的天数，例如2012年的2月有几天
		Calendar c = Calendar.getInstance();
		// 3月1日减一天就是2月的最后一天，Calendar月份范围0-11
		c.set(2012, 2, 1);
		c.add(Calendar.DAY_OF_MONTH, -1);
		System.out.println(c.get(Calendar.YEAR) + "年"
				+ (c.get(Calendar.MONTH) + 1) + "月共有"
				+ c.get(Calendar.DAY_OF_MONTH));
		// 日历设置到2个月后
		c.add(Calendar.MONTH, 2);
		System.out.println("日历设置到2个月后是" + c.get(Calendar.YEAR) + "年"
				+ (c.get(Calendar.MONTH) + 1) + "月"
				+ c.get(Calendar.DAY_OF_MONTH) + "日");
	}

}

结果以下：

十、Math类（静态工具类）
Math:包含用于数学基本运算的方法。
字段摘要：
E：天然对数的底数。（double）
PI： π，即圆周与直径之比。（double）
方法：
abs(); //绝对值
cbrt(); //立方根
ceil(); //返回大于等于参数的最小整数（double）特别注意负数的值
floor(); //返回小于等于参数的最小整数（double）
round(); //四舍五入（int 或 long）原理：原数加 0.5 判断
random(); //伪随机数（0——1 之间的数，不包含 1）
max(); //返回两个数中最大值
min(); //返回两个数中最小值
Note： 此处的 random 类与 Math 类中的 random()方法做用相似。Random 类能够生成对象，用其下的 next()方法或者 nextInt()方法生成伪随机数。其中有方法：
int next(int bits); //生成下一个伪随机数
int nextInt(int n); //返回下一个伪随机数，在 0 与指定值（不包括指定值）之间均匀分布的 int 值。
3、GUI
一、概述：
GUI：Graphical User Interface(图形用户接口)。用图形的方式，来显示计算机的操做图形界面。方便、直观。
CLI：Command line User Interface(命令行用户接口)。就是 DOS 命令行操做。不直观。
Java 为 GUI 提供的对象，都存在 java.Awt 和 javax.Swing 两个包中。Java中对于图形化编程有个完整的继承体系：

如图所示：

Awt 与 Swing：
java.Awt: (Abstract Window Toolkit,抽象窗口工具集)，须要调用本地系统方法实现功能。属重量级控件。跨平台性较弱。
javax.Swing: 在 AWT 基础上，创建一套图形界面系统，其中提供了更多组件，并且彻底由 Java 实现。加强了可移植性，属轻量级控件。
Note：开发时，制做图形化界面时，通常须要导入两个包，import java.awt.*; 和 import java.awt.event.*;。
二、布局管理器
布局：容器中组件的排放方式。
常见的布局管理器：
FlowLayout(流式布局管理器)：从左到右的顺序排列。Panel 默认的布局管理器。
  BorderLayout(边界布局管理器):东南西北中。Frame 默认的布局管理器。
  GridLayout(网络布局管理器)：规则的矩阵。
  GardLayout（卡片布局管理器）：选项卡。
  GridBagLayout(网格包布局管理器):非规矩的矩阵。
三、Component
Component 是一个具备图形表示能力的对象，可在屏幕上显示，并可与用户进行交互。经常使用子类：Window、Panel(面板，不能单独存在)。Window 经常使用子类：Frame、DialogFrame 类：是带有标题和边框的顶层窗口。若显示窗体，必须设置 setVisible 显示。设置 Frame 时，有一个默认的管理器是边界式布局（BorderLayout）。
主要方法：
  add() //添加组件（含参数）
  setVisible(Boolean b) //根据参数的值来显示或隐藏组件
  setSize() //设置窗体大小，参数为窗口的横坐标和纵坐标
  setLocation() //设置窗体在本地位置，参数为横、纵坐标
  setLayout() //设置布局管理器（参数能够是相应布局管理器的对象）
  setBounds() //移动组件并调整其大小，参数是 4 个坐标（左边距、右边距、宽、高）
  addMouseListener() //添加指定的鼠标监听器
  addKeyListener() //添加键盘监听事件
建立图形化界面的步骤：
  1）建立 frame 窗体。
  2）对窗体进行基本设置。好比大小，位置，布局。
  3）定义组件。
  4）将组件经过窗体的 add 方法添加到窗体中。
  5）让窗体显示，经过 setVisible(true)
四、事件监听机制
组成：
事件源、事件（Event）、监听器（Listener）、事件处理（引起事件后处理方式）
事件源：就是 awt 包或者 swing 包中的那些图形界面组件。
事件：每个事件源都有本身特有对应事件和共性事件。
监听器：将能够触发某一个事件的全部动做都封装到监听器中。
事件处理：对时间元传来的信息进行处理并反馈出去。

Note：在 java 中事件源、事件（Event）、监听器（Listener）都已定义好，直接获取其对象使用。只须要作事件处理（对产生的动做进行处理）。
五、Window（窗体事件）
Window :
addWindowListener( ) //添加窗口事件监听器
windowListener 接口：复写方法，实例化对象，才能使用。但它有一个已复写所有方法的子类WindowAdapter。
WindowAdapter：接收窗口事件的抽象适配器类。此类中的方法为空。它是一个没有抽象方法的抽象类，目的是不能建立对象。此类存在的意义是方便建立监听器对象。使用：由于 WindowListener 的子类 WindowAdapter 已经实现了 WindowListener 接口。并覆盖了其中的全部方法。那么我只要继承自 Windowadapter 覆盖我须要的方法便可。具体方法以下：
windowClosing( ) //关闭窗口
  windowIconified( ) //窗口最小化状态
  windowOpened() //打开窗口
  windowActivated() //前置窗口
  windowClosed() //关闭窗口
  wind owDeactivated() //后置窗口
六、Button（含 Action 事件）
方法：
  addActionListener() //添加指定的动做监听器
ActionListener 接口：用于接收操做事件的监听器接口。是少数没有适配器接口的其中一个。其中只有一个方法 actionPerformed(),做用：发生操做时调用。
七、鼠标事件和键盘事件
MouseListener: 用于接收组件上“感兴趣的”鼠标事件（eg：按下、释放、单击、进入或离开）的监听器接口。有适配器。
方法：
  mouseClicked(MouseEvent e) //鼠标单击（按下并释放）
  mouseEntered(MouseEvent e) //鼠标进入组件
  mouseExited(MouseEvent e) //鼠标离开组件
  mousePressed(MouseEvent e) //鼠标按下时
  mouseReleased(MouseEvent e) //鼠标释放时
Note：鼠标按下与 Action 事件同时存在操做时，鼠标按下先发生。
MouseEvent: (适配器)
成员变量：static int mouse_clicked
方法：
  int getClickCount() //返回鼠标单击次数
keyListener: 有适配器。
  static int VK_ENTER
  keyPressed(keyEvent e) //按下某个键时调用此方法
  keyReleased(keyEvent e) //释放某个键时调用此方法
  keyTyped(keyEvent e) //键入某个键时调用此方法
keyEvent: (适配器)
  char getkeyChar() //返回与此事件中的键相关联的字符
  int getkeyCode() //获取键盘对应的码
  static String getKeyText(int keyCode) //经过码获取对应的键盘字符
Note：InputEvent 类中 isControlDown() 判断 ctrl 键是否被按下；InputEvent 类中 consume() 以非默认方式处理事件，屏蔽键
八、TextField 和 TextArea
TextField: 文本框类；TextArea:  文本区域
构造方法: TextField() //建立文本框。带参数能够设置文本框大小，只能指定列（宽）。
TextArea()   //建立文本区域，既能指定行数又能指定列数，还能够指定文本区域内含有的默认文字
方法：
append(String str) //追加文本。将给定文本追加到文本区的当前文本在他们的父类 TextComponent 中，
String getText() //获取文本的方法
setText()   //设置填充文本内容，参数为内容
九、Dialog 和 Label
Dialog: 是一个带标题和边界的顶层窗口。对话框，默认边界布局管理器，通常对话框不能单独存在，必须依赖于窗体。
FileDialog: 是 Dialog 的子类。显示一个对话框窗口，用户能够从中选择文件。构造参数能够有模式：FileDialog.LOAD(打开，加载文件)和 FileDialog.SAVE（保存）默认打开。
方法：
String getFile() //获取选定文件
String getDirectory() //获取文件对话框目录
Label: 标签，最经常使用的控件之一，setText()来设置指定文本
十、MenuBar、MenuItem、Menu
MenuBar: 封装绑定到框架的菜单栏的平台概念。为了将该菜单栏与Frame对象关联，能够调用该框架的setMenuBar方法，add()用来添加菜单栏。
MenuItem：菜单项
Menu：菜单条，其中add()用来将指定菜单项或者标签添加到菜单栏。
Note：MenuBar 包括 Menu，Menu 包括 MenuItem、Menu（带箭头）。MenuBar 为菜单栏，通常一个窗口中只有一个；Menu 菜单项，能够设置多个，若并排显示，都添加进 MenuBar；若显示在菜单项中（带二级箭头菜单条），则 Menu 嵌套（添加）Menu 便可。MenuItem 子菜单，是最终子菜单。能够设置多个，添加进 Menu。
GUI示例以下：

/*
 GUI：文本框和文本区域功能等（对话框）
 */

import java.awt.*;
import java.awt.event.*;
import java.io.*;

public class MyWindowDemo {
	private Frame f;
	private TextField tf;
	private Button but;
	private TextArea ta;

	private Dialog d;
	private Label lab;
	private Button okBut;

	MyWindowDemo() {
		init();
	}

	public void init() {
		f = new Frame("my window");
		f.setBounds(300, 100, 600, 500);
		f.setLayout(new FlowLayout());

		tf = new TextField(60);

		but = new Button("转到");

		ta = new TextArea(25, 70);

		// 此处不该该直接初始化对话框等组件，通常处理用户出错问题再建立使用对话框
		// 这里只为演示看效果。
		d = new Dialog(f, "提示信息-self", true);
		d.setBounds(400, 200, 240, 150);
		d.setLayout(new FlowLayout());
		lab = new Label();
		okBut = new Button("肯定");

		d.add(lab);
		d.add(okBut);
		// 注意：不要将对话框添加到frame中，只有出现问题才会调用出现对话框

		f.add(tf);
		f.add(but);
		f.add(ta);

		myEvent();
		f.setVisible(true);
	}

	private void myEvent() {

		okBut.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				d.setVisible(false);
			}
		});
		d.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				d.setVisible(false);
			}
		});

		tf.addKeyListener(new KeyAdapter() {
			public void keyPressed(KeyEvent e) {
				if (e.getKeyCode() == KeyEvent.VK_ENTER)
					showDir();
			}
		});

		but.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				showDir();

			}
		});

		f.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
	}

	private void showDir() {
		String dirPath = tf.getText();

		File dir = new File(dirPath);

		if (dir.exists() && dir.isDirectory()) {
			ta.setText("");// 清空文本
			String[] names = dir.list();
			for (String name : names) {
				ta.append(name + "\r\n");// 追加文本
			}
		} else {
			String info = "您输入的信息：" + dirPath + "是错误的。请重输";
			lab.setText(info);
			d.setVisible(true);
		}
	}

	public static void main(String[] args) {
		new MyWindowDemo();
	}
}

结果以下：

4、正则表达式
一、概述：符合必定规则的表达式。一些特殊符号的使用。
做用：用于操做字符串
特色：用于一些特定的字符串来表达一些代码操做---到达简化效果
好处：能够简化对字符串的校验操做
弊端：符号定义越多，正则越长，阅读性极差
二、正则表达式构造摘要（非捕获组）主要：
----字符类：只能规则一个字符
[abc]  判断字符串当中某一个字符位上出现的字符。字符是 a、b 或 c。
  [^abc]  任何字符，只要不是 a、b、c 便可。
  [a-zA-Z]  a 到 z 或 A 到 Z，两头的字母包括在内（范围）
  [a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
  [a-z&&[def]] d、e 或 f（交集）
----预约义字符类：这里的\不是转义字符。使用时，记得用\\
  .  任何字符（与行结束符可能匹配也可能不匹配）
  \d  数字：[0-9]
  \D  非数字： [^0-9]
  \s  空白字符：[ \t\n\x0B\f \r]
  \S  非空白字符：[^\s]
  \w  单词字符：[a-zA-Z_0-9]
  \W  非单词字符：[^\w]
----Greedy 数量词：x 表明规则,当字符不肯定或者不少的时候
  X? X，一次或一次也没有
  X*  X，零次或屡次
  X+  X，一次或屡次
  X{n} X，刚好 n 次
  X{n,} X，至少 n 次
  X{n,m} X，至少 n 次，可是不超过 m 次
----边界匹配器：
  ^  行的开头
  $  行的结尾
  \b  单词边界
  \B  非单词边界
  \A  输入的开头
  \G  上一个匹配的结尾
  \Z  输入的结尾，仅用于最后的结束符（如有）
  \z  输入的结尾
三、具体操做功能：
1）匹配：String matches(regex)
  2）切割：String[] split(String regex)
  3）替换：String replaceAll(String regex, String replacement)String 类中方法：
  4）获取：将字符串中符合规则的子串取出，具体操做步骤以下：
      a）将正则表达式封装成对象
      b）让正则对象和药操做的字符串相关联

c）获取正则匹配引擎
d）经过引擎对符合规则的子串进行取出
四、功能选择：
1）只想知道是否正确————>匹配
2）想要将已有的字符串便称另外一个字符串————>替换
3）想要按照本身的规则将字符串变成多个子串————>切割
4）想要拿到符合需求的字符串子串————>获取
示例1：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/*
 * 正则表达式：
 * 	做用：用于操做字符串
 * 	特色：用于一些特定的字符串来表达一些代码操做---到达简化效果
 * 	好处：能够简化对字符串的校验操做
 * 	弊端：符号定义越多，正则越长，阅读性极差
 * 
 * 具体操做功能：
 * 	一、匹配：String matches(regex)
 * 	二、切割：String[] split(String regex) 
 * 	三、替换：String replaceAll(String regex, String replacement)
 * 	四、获取：将字符串中符合规则的子串取出
 * 	操做步骤：
 * 		1）将正则表达式封装成对象
 * 		2）让正则对象和药操做的字符串相关联
 * 		3）获取正则匹配引擎
 * 		4）经过引擎对符合规则的子串进行取出
 * 
 * 
 */
public class RegexDemo {

	public static void main(String[] args) {
		System.out.println("---------checkQQ-----------");
		checkQQ();
		System.out.println("---------regexDemo1-----------");
		regexDemo1();
		System.out.println("---------checkPhonenum-----------");
		checkPhonenum();
		System.out.println("---------splitDemo-----------");
		splitDemo();
		System.out.println("---------replaceAllDemo-----------");
		replaceAllDemo();
		System.out.println("---------getDemo-----------");
		getDemo();
	}

	// 获取
	public static void getDemo() {
		String str = "zhong guan cong hei ma di shi er qi jiu yao kai ban le.";
		System.out.println("字符串：" + str);
		String regex = "\\b[a-z]{4}\\b";
		// 将规则封装成对象
		Pattern p = Pattern.compile(regex);
		// 让正则对象和要做用的字符串相关联,获取匹配器对象
		Matcher m = p.matcher(str);
		// String类中的matches()用的就是Pattern和Matcher对象来完成的，仅仅为了使用简单而封装的，功能单一

		// 将规则做用到字符串上，并进行符合规则的子串查找
		// boolean flag = m.find();
		// System.out.println(flag);
		// System.out.println(m.group());// 用于获取匹配后的结果
		System.out.println("获取结果为：");
		while (m.find()) {
			System.out.println(m.group());
			System.out.println(m.start() + "..." + m.end());
		}

	}

	// 替换
	public static void replaceAllDemo() {
		String str = "wwwwwwwitheimaaaaacom";
		// 用“#”替换数字
		// String repstr = str.replaceAll("\\d{5,}", "#");

		// 将叠词替换&
		// String repstr = str.replaceAll("(.)\\1+", "&");

		// 将重叠的字母替换成单个字母,用$n(n为前面的组标识)获取前面的组
		String repstr = str.replaceAll("(.)\\1+", "$1");
		System.out.println("字符串：" + str + "替换后结果为：" + repstr);
	}

	// 切割
	public static void splitDemo() {
		String str = "wwwkkitheimaqqcom";
		// str = "d:\\abc\\a.txt";
		// .表明任何字符（与行结束符可能匹配也可能不匹配）要使用必须转义 \\.
		// String regex = "\\.";

		// 路径分隔符\\对应的regex为\\\\
		// String regex = "\\\\";

		// 按照叠词切割.
		// 为了让规则的结果被重用，能够讲规则封装成一个组，用()完成。
		// 组的出现都有编号，从1开始，要想使用就能够经过\n(n为租的编号)表示
		String regex = "(.)\\1+";
		String[] arr = str.split(regex);
		System.out.println("切割结果以下：");
		for (String ar : arr) {
			System.out.println(ar);
		}
	}

	// 匹配测试1
	public static void regexDemo1() {
		String str = "a111111";
		String regex = "[a-z]\\d{3,5}";
		System.out.println("匹配测试1" + str.matches(regex));
	}

	// 匹配手机号：手机号段 13xxx 15xxx 18xxx
	public static void checkPhonenum() {
		String phone = "18767330882";
		String regex = "1[358]\\d{9}";
		boolean flag = phone.matches(regex);
		if (flag) {
			System.out.println("验证手机号" + phone + "---is ok");
		} else {
			System.out.println("验证手机号" + phone + "---is wrrong");
		}
	}

	// 验证QQ号，不能0开头，5-15位，不能有字符
	public static void checkQQ() {
		String qq = "1512465";
		String regex = "[1-9]\\d{4,14}";

		boolean flag = qq.matches(regex);
		if (flag) {
			System.out.println("验证QQ号" + qq + "---is ok");
		} else {
			System.out.println("验证QQ号" + qq + "---is wrrong");
		}
	}
}

结果如图所示：

示例2：

import java.util.Collections;
import java.util.TreeSet;

/*
 * 功能选择：
 * 一、只想知道是否正确————>匹配
 * 二、想要将已有的字符串便称另外一个字符串————>替换
 * 三、想要按照本身的规则将字符串变成多个子串————>切割
 * 四、想要拿到符合需求的字符串子串————>获取
 */
public class RegexTest {

	public static void main(String[] args) {
		System.out.println("----------regexTest1----------");
		regexTest1();
		System.out.println("----------ipSort----------");
		ipSort();
		System.out.println("----------checkMail----------");
		checkMail();
	}

	// 对邮件地址进行验证。
	public static void checkMail() {
		String mail = "cavenzzep@163.com.cn";
		String regex = "\\w+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";
		System.out.println(mail.matches(regex));
	}

	// * 练习需求： 将下面的字符串转换成(我要进黑马)
	public static void regexTest1() {
		String str = "我我...我我...我要...要要要...要去...去去去...去北京...京京京";
		// 将已有的字符串变成另外一个字符串————>替换
		// 一、先将.去掉
		// 二、将重复的内容变成单个子符内容
		str = str.replaceAll("\\.+", "");
		System.out.println(str);
		str = str.replaceAll("(.)\\1+", "$1");
		System.out.println(str);
	}

	// 将ip地址进行地址段顺序排序
	public static void ipSort() {
		String ip = "192.168.0.1 2.2.2.1 168.192.10.10 10.10.10.10 254.254.254.1 255.255.255.1";
		ip = ip.replaceAll("(\\d+)", "00$1");
		System.out.println(ip);
		ip = ip.replaceAll("0*(\\d{3})", "$1");
		System.out.println(ip);

		String[] ips = ip.split(" ");
		TreeSet<String> tree = new TreeSet<String>(Collections.reverseOrder());
		for (String newIp : ips) {
			// System.out.println(newIp);
			tree.add(newIp);
		}
		for (String s : tree) {
			System.out.println(s.replaceAll("0*(\\d+)", "$1"));
		}
	}
}

结果如图所示：

以上所述仅表明我的观点，若有出入请谅解。