Throwable

|---Error //通常出现重大问题如：运行的类不存在或者内存溢出等。

|---Exception //运行时出现的一起情况

|---RuntimeException //特殊异常类，抛时不需要声明

Exception和Error的子类名都是以父类名作为后缀。

异常体系的特点：

1）异常体系中的所有类以及建立的对象都具备可抛性。

2）也就是说可以被throw和throws关键字所操作。

1）编译时被检测异常：

该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表着可以被处理。

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

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

4、throw和throws

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

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

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

常见方法操作：

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

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

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

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

class MyException extends Exception {
	private String msg;

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

/*
老师使用电脑讲课。

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

描述老师：
	1、老师使用电脑
	2、老师讲课。
描述老师可能出现的问题：
	1、老师不能继续讲课了，他让同学们自己做练习。

*/

//电脑蓝屏了
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("换老师或者放假");
		}
	}
}

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

public class StringTest {

	// 1、字符串反转
	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;
	}

	// 2、获取一个字符串在另一个字符串中出现的次数
	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;
	}

	// 3、有两个字符串，找出两个字符串中最大相同那个字符串
	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));
	}
}

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

/*
 * Date类：
 * 1、获取系统当前时间
 * 2、利用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());
	}
}

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) + "日");
	}

}

/*
 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,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();
	}
}

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

/*
 * 正则表达式：
 * 	作用：用于操作字符串
 * 	特点：用于一些特定的字符串来表达一些代码操作---到达简化效果
 * 	好处：可以简化对字符串的校验操作
 * 	弊端：符号定义越多，正则越长，阅读性极差
 * 
 * 具体操作功能：
 * 	1、匹配：String matches(regex)
 * 	2、切割：String[] split(String regex) 
 * 	3、替换：String replaceAll(String regex,String replacement)
 * 	4、获取：将字符串中符合规则的子串取出
 * 	操作步骤：
 * 		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");
		}
	}
}

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

/*
 * 功能选择：
 * 1、只想知道是否正确————>匹配
 * 2、想要将已有的字符串便称另一个字符串————>替换
 * 3、想要按照自己的规则将字符串变成多个子串————>切割
 * 4、想要拿到符合需求的字符串子串————>获取
 */
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 = "我我...我我...我要...要要要...要去...去去去...去北京...京京京";
		// 将已有的字符串变成另一个字符串————>替换
		// 1、先将.去掉
		// 2、将重复的内容变成单个子符内容
		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"));
		}
	}
}