黑马程序员-JAVASE入门（异常，包）

最新推荐文章于 2015-04-08 00:27:32 发布

a78926635

最新推荐文章于 2015-04-08 00:27:32 发布

阅读量374

点赞数

分类专栏：学习总结

本文链接：https://blog.csdn.net/a78926635/article/details/8947593

版权

学习总结专栏收录该内容

29 篇文章 0 订阅

订阅专栏

------- android培训、java培训、期待与您交流！ ----------

异常：

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

异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。
			其实就是java对不正常情况进行描述后的对象体现。

对于问题的划分：两种：一种是严重的问题，一种非严重的问题。

对于严重的，java通过Error类进行描述。
	对于Error一般不编写针对性的代码对其进行处理。

对与非严重的，java通过Exception类进行描述。
	对于Exception可以使用针对性的处理方式进行处理。

无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等。

Throwable
	|--Error
	|--Exception

throwable的方法：

  
  
   
   
    
    getMessage()

   
   
   
   
    
    获取异常信息，返回字符串。

   
   
   
   
    
    toString()

   
   
   
   
    
    获取异常类名和异常信息，返回字符串。

   
   
   
   
    
    printStackTrace()

   
   
   
   
    
    获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

   
   
   
   
    
    printStackTrace(PrintStream s)

   
   
   
   
    
    通常用该方法将异常内容保存在日志文件中，以便查阅
   
   
  
  


1,异常的处理
java 提供了特有的语句进行处理。
try
{
	需要被检测的代码；
}
catch(异常类 变量)
{
	处理异常的代码；(处理方式)
}
finally
{
	一定会执行的语句；
}


3，对捕获到的异常对象进行常见方法操作。
	String getMessage()：获取异常信息。

在函数上声明异常。
便于提高安全性，让调用出进行处理。不处理编译失败。

对多异常的处理。

1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
	如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。


建立在进行catch处理时，catch中一定要定义具体处理方式。
不要简单定义一句 e.printStackTrace(),
也不要简单的就书写一条输出语句。

通过下面代码对文字进来了解：

class Demo//异常处理
{
	int div(int a,int b)throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。
	{
		return a/b;
	}
}


class  ExceptionDemo
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(4,1);
			System.out.println("x="+x);
		}
		catch (Exception e)//Exception e = new ArithmeticException();
		{
			System.out.println("除零啦");
			System.out.println(e.getMessage());//  / by zero;
			System.out.println(e.toString());// 异常名称 ： 异常信息。

			e.printStackTrace();//异常名称，异常信息，异常出现的位置。
							//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。
							//打印异常的堆栈的跟踪信息。
		}		
		System.out.println("over");

	}
}
//对多异常的处理
class Demo
{
	int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上通过throws的关键字声明了该功能有可能会出现问题。
	{

		int[] arr = new int[a];

		System.out.println(arr[4]);

		return a/b;
	}
}


class  ExceptionDemo2
{
	public static void main(String[] args) //throws Exception
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(5,0);//如果是为报告的异常
			System.out.println("x="+x);
		}
		
		catch(Exception e)
		{
			System.out.println("查看是什么异常:"+e.toString());
		}/*对两种异常进行处理。
		catch (ArithmeticException e)
		{
			System.out.println(e.toString());
			System.out.println("被零除了!!");

		}
		catch (ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
			System.out.println("角标越界啦！！");
		}
		
		*/
		System.out.println("over");

	}
}

2：自定义异常：

因为项目中会出现特有的问题，
而这些问题并未被java所描述并封装对象。
所以对于这些特有的问题可以按照java的对问题封装的思想。
将特有的问题。进行自定义的异常封装。

自定义异常。

需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的。
那么就需要对这个问题进行自定义的描述。

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
要么在内部try catch处理。
要么在函数上声明让调用者处理。

一般情况在，函数内出现异常，函数上需要声明。


发现打印的结果中只有异常的名称，却没有异常的信息。
因为自定义的异常并未定义信息。

如何定义异常信息呢？
因为父类中已经把异常信息的操作都完成了。
所以子类只要在构造时，将异常信息传递给父类通过super语句。
那么就可以直接通过getMessage方法获取自定义的异常信息。



自定义异常：
必须是自定义类继承Exception。


继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

只有这个体系中的类和对象才可以被throws和throw操作。



throws和throw的区别
throws使用在函数上。
throw使用在函数内。

throws后面跟的异常类。可以跟多个。用逗号隔开。
throw后跟的是异常对象。

class FuShuException extends Exception //getMessage();继承Exception自定义一个异常
{
	private int value;

	FuShuException()
	{
		super();//用父类方法
	}
	FuShuException(String msg,int value)//用父类方法然后自定义一个方法
	{
		super(msg);
		this.value = value;
	}

	public int getValue()//返回自定义方法的数值
	{
		return value;
	}

}
class Demo
{
	int div(int a,int b)throws FuShuException
	{
		if(b<0)
			throw new FuShuException("出现了除数是负数的情况------ / by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。
		return a/b;
	}
}
class  ExceptionDemo3
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(4,-9);
			System.out.println("x="+x);		
		}
		catch (FuShuException e)
		{
			System.out.println(e.toString());
			//System.out.println("除数出现负数了");
			System.out.println("错误的负数是："+e.getValue());
		}
		System.out.println("over");

	}
}

3：RuntimeException异常：

Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。

如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。

如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；

之所以不用在函数声明，是因为不需要让调用者处理。
当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，
对代码进行修正。




自定义异常时：如果该异常的发生，无法在继续进行运算，
就让自定义异常继承RuntimeException。


对于异常分两种：
1，编译时被检测的异常。
	
2，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)

异常的finally：

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

第二个格式：
try{	
}
catch (){

}
finally{
}

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

finally代码块：定义一定执行的代码。通常用于关闭资源。

用一个简单的数据库例子

public void method()throws NoException
{

	连接数据库;

	数据操作;//throw new SQLException();

	关闭数据库;//该动作，无论数据操作是否成功，一定要关闭资源。
	try
	{		
		连接数据库;

		数据操作;//throw new SQLException();
	}
	catch (SQLException e)
	{
		会对数据库进行异常处理;
		throw new NoException();

	}
	finally
	{
		关闭数据库;
	}
}

包

对类文件进行分类管理。

给类提供多层命名空间。

写在程序文件的第一行。

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

包也是一种封装形式。

包之间的访问

被访问的包中的类权限必须是public的。

类中的成员权限：public或者protected

protected是为其他包中的子类提供的一种权限

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

*/

a78926635

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员-JAVASE入门（异常，包）

------- android培训、java培训、期待与您交流！ ----------异常：异常：就是程序在运行时出现不正常情况。------------ 异常的注意事项：在子父类覆盖时： 1，子类抛出的异常必须是父类的异常的子类或者子集。 2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。异常由来：问题也是现实生活中一个具体的事物，也可
复制链接

扫一扫