黑马程序员-Java面向对象-day10

最新推荐文章于 2018-11-06 17:28:30 发布

赤脚浪涯

最新推荐文章于 2018-11-06 17:28:30 发布

阅读量414

点赞数

本文链接：https://blog.csdn.net/yinbolove576/article/details/10273083

版权

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

1、异常-finally

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 ExceptionDemo4
{
       public static void main(String[] args)
       {
              Demo d = new Demo();
              try
              {
                     intx = d.div(3,-1);
                     System.out.println("x="+x);
              }
              catch (FuShuException e)
              {
                     System.out.println(e.toString());
                     return;
              }
              finally
              {
                     System.out.println("finally");//finally中存放的是一定会被执行的代码
              }
              System.out.println("over");
       }
}

public void method()
{
       连接数据库；
      
       数据库操作；//throw new SQLException();
 
       关闭数据库；//该动作，无论数据操作是否成功，一定要关闭资源。
 
       try
       {
              连接数据库；
             
              数据操作；//throw new SQLException();
       }
       catch(SQLException e)
       {
       }
       finally
       {
              关闭数据库；
       }
}

2、异常处理语句的几种格式：

//第一种格式：
try{
}
catch (){
}
 
//第二种格式：
try{
}
catch (){
}
finally{
}
 
//第三种处理格式：
try{
}
finally{
}
//记住一点：catch是用于处理异常。如果没有catch就代表异常没有被异常处理过，
//如果该异常时检测时异常，那么久必须声明。

class Demo
{
       public void method()
       {
              try
              {
                     throw new Exception();
              }
              finally
              {
                     //关闭资源
              }
       }
}
class ExceptionDemo5
{
       public static void main(String[] args)
       {
              System.out.println("HelloWorld!");
       }
}

3、异常在子父类覆盖中的体现：

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

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

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

Exception

|--AException

|--BException

|--CException

class AException extends Exception{
}
class BException extends AException{
}
class CException extends Exception{
}
class Fu{
       voidshow() throws AException{
       }
}
class Test{
       void function(Fu f){
              try{
                     f.show();
              }
              catch (AException e){
              }
       }
}
class Zi extends Fu{
       void show() throws CException
       {}
}
class ExceptionDemo6
{
       public static void main(String[] args)
       {
              System.out.println("HelloWorld!");
       }
}

4、自定义异常代码演示

class NoValueException extendsRuntimeException
{
       NoValueException(Stringmessage)
       {
              super(message);
       }
}
interface Shape
{
       void getArea();
}
 
