Java基础视频教程第10天_面向对象之异常2、包

一、面向对象——异常- finally

finally 代码块：定义一定执行的代码，通常用于关闭资源。
代码示例一：
	class NoException extends Exception
{
}
class Demo
{
public void method()throws NoException
{
try
{
连接数据库;
操作数据库;
}
catch (SQLException e)
{
对数据库进行异常处理;
throw new NoException();//抛出一个新的异常对象
}
finally
{
关闭数据库;//一定执行的语句
}
}
}

代码示例二：
[code]	class FinallyDemo
{
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;//代表出现异常时，直接让程序停掉。
}
finally
{
System.out.println("finally");
}
System.out.println("over");
}
//结果会打印finally，不会打印over 。
}

二、面向对象——异常-处理语句其他格式

格式一：
try
{}
catch ()
{}

格式二：
try
{}
catch ()
{}
finally
{}

格式三：
try
{}
finally
{}

小问题：

<span style="white-space:pre">	</span>示例一：

class Demo
{
public void method()
{ //该异常内部已解决，可以不用声明
try
{
throw new Exception();
}
catch (Exception e)
{
}
}
}

示例二：

class Demo
{
public void method()
{
try
{
throw new Exception();
}
catch (Exception e)
{
throw e;//此时将问题抛出，如果函数上未声明，编译不通过。
}
}
}

示例三：

class Demo
{
public void method()
{ //该异常内部已解决，可以不用声明
try
{
throw new Exception();
}
catch (Exception e)
{
try
{
throw e;
}
catch (Exception ex)
{
}
}
}
}

示例四：

class Demo
{
public void method()
{ //这个程序抓住问题，但并没有处理，而是交给下一个程序处理。需要在函数上声明，否则编译失败。但是需要finally中的语句必须执行。
try
{
throw new Exception();
}
finally
{
关闭资源;
}
}
}

注意：
catch 用于处理异常。如果没有 catch 就代表异常没有被处理过。如果该异常是检测时的异常，那么必须声明。

三、面向对象——异常-覆盖时的异常特点

1，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。

示例：

class AException extends Exception
{
}
class BException extends AException
{
}
class CException extends Exception
{
}

class Fu
{
void show()throws AException
{}
}
class Zi extends Fu
{
void show()throw AException //或者BException //或者不抛出异常 //不能抛出CException
{}
}

2，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
示例：

class Fu
{
void show()throws AException,BException,CException
{}
}
class Zi extends Fu
{
void show()throw AException,BException//最多只能抛出A、B、C三个。//或者不抛出
{}
}

3，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行 try 处理，绝对不能抛出。

总结：
子类抛出的异常不能多于父类抛出的异常。

四、面向对象——异常练习

如果正常流程代码和问题处理代码结合的非常紧密，阅读性比较差。
异常的出现，能让正常流程代码和问题处理代码相分离。
/*
需求：获取圆形和长方形的面积，如果出现非法数值，视为获取问题时出现问题。用异常来表示这个问题。
*/

