java架包异常_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();

}

};