class Rec implements Shape
{
       private int len,wid;
       Rec(intlen,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
{
       public static final double PI = 3.14;
       private int radius;
       Circle(int radius)
       {
              if(radius<0)
                     throw new NoValueException("出现非法制");
              this.radius = radius;
       }
       public void getArea()
       {
              System.out.println(PI*radius*radius);
       }
}
 
class ExceptionTest1
{
       public static void main(String[] args)
       {
              Rec r = new Rec(3,4);
              r.getArea();    
 
              Circle c = new Circle(-3);
              c.getArea();
              System.out.println("over");
       }
}

5、异常总结：

异常：是什么？是对问题的描述，将问题进行对象的封装。

异常体系：

Throwable

|--Error

|--Exception

|--RuntimeException

异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性，也就是说可以被throw和throws关键字所操作。只有异常体系具备这个特点。

当函数内容有throw抛出异常对象，并为进行try处理，必须要在函数上声明。否则编译失败。

注意，RuntimeException除外，也就说，函数内如果抛出的RuntimeException异常，函数上可以不用声明。

如果函数声明了异常，调用者需要进行处理，处理方法可以throw，可以try

异常有两种：

编译时被检测异常：

该异常在编译时，如果没有处理（没有throw也没有try），编译失败。

该异常被标识，代表这可以被处理。

运行时异常（编译时不检测)

在编译时，不需要处理，编译器不检查。

该异常的发生，建议不处理，让程序停止，需要对代码进行修正。

注意：

1.finally中定义的通常是关闭资源代码，因为资源必须被释放。

2.只有当遇到System.exit(0);语句是，系统会退出，finally才不会被执行。

3.当catch语句中遇到return时，JVM会检查catch后有没有finally，如果有，则执行finally中的语句，然后退出；如果没有，则直接退出。

6、自定义异常：

定义类继承Exception或者RuntimeException

1.为了让该自定义类具备可抛性；

2.让该类具备操作异常的共性方法。

当要定义自定义异常的信息时，可以使用父类已经定义好的功能。

将异常信息传递给父类的构造函数。

classMyException extends Exception

{

MyException(String message)

{

super(message);

}

自定义异常：是按照java的面向对象思想，将程序中出现的特有问题进行封装。

异常的好处：

1.将问题进行封装；

2.将正常流程代码和问题处理代码相分离，方便与阅读。

异常的处理原则：

1.处理方式有两种：try或者throw。

2.调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch的情况。

3.多个catch，父类的catch要放在最下面。

4.catch内，需要定义针对性的处理方式，不要简单的定义printStackTrace，输出语句，也不要不写。当捕获到的异常，本功能处理不了时，可以继续在catch中抛出：

try

{

throw new AException();

}

catch (AException e)

{

throw e;

}

如果该异常处理不了，但并不属于该功能出现的异常。

可以将异常转换后，在抛出和该功能相关的异常。

或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，

让调用者知道，并处理，也可以将捕获异常处理后，转换型的异常。

try

{

throw new AException();

}

catch (AException e)

{

//throwAException();对AException处理。

throw new BException();

}

异常的注意事项：

在子父类覆盖时：

1.子类抛出的异常必须是父类的异常的子类或者子集；

2.如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

其实就是子类不能比父类抛出更多异常！

面试题：写出this关键字的含义，final有哪些特点？

this：代表本类对象，哪个对象调用this所在的函数，this就代表哪个对象。

final：

1.修饰类，变量(成员变量，静态变量，局部变量)，函数。

2.修饰的类不可以被继承；

3.修饰的函数不可以被覆盖

4.修饰的变量时一个常量，只能赋值一次。

5.内部类只能访问局部变量中被final修饰的变量

7、包（package）

对类文件进行分类管理

给类提供多层命名空间

写在程序文件的第一行

类名的全称是：包名.类名

包也是一种封装形式。

8、jar包

1.方便项目的携带。

2。方便于使用，只要在classpath设置jar路径即可。

3.数据库驱动，SSH框架等都是jar包体现的。

需要查看或者运行Jar包的时候，需要先将classpath路径设置成Jar包路径，

例如：setclasspath=c:\myclass\haha.jar

编译：javac -d 路径类名.java

javac -d c:\myclass PackageDemo.java 或者javac -d . PackageDemo.java 中间的.是指当前路径

-d:指定包所存放的位置

运行：java 包名.类名

java pack.PackageDemo

9、包与包之间访问

为了简化类名的书写，使用了一个关键字：import。

import导入的是包中的类。

建议不要写通配符*，需要用到包中的哪个类，就导入哪个类。

建议包名不要重复，可以使用url来完成定义，url是唯一的。

package pack;
import packb.haha.hehe.heihei.*;
class PackageDemo
{
       publicstatic void main(String[] args)
       {
              packa.DemoA d = new packa.DemoA();
              d.show();
 
              //packb.DemoB d = new packb.DemoB();
              //d.method();
       }
}

错误情况显示：

符号：类 DemoA

位置：类 pack.PackageDemo

DemoA d = new DemoA();

PackageDemo.java:7: 找不到符号

符号：类 DemoA

位置：类 pack.PackageDemo

DemoA d = new DemoA();

2 错误

错误原因：类名写错

因为类名的全名是：包名.类名

D:\java0414\day10>javac -d C:\myclassPackageDemo.java

PackageDemo.java:7: 软件包 packa 不存在

packa.DemoA d = newpacka.DemoA();

PackageDemo.java:7: 软件包 packa 不存在

packa.DemoA d = newpacka.DemoA();

2 错误

错误原因：packa包不在当前目录下

需要设置classpath，告诉jvm去哪里找指定的packa包。

有了包，范围变大，一个包中的类要被访问，必须要有足够大的权限，所以被访问的的类要被public修饰

D:\java0414\day10>javac -d c:\myclassPackageDemo.java

PackageDemo.java:8: show() 在 packa.DemoA 中不是公共的；无法从外部软件包中对其进

行访问

d.show();

1 错误

错误原因：类共有后，被访问的成员也要共有才可以被访问。

总结：

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

不同包中的子类还可以直接访问父类中被protected权限修饰的成员

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

public protected default private

同一个类中 ok ok ok ok

同一个包中 ok ok ok

子类 ok ok

不同包中 ok

package packa;
 
public class DemoA //extends packb.DemoB
{
       public void show()
       {
              System.out.println("demoa showrun");
              //method();
       }
}

package packb;
public class DemoB
{
       protected/*保护*/ void method()
       {
              System.out.println("demob methodrun");
       }
}

package packc.haha.hehe.heihei;
public class DemoC
{
       public void show(){}
}

注意：当想建立一个包中的两个不同类而防止在编译的时候被覆盖，这里可以将另一个类在新建的java文档里添加同名包名，这样编译的时候就不会覆盖原始类产生的class文件。

10、导入import

为了简化类名的书写，使用一个关键字，import；

例如：import packb.haha.hehe.heihei.DemoC;

如果当前目录下的类特别多，这里可以使用通配符*，即导入子包中所有的类，例如：

importpackb.haha.hehe.heihei.*;

但是在真实开发项目中，我们为了让程序运行的精简，更快，当我们需要用哪个类的时候，就直接导入哪个类，防止将过多的类导入后，占用空间，导致程序运行过慢。

如何定义包名？

建议定义包名不要重复，可以使用url来完成定义，url是唯一的，例如：www.itheima.com

定义包名的形式为：package com.itheima.test

11、Jar包

1、Java的压缩包

1.方便项目的携带；

2.方便于使用，只要在classpath设置jar路径即可；

3.数据库驱动，SSH框架等都是以jar包体现的。

2、如何创建jar包？

格式：jar -cfxx.jar 包名，前提是需要切换到打包路径中，且路径中已经存在相应包文件

jar -cf haha.jar packa pack

3、jar命令常见用法：

-c:创建新的归档文档；

-f:指定归档文件名

-t:列出归档目录

-v:在标准输出中生成详细输出

当使用jar命令打包程序后，jar包文件中会有一个配置清单文件

设置jar包的classpath路径方式为setclasspath=c:\myclass\haha.jar

将jar包中的详细信息写入硬盘中的一个文件里，操作如下：

jar -tf a.jar >c:\1.txt

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net

赤脚浪涯

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员-Java面向对象-day10

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------1、异常-finallyfinally代码块：定义一定执行的代码，通常用于关闭资源。 class FuShuException extends Exception{ FuShuException(
复制链接

扫一扫