class NoValueException extends RuntimeException //该异常类继承RuntimeException,以便当出现这个异常时让程序停止运行
{
NoValueException(String message)
{
super(message);
}
}
//定义一个接口，便于功能拓展
interface Shape
{
void getArea();
}
class Rec implements Shape
{
private int len, wid;
Rec(int len, int wid)
{
if(len<=0 || wid<=0)
throw new NoValueException("出现非法值");
this.len = len;
this.wid = wid;
}
public void getArea()
{
System.out.println("len*wid="+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("Circle: "+radius*radius*PI);
}
}

class ExceptionTest1
{
public static void main(String[] args)
{
Rec r = new Rec(3,4);
r.getArea();
Circle c = new Circle(-5);
c.getArea();
System.out.println("over");
}
}

五、面向对象——异常总结

异常：
是什么？是对问题的描述。将问题进行对象的封装。
------------
异常体系：
Throwable
|--Error
|--Exception
|--RuntimeException
异常体系的特点：
异常体系中的所有类及其建立的对象都具备可抛性。
也就是说可以被 throw 和 throws 关键字所操作。
只有异常体系具备这个特点。
--------------
throw 和 throws 的用法：
throw 定义在函数内，用于抛出异常对象。
throws 定义在函数上，用于抛出异常类，多个异常类抛出时用逗号隔开。

当函数内有 throw 抛出异常对象，并未进行 try 处理时，必须要在函数上声明，否则编译失败。
但是， RuntimeException 除外；也就说，函数内如果抛出的是 RuntimeException 异常，函数上可以不用声明。
--------------
如果函数声明了异常，调用者需要进行处理。处理方法可以 throws 可以 try 。

异常有两种：
编译时被检测异常
该异常在编译时，如果没有处理(没有抛也没有 try )，编译失败。
该异常被标识，代表可以被处理。
运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。
该异常的发生，建议不处理，让程序停止，需要对代码进行修正。
--------------
异常处理语句：
try
{
需要被检测的代码；
}
catch ()
{
处理异常的代码；//处理方式；
}
finally
{
一定会执行的代码；
}

有三个结合格式：
1. try
{
}
catch ()
{
}

2. try
{
}
finally
{
}

3. try
{
}
catch ()
{
}
finally
{
}

注意：
1， finally 中定义的通常是 关闭资源代码。因为资源必须释放。
2， finally 只有一种情况不会执行。当执行到 System.exit(0);/*系统退出,JVM结束*/ finally 不会执行。
--------------
自定义异常：
定义类继承 Exception 或者 RuntimeException
目的：
1，为了让该自定义类具备可抛性。
2，让该类具备操作异常的共性方法。

当要定义自定义异常的信息时，可以使用父类已经定义好的功能。将异常异常信息传递给父类的构造函数。

class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}

自定义异常出现的好处：按照java的面向对象思想，将程序中出现的特有问题进行封装。
--------------
异常的好处：
1，将问题进行封装。
2，将正常流程代码和问题处理代码相分离，方便于阅读。

异常的处理原则：
1，处理方式有两种： try catch 或者 throws 。
2，调用到抛出异常的功能时，抛出几个就处理几个。
一个 try 对应多个 catch 。
3，多个 catch ，父类的 catch 放到最下面。
4， catch 内，需要定义针对性的处理方式。不要简单的定义 printStackTrace()方法 ，输出语句。也不要不写。
A、当捕获到的异常，本功能处理不了时，可以继续在 catch 中抛出。
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}

B、如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，再抛出和该功能相关的异常。
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道，并处理。也可以将捕获异常处理后，转换新的异常。
try
{
throw new AException();
}
catch (AException e)
{
// 对AException处理。
throw new BException();
}

异常的注意事项：
在子父类覆盖时：
1，子类抛出的异常必须是父类的异常的子类或者子集。
2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

参阅
ExceptionTest.java 老师用电脑上课
ExceptionTest1.java 图形面积

小知识：

class
{
public static void main(String[] args)
{
int x = 0;
try
{
x = 4;
}
catch ()
{
}
finally
{
System.out.println("x="+x);//结果x=4;
}
}
}

六、面向对象——练习四

略

七、面向对象——包 package

java中的包就是系统中的文件夹。

1、包的特点：
对类文件进行分类管理；
给类提供多层命名空间；
写在程序文件的第一行；
类名的全称是：包名.类名；
包也是一种封装形式。

2、编译：
编译时，如果源文件中定义了包，则需加参数，示例：

javac -d . PackageDemo.java
-d 指定包的存放目录(d:directory)
. 代表当前目录
PackageDemo.java 代表源文件

3、运行：
java pack.PackageDemo
运行时需指定包名
pack.PackageDemo 为pack包中可独立运行的 PackageDemo.class文件。

4、当运行文件不在当前目录下时，需配置classpath环境变量：
set classpath=路径

5、定义类用 class ，定义接口用 interface ，定义包用 package 。

6、定义包时, package 必须放在代码的第一行。包名所有字母都小写。

示例代码：

package pack; //定义包时，必须写在代码的第一行；包名所有字母都要小写。

class PackageDemo
{
public static void main(String[] args)
{
System.out.println("Hello");
}
}

======编译时，如果没有指定包，java会把当前目录作为默认包的存在。

======包的出现可以让java的源文件和运行文件相分离。

八、面向对象——包与包之间访问

访问规则：
1、访问不同包中的类时，需在类名前面加上包名；例如：packa.DemoA

2、包与包之间进行访问，被访问的包中的 类 以及 类中的成员，需要被 public 修饰。

3、包中的成员被 protected 修饰，那么，不同包中，只有该子类可以访问该成员。

