/*

异常

异常定义了程序中遇到的非致命的错误，而不是编译时的语法错误，如程序要打开一个不存在的文件

网络连接中断，操作数越界，装载一个不存在的类等

try, catch语句

throws关键字

自定义异常与Throw关键字

如何对多个异常进行处理

我们可以在一个方法中使用throw,try...catch语句来实现程序的跳转

一个方法被覆盖时，覆盖它的方法必须扔出相同的异常或异常的子类

如果父类扔出了多个异常，那么重写(覆盖)方法必须扔出那些异常的一个子集，

也就是说不能扔出新的异常

包

 1 package语句及应用

 2 package语句作为java源文件的第一条语句，如果没有package语句，则为缺少无名包

 3 import语句及应用

 4 jdk常用的包

   java.lang...包含一些java语言的核心类,如String, Math, Integer, System.和Thread,提供常用功能

   java.awt..包含了构成抽象窗口工具集(abstract window toolkits)的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)

   java.applet...包含applet运行所需的一些类

   java.net...包含执行与网络相关的操作类

   java.io...包含能提供多种输入/输入功能的类

   java.util...包含一些实用工具类，如定义系统特性，使用与日期日历相关的函数

javac -d . Lesson44.java 如果存在包名的话，那么就按目录生成编译文件

找不到类的三个排错方法

   1: 类名写错了

   2: 包名错误，是否import这个类所在的包名

   3: 查看classpath是否设置类型

访问控制

                 private    default  protected   public

同一类-----------   可          可        可         可

同一包中的类------              可        可         可

子类-------------                         可         可

其他包中的类-----                                    可

类本身也有访问控制，即在定义类的class关键字前加上访问

控制符，但类本身只有两种访问控制，

即public和 默认，父类不能是private 和protected

否则子类无法继承，public修饰的类能被所有的类访问

默认修饰（即class关键字前没有访问控制符）的类

只能被同一个懈中的所有类访问

java的命名习惯

下面是java中的一些命名习惯，假设xxx, yyy, zzz分别是一个英文单词的拼写

1 包名中的字母一律小写，如:xxxyyyzzz

2 类名，接口名应当使用名词，每个单词的首字母大写，如XxxYyyZzz

3 方法名，第一个单词小写，后面的每个单词的首字母大写，如:xxxYyyZzz

4 变量名，第一个单词小写，后面每个单词的首字母大写，如xxxYyyZzz

5 常量名中的第个字母一律大写，如XXXYYYZZZ

使用jar文件

jar -cvf

jar -tvf

jar -xvf

jar -tvf > a.txt

用rar查看jar文件中的内容

注意压缩后的jar文件中的目录结构

快速查看jar包中是否有我们想找的类

jar查看帮助

jar -cf lesson4.jar org 将org目录生成一个lesson4.jar的包文件

jar -cvf lesson4.jar org

jar -tf lesson4.jar 查看包内容

jar -xvf lesson4.jar 解压包

jar -xvf rt.jar > 1.txt 重写向

*/

package org.it315;

//import java.awt.*;

//import java.awt.event.*;

//import java.sql.*;

//import java.util.*;

/*class SubTest extends Test

{

	 //在子类中只能扔出父类的异常，只能比父类的少，不能比父类的异常多

	 public int devide(int x, int y) throws NullPointerException

	 {

	 }

};*/

//定义自己的异常类

import org.it315.*;

import org.it315.example.*;

class TestException

{

     public static void main(String[] args) //throws Exception

     {

		 try

		 {

			 new org.it315.example.Test().devide(3,1);

			 //new org.it315.example.Test().fun1();

			 //现在不能访问了，因为TestSub是Test类的子类，但TextException类的子类，所以不能访问

			 //如果为如果fun1()为public将可以被其它包中的类访问

			 //new Test().fun1();

			 //int i=1+1;

		 }

		 catch(ArithmeticException e)

		 {

		      System.out.println("ArithmeticException");

			  e.printStackTrace();

		 }

		 catch(org.it315.DevideByMinusException e)

		 {

		      System.out.println("DevideByMinusException");

			  e.printStackTrace();

			  return;

			  //System.exit(0); //程序到此结束了，

			  //finally将不被执行了

		 }

		 catch(Exception e)

		 {

		     System.out.println(e.getMessage());

		 }

		 finally

		 {

		     System.out.println("不管是否有异常，finally的代码都要执行");

		 }

		 System.out.println("program is running here!");

     }

}

class TestSub extends Test

{

	public void fun3()

	{

	       fun1();

	}

};

package org.it315;

public class DevideByMinusException extends Exception

{

     public DevideByMinusException(String msg)

	 {

	     super(msg);

	 }

};

package org.it315.example;

//import org.it315.*;

import org.it315.DevideByMinusException;

public class Test

{

	 //throws Exception加上该throws Exception 在调用该函数时，那么必须实现try...catch

     //多个异常类的处理

	 //public int devide(int x, int y) throws ArithmeticException, org.it315.DevideByMinusException

     public int devide(int x, int y) throws ArithmeticException, DevideByMinusException

     {

         if(y<0)

		 {

		    //throw new org.it315.DevideByMinusException("devisor is "+y);

			throw new DevideByMinusException("devisor is "+y);

		 }

		 int result = x/y;

	     return result;

     }

     //throw try...catch还可以实现话句的跳转

	 /*void fun()

	 {

		 try{

			 if(x==0)

			 {

				 throw new XxxException("xxx");

			 }else{

			     throw new YyyException("yyy");

			 }

		 }catch(XxxException e)

		 {

		      //......

		 }

		 catch(YyyException e)

		 {

		      //.....

		 }

	 }*/

	 //private void fun1()

	 protected void fun1() //没有访问修饰的叫做包类型的访问修饰符. 在其它的包中是不可以访问

	 {

	 }

	 private void fun2()

	 {

	        fun1();

	 }

}

class Test1

{

      public static void main(String[] args)

	  {

	       new Test().fun1();

	  }

};