黑马程序员-Java的面向对象（异常和包）

最新推荐文章于 2016-04-24 17:22:53 发布

探索者Y

最新推荐文章于 2016-04-24 17:22:53 发布

阅读量378

点赞数 1

分类专栏： java基础文章标签：异常

本文链接：https://blog.csdn.net/tansuozhey/article/details/50199917

版权

java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

Java的面向对象要点问题总结3

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

     2、异常体系：
       （1）对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
    a、对于严重的，java通过Error类进行描述,一些超出JVM处理能力的问题。
  对于Error一般不编写针对性的代码对其进行处理。
       例如：byte[] arr = new byte[1024*1024*500];
       结果：Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
                    at ExceptionDemo.main(ExceptionDemo.java:4)

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

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

    d、Throwable
     |--Error
     |--Exception
     |--RuntimeException

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

      3、异常处理语句：
         （1）try块
  try
  {
   需要被检测的代码；
  }
  catch (异常类变量)
  {
   处理异常的代码（处理方式）；
  }
  finally
  {
   一定会执行的代码（即使catch块中用return）；
  }

注：a、catch语句中的异常类必须和try作用域中产生的对象的异常类是同一个类或者是它的父类；
b、try作用域中产生异常时，下面的语句就不再执行，如果catch能捕获异常，直接跳转到catch作用域去执行；

   （2）有三个结合格式：
  a、 try
   {

   }
   catch ()
   {
   }

  b、 try
   {

   }
   finally
   {

   }

  c、 try
   {

   }
   catch ()
   {
   }
   finally
   {

   }

注意：
（1）finally中定义的通常是关闭资源代码。因为资源必须释放。
（2）finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。
（3）catch是用于处理异常，如果没有catch就代表异常没有被处理过，如果该异常是检测时异常。那么必须声明。

4、对捕获到的异常对象进行常见方法操作
（1）public String getMessage();获取异常信息;
（2）public void printStackTrace();//获取异常名称、异常信息和异常出现的位置
其实，JVM默认的异常处理机制也是调用它打印异常的堆栈中的信息。

     5、throw和throws的用法：
        throw定义在函数内，用于抛出异常对象。
        throws定义在函数上，用于抛出异常类，可以抛出多个异常，用逗号隔开;发生异常的地方后面的语句不执行，直接执行throws。

            当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。
        注意：(1)RuntimeException和它的子类除外；也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明;
              (2)如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。

     6、异常的处理
        （1）直接抛出异常
      在函数上声明异常，便于提高安全性，让调用处进行处理。不处理编译就会失败。

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

例如：可以把异常信息输出到硬盘上异常日志文件中。

        （3）对多异常的处理
      a、声明异常时，建议声明更为具体的异常。这样处理的可以更具体；
      b、一个方法不可能同时抛出两个异常，因为当抛出第一个异常时，后面的程序语句就不会再去执行了；
      c、对方声明几个异常，就对应有几个catch块。不要就用一个父类的异常处理所有的异常；
      d、对方声明几个异常，就对应有几个catch块,如果有其他异常，不要用父类的异常简单处理掉，就让程序停掉在检查；
      e、对方声明几个异常，就对应有几个catch块。不要定义多余的catch块，
  如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

7、特殊RuntimeException类及其子类异常处理
JVM希望通过程序员自己进行代码的修正，解决这个问题的一类异常。

       （1）Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常,它属于 Java 进行的标准运行期检查的
            一部分,所以，
        a、如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过；
        b、如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；
             之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，
        出现了无法继续运算的情况，希望停止程序后，对代码进行修正。

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

class  NegativeException extends RuntimeException{

	NegativeException(String msg){
		super(msg);
	}
}

class  DivDemo {
	int div(int x,int y){
        
		if(y<0)
			throw  new ArithmeticException("除数为负数出现了！");
		
		return  x/y;
	}
}


class ExceptionDemo3 {
	public static void main(String[] args) {

		DivDemo  dd = new DivDemo();
		int value = dd.div(3,-1);
		System.out.println("value= "+value);

		System.out.println("end");
	}
}

     8、异常有两种：
       （1）编译时被检测异常
  该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
  该异常被标识，代表这可以被处理。调用者也要么抛，要么try处理。
       （2）运行时异常(编译时不检测)
  在编译时，不需要处理，编译器不检查。
  该异常（RuntimeException类及其子类）的发生，建议不处理，让程序停止。需要对代码进行修正。

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

       （2）当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
  要么在内部try catch处理。
  要么在函数上声明让调用者处理。
            注：一般情况在，函数内出现异常，函数上需要声明。

       （3）发现打印的结果中只有异常的名称，却没有异常的信息。因为自定义的异常并未定义信息：
         因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过super(msg)语句。
     那么就可以直接通过getMessage方法获取自定义的异常信息。

         当要定义自定义异常的信息时，可以使用父类已经定义好的功能。
     异常异常信息传递给父类的构造函数。
  class MyException extends Exception{
   MyException(String message)
   {
    super(message);
   }
  }

       （4）自定义类继承Exception或者RuntimeException
      a、因为自定义异常类和对象都需要被抛出，为了让该自定义类具备可抛性，这个可抛性是Throwable这个体系中独有特点；
         只有这个体系中的类和对象才可以被throws在方法上声明和被throw在方法中抛出；
      b、让该类具备操作异常的共性方法，比如 toString()等；
      c、自定义异常时，如果该异常的发生，无法在继续进行运算，就让自定义异常继承RuntimeException。