4、同一个包中，类中的成员被 protected 修饰，其作用仅仅是：
当子类覆盖时，需提供相等或者更大的权限。
代码示例：

class DemoA
{
protected void show(){}
}
class DemoB extends DemoA
{
public void show(){}
//或者是protected修饰
}

5、当同一个包中有两个类都需要被其他包中的类建立对象访问。
那么，这两个类都需要被 public 修饰；同时，这两个类不能放在同一个文件中，需分开放置(因为类名被 public 修饰后，文件名必须与其保持一致)。
示例：
package pack;
public DemoA{} 放在DemoA.java中；

package pack;
public DemoB{} 放在DemoB.java中。
编译后，两个类文件将出现在同一个包(文件夹)中。

注意：
包与包之间可以使用的权限只有两种：
public protected

成员之间访问权限总结：
public protected default private
同一个类中 OK OK OK OK
同一个包中 OK OK OK
不同包中的子类 OK OK
不同包中的非子类 OK

=====包的层次关系：
例如：pack.packA.packAB.packABC
pack包中有子包packA，packA包中有子包packAB...

=====包也是一种封装体，一个包中有十个类，但只有一个类被 public 修饰，那么其他九个类都只是对内使用的，不对外提供。

=====当包中的类被 public 修饰，但该类中的方法没有被 public 修饰，那么该方法也不对外提供。

九、面向对象——导入 import

import 导入支持类（可以是JDK基础类或者自己编写的类），可以供本类调用方法和属性。

例如：
import ck.cka.ckb.ckc.DemoC;//ck.*//导入全部类

示例一：
c:\myclass\packb\DemoA.class
c:\myclass\packb\haha\DemoZ.class

import packb.*;//导入的只是DemoA.class
import packb.haha.*;//导入DemoZ.class

建议：
不要写通配符 * ；需要用到包中的哪个类就导入哪个类。因为不需要导入多余的类(否则会比较占用内存空间)。

注意：
1、如果导入的包中出现同名类名，那么在使用时，类名前必须加包名。
2、建议定包名不要重复，可以使用url来完成定义，url是唯一的。
3、url: Uniform Resource Locator 统一资源定位符。见百度百科。
4、一个程序中，用到其他包中的类时，可以不用写 import ,这样在使用该类时，写全类名即可。

十、面向对象——jar包

jar包：java的压缩包。
特点：
A、方便项目的携带；
B、方便于使用，只要在classpath设置jar路劲即可；
C、数据库驱动，SSH框架等都是以jar包体现的。

示例代码：

package packa;
public class DemoA
{
public void show()
{
System.out.println("demoA show run");
}
}

package pack;
import packa.*;
class JarDemo
{
public static void main(String[] args)
{
DemoA a = new DemoA();
a.show();
System.out.println("Hello jar pack!");
}
}

编译DemoA.java,JarDemo.java 将其生成的包都放到d:\myclass文件夹中。生成packa包和pack包。(注意：需配置set classpath=d:\myclass)
此时，运行pack.JarDemo即可。

为了方便进行压缩：
切换到d:\myclass目录中，输入
jar -cf haha.jar pack packa
-cf: 创建指定名称档案。
haha.jar: 创建后的jar包名称。
pack,packa: 被压缩的包。

在命令行中输入：jar -tf haha.jar 可查看haha.jar包中的目录信息。

当删除pack,packa两个包后，直接运行pack.JarDemo会失败。但是可以配置classpath路径：set classpath=d:\myclass\haha.jar
此时，运行pack.JarDemo OK。因为pack包被压缩到了haha.jar包中。

结论：
在开发中，拿到jar包后，将其放到classpath路径下即可运行。

在开发当中，需要找一些对象来完成相应功能。如果java网站上没有提供现有的工具，可以到互联网资源上查找。

比如：dem4j

jar -cfv a.jar pack packa
压缩成a.jar并显示详细信息。

jar - tvf a.jar
显示a.jar中的详细信息。

jar -tf a.jar >d:\myclass\1.txt
在目录d:\myclass下生成1.txt文档显示详细信息。
dir >2.txt 显示当前目录下的文件和文件夹，并在当前路径下生成2.txt文档显示。
这叫数据重定向。
======= >在doc命令行中用于指定路径？？？

====== 虚拟机在启动时，运行main.class 类文件？？？

[/code]