java第四节 异常/访问控制/jar包

/*
异常
异常定义了程序中遇到的非致命的错误，而不是编译时的语法错误，如程序要打开一个不存在的文件
网络连接中断，操作数越界，装载一个不存在的类等

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