class  NegativeException extends Exception{
	//private  String  msg;
	//NegativeException(String msg){
		//this.msg = msg;
	//}

	//public String  getMessage(){
		//return msg;
	//}
    private int value;

	NegativeException(){
		super();
	}

	NegativeException(String msg,int value){
		super(msg);
		this.value = value;
	}

	public int getValue(){
		return value;
	}
}


class  DivDemo {
	int div(int x,int y) throws NegativeException{

		if(y<0){
			throw new NegativeException("a negative appear.",y);
		}
		
		return  x/y;
	}
}


class ExceptionDemo4 {
	public static void main(String[] args) {
		
		try{

			DivDemo  dd = new DivDemo();
			int value = dd.div(3,-1);
			System.out.println("value= "+value);

		}catch(NegativeException e){  

			System.out.println(e.toString());
			System.out.println(e.getValue());
	    }

	}
}

      10、异常的处理原则：
（1）处理方式有两种：try 或者 throws。
（2）调用到抛出异常的功能时，抛出几个，就处理几个；一个try对应多个catch。
（3）多个catch，父类的catch放到最下面。
（4）throw下面不能写任何语句;
（5）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();
   //throw下面不能写任何语句。
  }

比如，汇款的例子。

/*
需求：老师用电脑上课

思路：
1、类：老师 电脑

2、异常：电脑蓝屏
         电脑无法开机
		 课程计划按时完成问题
*/

class  BlueScreenException extends Exception{
	BlueScreenException(String msg){
		super(msg);
	}
}

class  NoBootException extends Exception{
	NoBootException(String msg){
		super(msg);
	}
}

class  LessonPlanException extends Exception{
	LessonPlanException(String msg){
		super(msg);
	}
}

class Computer{

	private  int  flag = 3;

	public  void  run() throws BlueScreenException,NoBootException{
		if(flag ==2){
			throw  new BlueScreenException("电脑蓝屏！");
		}
	    if(flag ==3){
			throw  new NoBootException("电脑不能启动！");
		}

		System.out.println("电脑运行......");
	}

	public  void  reset(){
		System.out.println("电脑重启......");
	}

}

class Teacher{

	private  String  name;
	private  Computer  cp;

	Teacher(String name){
		this.name = name;
		cp = new Computer();
	}

	public  void  test(){
		System.out.println("练习！");
	}

	public void  prelect()throws LessonPlanException{

		try{

			cp.run();
			System.out.println("讲课!");
		}catch(BlueScreenException e){

			cp.reset();
			System.out.println("继续讲课!");

		}catch(NoBootException e){
			test();
			throw  new  LessonPlanException(e.getMessage()+"课程计划会有影响!");
		}
		
	}
}

class ExceptionTest {

	public static void main(String[] args) {
		Teacher  tc  = new  Teacher("李老师!");

		try{

			tc.prelect();

		}catch(LessonPlanException e){
			
			System.out.println(e.getMessage());
			System.out.println("更换电脑!");
		}
	}
}

/*
需求：有一个圆形和长方形，都可以获取面积。
      对于面积如果出现非法的数值，视为是获取面积出现问题，问题通过异常来表示。

分析：
    1、圆形和长方形都是形状，可以抽象出形状类或者接口；
	2、非法的数值：负数，这种是可以通过code修正的，继承RuntimeException类
*/

class  InvalidAreaException extends RuntimeException{
	InvalidAreaException(String msg){
		super(msg);
	}
}


interface  Shape{
	public  double   getArea();
}

class Circle implements Shape{
	
	private  double  radius;

	Circle(double radius){
		if(radius <=0)
			throw  new  InvalidAreaException("非法值!");
		this.radius = radius;
	}

	public double getArea() {

		return  Math.PI*Math.pow(radius,2);
	}

}

class Rectangle implements Shape{
	private int length,width;

	Rectangle(int length,int width){
		if(length <=0||width<=0)
			throw  new  InvalidAreaException("非法值!");
		this.length = length;
		this.width = width;
	}

	public double  getArea(){
		return  length*width;
	}
}

