黑马程序员--- 学习笔记(第十天)

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————
return finally语句也会执行




finally代码块:定义执行的代码,通常用于关闭资源.


第一格式:
try{


}catch{


}
第二格式:
try{


}catch{


}finally{


}
第三格式:
try{


}finally{


}


记住一点:
catch是用于处理异常,如果该catch,就代表异常没被处理,
如果该异常时检测时异常,必须作出对应的处理

/*
异常测试
*/
class Demo1 
{
	public static void main(String[] args)
	{	
		/*
		//有没有用catch处理,编译失败
		 try
		 {
			new Test().show(-11);
		 }
		 finally
		 {
			 System.out.print("一定会执行的语句");
		 }
		 */	
		//	 
		 try
		 {
			new Test().show(-11);
		 }
		 catch(Exception e)
		 {
			e.printStackTrace();
		//	return;//finaly也一定会执行g
			System.exit(0);//jvm退出了,finally就不会执行了
		 }finally{
			System.out.println("这是一定会执行的语句");
		 }
	}
}
class Test
{
	public void show(int a)throws Exception{
		if(a<0)
		throw new Exception("出现非法数值");
	}
}

异常在子父类覆盖中的体现:


1.子类的覆盖父类,如果父类时,如果父类的方法抛出异常,
那么覆盖的方法只能抛出父类的异常(自己)或者该异常的子类
2.如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出该
父类异常的子集.
3.如果父类或者接口方法中,没有异常抛出,那么子类在覆盖时,
也不可以抛出异常
如果子类方法发生了异常,就必须进行try处理,绝对不能抛


异常总结:
异常是什么?
是对问题的描述,将问题进行对象的封装
异常体系:
throwable
|--Error
|--Exception
|--RuntimeExcepetion
异常体系的特点:
异常体系中所有的类以及建立的对象都具有可抛性,也就是说
可以被throw和throws关键字所操作,只有异常体系具备这个特点


throw和throws的用法:
throw定义在函数内,用于抛出异常对象
throws定义在函数上,用于抛出异常类,可以抛出多个,用逗号隔开


当函数内throw抛出对象,并未进行try处理,必须要在函数上声明,否则就
编译失败,注意:RuntimeException除外,也就是说,函数内抛出的RuntimeException
及其子类在函数上不用声明.


当在函数上声明了异常,调用者需要进行处理,处理方法可以throws
,可以try


异常分两种:
1.编译时被检测异常
该异常在编译时,如果没有处理,编译失败
该异常被标识,代表这可以被处理
2.运行时异常(编译时不检测)
在编译时,不需要处理,编译器不检查
该异常发生,建议不处理,让程序停止,需要对代码进行改正


注意:
1.finally中定义通常的是关闭资源代码,因为资源必须要释放
2.当System.exit(0);这种情况发生时,finally不会执行


自定义异常:
定义类继承Exception或RuntimeException
1.为了让该自定义异常具备可抛性
2.让该类具备操作异常的共性方法
当要定义自定义异常信息时,可以使用父类已经定义好的功能
,异常信息传参给父类的构造函数
class MyException extends Exception
{
public MyException(String ms){
super(ms);
}
}
自定义异常:
按照java的面向对象思想,将程序出现的特有问题进行封装


异常的好处:
1.将问题进行封装
2.将正常流程代码和问题代码相分离,方便与阅读


异常的处理原则:
1.处理方式有两种:try或者throws
2.调用抛出异常功能时,抛出几个,就处理几个
一个try对应多个catch块
3.多个catch块,父类的catch放到最下面
4.catch内,需要定义针对性的处理方式,不要简单的定义printStackTrace
,输出语句,也不要不写.当捕获到异常,本功能处理不了时,可以 继续
在catch中抛出


如果该异常处理不了,但并不属于该功能出现的异常,可以将异常转换后
在抛出和该功能相关的异常或者异常可以处理.就需要将异常产生的和本
功能相关的问题提供出去.当调用者知道,并处理,也可以将捕获的异常处理
后,转换新的异常:比如:汇款的例子


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

/*
异常在子父类中覆盖的特点
*/
class Demo2 
{
	public static void main(String[] args) 
	{
		Fu f=new Zi();
		try
		{
			f.show();
		}
		catch (Exception e)
		{
		}
	}
}
class AException extends Exception 
{
}
class BException extends AException 
{
}
class CException extends Exception 
{
}
class DException extends Exception 
{
}
class Fu
{
	public void show()throws AException,CException{

		System.out.println("fu");
				throw new AException();
	}
}
class Zi extends Fu
{	//子类覆盖父类方法时,只能抛出父类的异常或者异常子类,或者子集
	public void show()throws BException{
	   System.out.println("zi");
	}
}
/*接口中不抛异常,子类只能try*/
interface Inter
{
	public abstract void show();
}
class Test2 implements Inter
{	//继承或者实现接口,子类覆盖函数内容发生异常之后不能抛,只能try
	public void show(){
		try
		{
			throw new Exception();
		}
		catch (Exception e)
		{
		}
	}
}

