1.EmptyStackException类

public class Printer {
	
	    private String name;
	 
	    public void setName(String name) {
	        this.name = name;
	    }
	 
	    public void print() {
	        printString(name);
	    }
	 
	    private void printString(String s) {
	        System.out.println(s + " (" + s.length() + ")");
	    }
	 
	    public static void main(String[] args) {
	    	Printer printer = new Printer();
	    	try{
	        
	        printer.print();
	        
	    	}
	    	catch(NullPointerException ae)
	    	{System.out.println("ycbh");}
	    	
	    }

2.ArithmeticException类

public class TestArithmeticException {
	public static void main(String[] args) {
		int a,b,c;
		a=1;
		b=0;
		c=a/b;
		System.out.println(c);
	}
}
public class TestArithmeticException {
	public static void main(String[] args) {
		try{
			int a,b,c;
			a=1;
			b=0;
			c=a/b;
			System.out.println(c);
		}
		catch(ArithmeticException e) {
			System.out.println("除数为0");
		}
			
	}
}

3.NullPointerException类

public class TestArry {
	private static int[] x;
	public static void main(String[] args) {
		System.out.println(x[0]);
	}
}
public class TestArry {
	private static int[] x;
	public static void main(String[] args) {
		try {
			System.out.println(x[0]);
		}
		catch(NullPointerException e) {
			System.out.println("空指针异常");
		}
	}
}

4.ArrayIndexOutOfBoundsException类

public class TestArgs {
	public static void main(String[] args) {
		String foo=args[1];
		System.out.println("foo="+foo);
	}
}
public class TestArgs {
	public static void main(String[] args) {
		try{
			String foo=args[1];
			System.out.println("foo="+foo);
		}
		catch(ArrayIndexOutOfBoundsException e) {
			System.out.println("数组下标越界");
		}
	}
}

5.NegativeArraySizeException类

public class TestNegativeArraySize {
	public static void main(String[] args) {
		int[] a;
		a=new int[-1];
	}
}
public class TestNegativeArraySize {
	public static void main(String[] args) {
		try{
			int[] a;
			a=new int[-1];
		}
		catch(NegativeArraySizeException e) {
			System.out.println("负数组长度异常");
		}
	}
}

RuntimeException类为运行时异常类，它的父类为Exception类

当运行时出现异常时，可以声明或捕获，一般不声明，一般会捕获，至少保证程序继续运行

举个例子：

定义了一个Word类，该类是单词类，根据单词的业务逻辑，单词中只能含有a~z、A~Z里的字符，但是在初始化Word对象可能会有含有其他字符，当含有其他字符时，就让程序报错。

 代码如下：

定义异常类，继承RuntimeException类

public class WordsCanOnlyBeComposedOfEnglishLetters extends RuntimeException{//继承Exception为编译时异常

	public WordsCanOnlyBeComposedOfEnglishLetters(String str) {
		
		super(str);
	}
}

 定义实体类Word

public class Word {
	
	private String word;
	
	public Word() {
		word="";
	}
	public Word(String str) /*声明这里可能出现异常*/ {
		for(int i=0;i<str.length();i++) {
			if(!((str.charAt(i)>='A'&str.charAt(i)<='Z')||(str.charAt(i)>='a'&str.charAt(i)<='z'))) {
				throw new WordsCanOnlyBeComposedOfEnglishLetters("含有非法字符");
			}
		}
		word=str;
	}
	public void setWord(String str) /*声明这里可能出现异常*/ {
		for(int i=0;i<str.length();i++) {
			if(!((str.charAt(i)>='A'&str.charAt(i)<='Z')||(str.charAt(i)>='a'&str.charAt(i)<='z'))) {
				throw new WordsCanOnlyBeComposedOfEnglishLetters("含有非法字符");
			}
		}
		word=str;
	}
	public String getWord(String str) {
		return word;
	}
}

//主类代码
public class Main {
	
	public static void main(String[] args) {
		//捕获异常
		try {
			
			Word w1=new Word("hj1");
			System.out.println("正常执行……");
		}catch(WordsCanOnlyBeComposedOfEnglishLetters w){
			w.printStackTrace();
		}
		System.out.println("执行结束！");
		
	}
}