1.1,finally
1,finally中定义的通常是关闭资源代码。因为资源必须释放。
2,如果在一个功能中,定义了一些必须要执行的代码,可以用try{}finally{}的方式,将一定
执行的代码放在finally代码块中。
3,finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。
示例:
/*
finally代码块:定义一定执行的代码。
通常用于关闭资源。
*/
class FuShuException extends Exception
{
FuShuException(String msg)
{
super(msg);
}
}
class Demo
{
int div(int a,int b)throws FuShuException
{
if(b<0)
throw new FuShuException("除数为负数");
return a/b;
}
}
class ExceptionDemo5
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,-1);
System.out.println("x="+x);
}
catch (FuShuException e)
{
System.out.println(e.toString());
return;
//System.exit(0);//系统,退出。jvm结束。
}
finally
{
System.out.println("finally");//finally中存放的是一定会被执行的代码。
}
System.out.println("over");
}
}
class NoException extends Exception
{
}
public void method()throws NoException
{
连接数据库;
数据操作;//throw new SQLException();
关闭数据库;//该动作,无论数据操作是否成功,一定要关闭资源。
try
{
连接数据库;
数据操作;//throw new SQLException();
}
catch (SQLException e)
{
会对数据库进行异常处理;
throw new NoException();
}
finally
{
关闭数据库;
}
}
1.2,异常的好处
1,将问题进行封装。
2,将正常流程代码和问题处理代码相分离,方便于阅读。
1.3,异常的处理原则
1,处理方式有两种:try或者 throws。
2,调用到抛出异常的功能时,抛出几个,就处理几个。一个try对应多个catch。
3,多个catch时,父类的catch放到最下面。否则编译会报错,因为其余的catch语句执行不到。
4,catch内,需要定义针对性的处理方式。不要简单的定义printStackTrace,输出语句。
也不要不写。当捕获到的异常,本功能处理不了时,可以继续在catch中抛出。
1.4,异常的注意事项
在子父类覆盖时:
1,子类抛出的异常必须是父类的异常的子类或者子集。
2,如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。
示例1:
/*
异常在子父类覆盖中的体现;
*/
class AException extends Exception
{
}
class BException extends AException
{
}
class CException extends Exception
{
}
/*
Exception
|--AException
|--BException
|--CException
*/
class Fu
{
void show()throws AException
{
}
}
class Test
{
void function(Fu f)
{
try
{
f.show();
}
catch (AException e)
{
}
}
}
class Zi extends Fu
{
void show()throws CException
{
}
}
class
{
public static void main(String[] args)
{
Test t = new Test();
t.function(new Zi());
}
}
示例2:
/*
有一个圆形和长方形。
都可以获取面积。对于面积如果出现非法的数值,视为是获取面积出现问题。
问题通过异常来表示。
现有对这个程序进行基本设计。
*/
class NoValueException extends RuntimeException
{
NoValueException(String message)
{
super(message);
}
}
interface Shape
{
void getArea();
}
class Rec implements Shape
{
private int len,wid;
Rec(int len ,int wid)//throws NoValueException
{
if(len<=0 || wid<=0)
throw new NoValueException("出现非法值");
this.len = len;
this.wid = wid;
}
public void getArea()
{
System.out.println(len*wid);
}
}
class Circle implements Shape
{
private int radius;
public static final double PI = 3.14;
Circle(int radius)
{
if(radius<=0)
throw new NoValueException("非法");
this.radius = radius;
}
public void getArea()
{
System.out.println(radius*radius*PI);
}
}
class ExceptionTest1
{
public static void main(String[] args)
{
Rec r = new Rec(3,4);
r.getArea();
Circle c = new Circle(-8);
System.out.println("over");
}
}
2.1,包(package)
包:用来给类文件进行分类管理。
2.2,包的作用
1、为避免多个类重名的情况,如果出现两个相同名字的类,可通过包将两者区分,从而避免冲突。
2、对类文件进行分类管理,可以将相关的一些类放在同一个包中。
3、给类提供多层命名空间,如a包中的Demo.class文件,如果要创建Demo对象,就要在使用时加上a.如:a.Demo demo=new a.Demo();
4、包的出现可以将java的类文件和源文件相分离。
2.3,包的规则
1、包必须写在程序的第一行。因为要先有包,才知道类文件的存放地方。
2、类的全称:包名.类名。
3、编译定义了包的程序文件时,在编译时要指定包的存储目录。
如:javac –d c:\mypack类名.java
2.4,包之间的访问
1、要访问其他包中的类,需要定义类的全称:包名.类名。
2、包如果不在当前路径,需要使用classpath设定环境变量,为JVM指明路径。
3、被访问的包中的类权限必须是public的。
4、类中的成员权限:public或者protected。protected是为其他包中的子类提供的一种权限。
类公有后,被访问的成员也要公有才可以被访问。不同包中的子类可以直接访问父类中
被protected权限修饰的成员。同一个包中,protected只作用为覆盖。
四种权限
public
protected
defauld
Private
注:一个.java文件里面,不能出现两个以上的公有类或者接口。因为被public修饰的类名必须与
java文件名相同。
2.5,包的导入(import)
1,可以简化类名。在调用其他包中的类时,需要写类的全称,也就是连同包名一起书写。当类存在多层包中时,如:haha.hehe.pack.Demo,使用import导入后,使用其类时,就可以不加包名了。导入格式如:import haha.hehe.pack.Demo;
2,一个程序文件中只有一个package,可以有多个import。import导入的是包中的类,不导入包中的包。
3,注意事项:
(1),在导入包时,如果包中有很多类,可以使用通配符 来替代包中的所有类。但是,建议不要使用通配符 ,
因为将不需要使用的类导入后,会占用内存空间。所有在编写程序时,要使用包中的哪些类,就导入哪些类。
(2),定义包名不要重复,可以使用url来完成定义,url是唯一的。如:package cn.itheima.Demo。
(3),导入的不同包中有相同类时,必须写类的全名以区分,否则将会报错。
2.6,jar包
类越来越多,我们可以用包来装,当包越来越多时,我们可以将包进行压缩。而java中用jar这个
工具来对包进行压缩。压缩后的后缀名为jar。
jar.exe工具的一些命令:
创建jar包
jar -cvf mypack.jar packa packb
查看jar包
jar -tvf mypack.jar [>定向文件]
解压缩
jar -xvf mypack.jar
自定义jar包的清单文件
jar –cvfm mypack.jar mf.txt packa packb
jar包的好处:
1、 可以将多个包进行压缩到为一个文件。方便项目的携带。
2、 方便于使用,只要在classpath设置jar路径,即可以执行jar包中的java程序。
3、 数据库驱动,SSH框架等都是以jar包体现的。
示例:
package pack;
/*
为了简化类名的书写,使用一个关键字,import.
import 导入的是包中的类。
建议,不要写通配符 * ,需要用到包中的哪个类,就导入哪个类。
c:\myclass
c:\myclass\packb\DemoA.class
c:\myclass\packb\haha\DemoZ.class
import packb.*;
import packb.haha.*;
建立定包名不要重复,可以使用url来完成定义,url是唯一的。
www.itcast.cn
package cn.itcast.demo
package cn.itcast.test
*/
import packb.haha.hehe.heihei.*;
import packa.*;
import packb.*;
class PackageDemo
{
public static void main(String[] args)
{
DemoC c = new DemoC();
// packa.DemoA d = new packa.DemoA();
// d.show();
// packb.DemoB d = new packb.DemoB();
// d.method();
}
}
/*
PackageDemo.java:8: 找不到符号
符号: 类 DemoA
位置: 类 pack.PackageDemo
DemoA d = new DemoA();
^
PackageDemo.java:8: 找不到符号
符号: 类 DemoA
位置: 类 pack.PackageDemo
DemoA d = new DemoA();
^
2 错误
错误原因:类名写错。
因为类名的全名是:包名.类名
PackageDemo.java:8: 软件包 packa 不存在
packa.DemoA d = new packa.DemoA();
^
PackageDemo.java:8: 软件包 packa 不存在
packa.DemoA d = new packa.DemoA();
^
2 错误
错误原因:packa包不在当前目录下
需要设置classpath,告诉jvm去哪里找指定的packa包。
PackageDemo.java:8: packa.DemoA 在 packa 中不是公共的;无法从外部软件包中对其进
行访问
packa.DemoA d = new packa.DemoA();
^
PackageDemo.java:8: packa.DemoA 在 packa 中不是公共的;无法从外部软件包中对其进
行访问
packa.DemoA d = new packa.DemoA();
^
2 错误
错误原因:有了包,范围变大,一个包中的类要被访问,必须要有足够大的权限。
所以被访问的类要被public修饰。
PackageDemo.java:9: show() 在 packa.DemoA 中不是公共的;无法从外部软件包中对其进
行访问
d.show();
^
1 错误
错误原因:类公有后,被访问的成员也要公有才可以被访问。
总结:
包与包之间进行访问,被访问的包中的类以及类中的成员,需要public修饰。
不同包中的子类还可以直接访问父类中被protected权限修饰的成员。
包与包之间可以使用的权限只有两种,public protected。
public protected default private
同一个类中 ok ok ok ok
同一个包中 ok ok ok
子类 ok ok
不同包中 ok
java.lang : java的核心包 jdk1.2版本以后,该包中的类自动导入。
java.awt: 用于制作图形界面。
java.io:input output 用于操作设备上的数据。
java.util : 这里定义是java的工具类。集合,日期。
java.net:用于网络通讯的。
java.applet: application let server let servlet java server page jsp
class haha implements Servlet
class hehe extends HttpServlet
*/