自定义异常类：
自定义异常类的步骤：自定义一个类继承Exception即可
public class CustomClass { public static void main(String[] args) throws NoIpException{ // TODO Auto-generated method stub String ip=null; feiQ(ip); } public static void feiQ(String ip) throws NoIpException{ if (ip==null) { //抛出一个没有网线的异常 throw new NoIpException("没有插网线啊"); } System.out.println("正常显示好友列表！"); } } class NoIpException extends Exception{ public NoIpException() {} public NoIpException(String message) { super(message); //调用了Exception一个参数的构造函数 } } 结果： Exception in thread "main" test.NoIpException: 没有插网线啊 //这里会出现这样的结果是因为我们把上面的异常抛给了feiQ的调用者main函数，也就是jvm，它会默认打印异常的栈信息的，所以会出现下面的东西 at test.CustomClass.feiQ(CustomClass.java:13) at test.CustomClass.main(CustomClass.java:8)
还可以用try-catch方法：
public class CustomClass { public static void main(String[] args) /*throws NoIpException*/{ // TODO Auto-generated method stub String ip=null; try { feiQ(ip); }catch(NoIpException e) { e.printStackTrace(); System.out.println("马上插上网线！"); } } public static void feiQ(String ip) throws NoIpException{ if (ip==null) { //抛出一个没有网线的异常 throw new NoIpException("没有插网线啊"); } System.out.println("正常显示好友列表！"); } } class NoIpException extends Exception{ public NoIpException() {} public NoIpException(String message) { super(message); //调用了Exception一个参数的构造函数 } } 结果： test.NoIpException: 没有插网线啊 at test.CustomClass.feiQ(CustomClass.java:18) at test.CustomClass.main(CustomClass.java:9) 马上插上网线！
例题：定义一个没钱的异常 ，如果带够了钱，那么就可以吃上木桶饭，如果没有，那么就会抛出一个没钱的异常。
public class CustomClassTest { public static void main(String[] args) { // TODO Auto-generated method stub int money=6; try { eat(money); }catch(NoMoneyException e) { e.printStackTrace(); System.out.println("跟我洗碗一个月！"); } } public static void eat(int money) throws NoMoneyException{ if (money<10) { //抛出一个没有钱的异常 throw new NoMoneyException("吃霸王餐！"); } System.out.println("吃上了香喷喷的木桶饭！"); } } //定义一个没钱的异常 class NoMoneyException extends Exception{ public NoMoneyException() {} public NoMoneyException (String message) { super(message); } } 结果： test.NoMoneyException: 吃霸王餐！ at test.CustomClassTest.eat(CustomClassTest.java:18) at test.CustomClassTest.main(CustomClassTest.java:9) 跟我洗碗一个月！
异常分为：
运行时异常：如果一个方法内部抛出了一个运行时异常，那么方法上可以声明也可以不声明，调用者可以处理也可以不处理
编译时异常（非运行时异常，受检异常） ：如果一个方法内部抛出了一个编译时异常对象，那么方法上就必须要声明，而且调用者也必须要处理。
运行时异常：RuntimeException以及RuntimeException子类都是属于运行时异常
编译时异常：除了运行时异常就是编译时异常。
疑问：为什么java编译器会如此严格要求编译时异常，对运行时异常如此宽松？
运行时异常都是可以通过程序员良好的编程习惯去避免的，所以java编译器就没有严格要求处理运行时异常
而编译时异常是不能通过代码来避免的，所以就必须要求程序员来处理
资源文件一旦使用完毕，一定要释放资源文件，否则其他的程序无法对这个资源文件进行操作。
finally块：
finally块的使用前提是必须要存在try块才能使用
public class Finally { public static void main(String[] args) { // TODO Auto-generated method stub div(4,0); } public static void div(int a,int b) { try { int c=a/b; System.out.println("c="+c); }catch(Exception e) { System.out.println("出现了除数为0的异常"); //throw e; }finally { System.out.println("finally的代码被执行了"); } } } 结果： 出现了除数为0的异常 finally的代码被执行了
finally块的代码在任何情况下都会执行的，除了jvm退出的情况（System.exit）
finally非常适合做资源释放的工作，这样子可以保证资源文件在任何情况下都会被释放。
try块的三种组合方式：
1.比较适用于有异常要处理，但是没有资源要释放的。
try{
可能发生异常的代码
}catch（捕获的异常类型 变量名）{
处理异常的代码
}
2.比较适用于既有异常要处理，又要释放资源的代码
try{
可能发生异常的代码
}catch（捕获的异常类型 变量名）{
处理异常的代码
}finally{
释放资源的代码；
}
3.比较适用于内部抛出的是运行时异常，并且有资源要被释放。 （合法但不常用）
try{
可能发生异常的代码
}finally{
释放资源的代码；
}
包：
包的好处：
- 解决类名重复产生冲突的问题
- 便于软件版本的发布
定义包的格式：package 包名；
包名命名规范：包名全部小写
包语句要注意的事项：
- package语句必须位于java文件中的第一个语句
- 如果一个类加上了包语句，那么该类的完整类名就是 ： 包名.类名
- 一个java文件只能有一个包语句
在dos命令中， “.“ 表示当前的路径
java -d 指定类文件的存放路径 java源文件
有了包之后类与类之间的访问：（默认情况是每个类都是一个包）
导包语句作用：简化书写（误区：把一个类导入到内存中）
导包语句的格式：
import 包名.类名； （导入xxx包中的某个类）
导包语句要注意的细节：
- 一个java文件中可以出现多句导包语句
- "*"星号是导包语句的通配符。可以匹配任何的类名 （星号只能用作匹配类名，不能用作匹配包名）
- import 包名.* 是不会作用于此包下面的子包的
推荐使用 import 包名.类名 而不要使用 import 包名.* 因为使用*通配符会导致结构不清晰
什么时候使用import语句：
- 相互访问的两个类b不是在同一个包下面，这时候就需要使用到导包语句
- java.lang包是默认导入的，不需要我们自己导入
权限修饰符：权限修饰符就是控制被修饰的成员的范围可见性。
| public（公共） | protected（受保护） | default（缺省，也就是没有写东西） | private（私有）（大到小） | |
| 同一个类 | true | true | true | true |
| 同一个包 | true | true | true | false |
| 子父类 | true | true | false | false |
| 不同包 | true | false | false | false |
注意：在不同包下面只有public与protected可以访问，而且protected必须是在继承关系下才能够访问。
打jar包：需要使用到jdk的开发工具（jar.exe）
jar的用法： jar cvf （-cvf） jar文件的名字 class文件或者是文件夹
打jar包要注意的事项：
- 一个程序打完了jar之后，必须要在清单文件上指定入口类：格式 Main-Class: (注意这里有一个空格)包名.类名
- jar包双击运行仅对于图形化界面的程序起作用，对控制台的程序不起作用
jar文件的作用：
- 方便用户快速运行一个项目
- 提供工具类以jar包的形式给别人使用
如果使用jar包里面的类必须要先设置classpath路径
import javax.swing.*; public class Test { public static void main(String[] args) { // TODO Auto-generated method stub JFrame frame=new JFrame("QQ程序"); frame.setSize(400, 500); frame.setVisible(true); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } } 结果为一个界面
模板模式：
某类事情的步骤有些是固定的，有些是会发生变化的，那么这时候我们可以为这类事情提供一个模板代码，从而提高效率。
模板模式的步骤：
- 先写出解决该类事情其中一件的解决方案
- 分析代码，把会发生变化的的代码抽取出来独立成一个方法，把该方法也描述成一个抽象的方法
- 使用final修饰模板方法，防止别人重写你的模板方法
public class RunTime extends MyRunTime{ public static void main(String[] args) { // TODO Auto-generated method stub //MyRunTime time=new MyRunTime(); //time.getTime(); RunTime r=new RunTime(); r.getTime(); } public void code() { for (int i=0;i<100;i++) { System.out.println("i="+i); } } } abstract class MyRunTime{ public MyRunTime() {} public final void getTime() { long startTime=System.currentTimeMillis(); //记录开始的时间 code(); long endTime=System.currentTimeMillis(); //记录结束时间 System.out.println("运行时间是："+(endTime-startTime)); } public abstract void code(); } 结果： i=0 i=1 i=2 i=... i=99 运行时间是：13
清除重复元素：
例，清除{11，2，4，2，10，11}中的重复元素，并且打印出来，要求不允许又多余的空间
import java.util.*; public class ClearRepeat { public static void main(String[] args) { // TODO Auto-generated method stub int[] arr= {11,2,4,2,10,11}; arr=clearRepeat(arr); System.out.println("清除重复元素的数组："+Arrays.toString(arr)); } public static int[] clearRepeat(int[] arr) { //先计算出重复元素的格式 int count=0; //记录重复元素的个数 for (int i=0;i<arr.length-1;i++) { for (int j=i+1;j<arr.length;j++) { if (arr[i]==arr[j]) { count++; break; } } } System.out.println("重复元素的个数："+count); //新数组的长度 int newLength=arr.length-count; //创建一个新的数组 int[] newArr=new int[newLength]; int index=0;//定义一个变量记录新数组使用的索引值 //把旧数组的元素存储到新数组中，存入新数组之前要先判断该元素是否存在新数组中，如果存在了，那么该元素就不要了 for (int i=0;i<arr.length;i++) { int temp=arr[i]; //取出旧数组的元素 boolean flag=false;//定义一个变量用于记录当前元素是否为重复元素,默认不是重复元素 //检查新数组是否存在取出的元素 for (int j=0;j<newArr.length;j++) { if (newArr[j]==temp) { flag=true; //该元素已经存在了新数组中 break; } } //不是重复元素 if (flag==false) { newArr[index++]=temp; } } return newArr; } } 结果： 重复元素的个数：2 清除重复元素的数组：[11, 2, 4, 10]