class ExceptionTest1{
	public static void main(String[] args) {
		
		//Shape  sr = new Rectangle(-3,4);
		//double  rectangleArea = sr.getArea();
		//System.out.println("rectangleArea= "+rectangleArea);


		Shape  sc = new Circle(0);
		double  circleArea = sc.getArea();
		System.out.println("circleArea= "+circleArea);
	}
}

      11、异常在子父类覆盖中的体现；
            a、子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类；
        如果子类方法发生了新的异常。就必须要进行try处理。绝对不能抛。
            b、如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
            c、如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。
        如果子类方法发生了新的异常。就必须要进行try处理。绝对不能抛。

/*
Exception 
	|--AException
		|--BException
	|--CException
	|--DException
*/
class AException extends Exception{
}

class BException extends AException{
}

class CException extends Exception{
}

class DException extends Exception{
}

class Father{
    //(a)
	/*
	void show()throws AException{
	
	}
	*/

	//(b)
	
    void show()throws AException,CException{
	
	}
	

	//(c)
	/*
	void show(){
	
	}
	*/

}

class Child extends Father{
    
	//(a)
	/*
	void show()throws CException{//ExceptionDemo5.java:23: 错误: Child中的show()无法覆盖Father中的show()
		
	}

	void show ()throws AException{ //BException

	}
	
	void show(){

		try{
			throw  new  CException();
		}catch(CException e){
		}
	}
	*/
     
	//(b)
	/*
	void show()throws AException,CException{
	}

    void show()throws AException,BException,CException{
	}
	*/
	void show()throws CException{
	}
	

    //(c)
	/*
	void show()throws DException{ //ExceptionDemo5.java:74: 错误: Child中的show()无法覆盖Father中的show()
	}
	

	void show(){ 
		try{
			throw  new AException();
		}catch(AException e){
		}
	}
	*/
}


class  ExceptionDemo5{

	void function(Father f){
		try
		{
			f.show();
		}catch (AException e){

		}catch (CException e){

		}
	}

	public static void main(String[] args) {
		ExceptionDemo5 t = new ExceptionDemo5();
		t.function(new Child());
	}
}

12、异常的好处：
（1）将问题进行封装成异常类；
（2）将正常流程代码和问题处理代码相分离，方便于阅读；
（3）用于控制那些讨厌的运行期错误-由代码控制范围之外的其他力量产生;
（4）有助于调试某些特殊类型的编程错误，那些是编译器侦测不到的。

二、包
    通过命名空间的方式对类进行封装，进行分类管理的机制。
    1、package
       （1） package 包名必须被写在程序code的第一行；
       （2）包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰；
       （3）不同包中的子类还可以直接访问父类中被protected权限修饰的成员；
       （4）包与包之间可以使用的权限只有两种，public protected；
       （5）建立定包名不要重复，可以使用url来完成定义，url是唯一的；

    2、import关键字：为了简化类名的书写，使用一个关键字import
       （1）import 导入的是包中的类，即加载这个类到内存中；
       （2）建议不要写通配符 * ，因为那样会把子包下的所有类加载到内存，
            需要用到包中的哪个类，就导入哪个类；
       （3）当导入的包中有相同的类名时，就不能使用简写的类名定义类的对象，而要使用全称。

三、jar压缩包
    1、JAR file
       （1）用下面的命令行：
  jar -cfvt   xxx.jar   yyy.class/yyy ;
                jar -cfvt   xxx.jar   -C   yyy/ . ;
       （2）把xxx.jar放到classpath路径下 (即 classpath = ...xxx.jar)，
            就可以使用java命令来执行jar包中的带有main方法的类；

    2、Runable JAR file：可以双击运行的jar文件
       （1）可执行的jar包中的MANIFEST.MF文件，需要Main-Class的信息；
  Manifest-Version: 1.0
  Class-Path: .
  Main-Class: c13.beans.BangBean

（2）用下面的命令行
jar -cfvtm xxx.jar yyy.txt zzz.class/zzz；

     其中，yyy.txt中要
  Main-Class:(空格)c13.beans.BangBean(回车)的格式，
     因为只有有空格和回车，java命令才能正确的识别。

class Test
{ 
	public static String output=""; 
	public static void foo(int i)
	{ 
		try
		{ 
			if(i==1)
				throw new Exception(); 	
			output+="1"; 
		} 
		catch(Exception e)
		{ 
			output+="2"; 
			return; 
		} 
		finally
		{ 
			output+="3"; 
		} 
		output+="4"; 
	}
	public static void main(String args[])
	{ 
		foo(0);
		System.out.println(output);//134
		foo(1); 
		System.out.println(output); //13423
	}
}

探索者Y

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员-Java的面向对象（异常和包）

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ Java的面向对象要点问题总结3 黑马程序员-Java的面向对象要点问题总结3一、异常 1、异常是程序
复制链接

扫一扫

专栏目录