/*
注意事项:
*/
class Demo3 
{
	public static void main(String[] args) 
	{
		Test t=new Test();
		try
		{
			t.show(15);	//异常被封装在函数内,可能不会发生异常的情况
			System.out.println("这里可能还会执行到");

			throw new Exception();//单独throw存在,后面不能跟语句,否则编译失败
			//System.out.print("这里不允许有语句,因为执行不到");
		}
		catch (AException e)
		{
			e.printStackTrace();
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}
class AException extends Exception
{
	public AException(String msg){
		super(msg);
	}
}
class Test
{
	 public void show(int a)throws AException{
		if(a<0)
			throw new AException("出现非法数值");
	 }
}

变量不存在覆盖
静态方法只能覆盖静态方法
覆盖要注意(参数类型,参数个数),还有权限


注意:
showExce();//后面可以跟语句,异常被封装在函数内
throw new　Exception();//后面不能跟语句,会编译失败的


throw单独存在,不要定义语句在后面

 /*
 需求:
 对有一个长方形 和圆形 都可以获取面积

 如果获取面积输入非法数值,则抛出异常
 */
class Demo4 
{
	public static void main(String[] args) 
	{
		Circle c=new Circle(1.5);
		System.out.println(c.getArea());
		Rec r=new Rec(-4,5);//传入非法数值就会报错
		System.out.println(r.getArea());
	}
}
/*
图形接口 扩展功能 或者自身的面积
*/
interface  Shape
{
	public abstract double getArea();
}
/*
非法数值异常
*/
class FeiFaArugmentException extends RuntimeException
{
	public 	 FeiFaArugmentException(String msg){
		super(msg);
	}
}
/*长方形类*/
class Rec implements Shape 
{	
	private double chang;
	private double kuan;
	public Rec(double chang,double kuan){
		if(chang<=0 || kuan<=0)
			throw new FeiFaArugmentException("非法数值异常");
	   this.chang=chang;
	   this.kuan=kuan;
	}
	public double getArea(){
	   return chang*kuan;
	}
}
/*圆形类*/
class Circle implements Shape 
{
	public static final double PI=3.14;
	private double radius;
	public Circle(double radius){
		this.radius=radius;
	}
	public double getArea(){
		 return Math.pow(radius,2)*PI;
	}
}

包(package)
1.对类文件进行处理
2.给类提供层命名空间
3.写在程序文件第一行
4.类名的全称是包名.类名
5.包也是一种封装形式




cmd命令:
javac -d 文件夹  类名 //会自动将package语句生成文件夹形式

package com.it;//创建包 com.it

import com.it2.Demo6;//导入com.it包
public class Demo5 extends Demo6
{
	public static void main(String[] args) 
	{
		Demo5 t=new Demo5();
		t.publicMethod();
		/*继承之后就能访问了*/
		t.protectedMethod();//不继承不能访问
		//t.defaultMethod(); //不同包中不能访问
		//t.privateMethod(); //不同包不能放访问
	}
}

package com.it2; //创建包com.it

 /*权限必须为public*/

public class Demo6 
{
	public void publicMethod(){
	   System.out.println("publicMethod");
	}
	protected void protectedMethod(){
	      System.out.println("protectedMethod");
	}
	void defaultMethod(){
	   System.out.println("defaultMethod");
	}
	private void privateMethod(){
	   System.out.println("privateMethod");
	}
}

总结:
1.包与包之间进行访问,只能访问public的类及类中的成员
需要被public所修饰


2.不同包中,子类可以访问父类中被protected修饰的成员




  public   protected   default   private
同一个类中   ok ok   ok   ok
同包中     ok ok   ok   no
子类     ok ok   no   no
不同包中     ok no   no   no


导入(import)


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


import导入的是包中的类


开发建议用到那个类,就导入那个类,不要写*


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




jar包


cmd命令如下:
-c是创建文件夹 v是查看详细信息 f是指定文件名
jar -cvf  文件名.jar [包文件夹] [包文件夹]//多个用空格隔开


jar -tvf 文件名.jar > d:/1.txt  //-t列出目录  重定向到1.txt文件中


jar -tvf 文件.jar > d:/1.txt 




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