Day 09 10 面向对象

Day 09 10 面向对象

——内部类、异常、包
内部类
将一个类定义在另一个类的里面，对里面那个类就成为内部类（内置类，嵌套类）。
访问规则
访问特点：
1.内部类可以直接访问外部类中的成员，包括私有成员。之所以可以直接访问外部类中的成员，是因为外部类中持有了一个外部类的引用，格式 外部类名.this
2.而外部类要访问内部类中的成员必须要建立内部类的对象。
访问格式
1）当内部类定义在外部类的成员位置上，并且非私有，可以在外部其他类中。可以直接建立内部类对象。格式 外部类名.内部类名 变量名 =外部类对象.内部类对象；
Outer.Inner in = new Outer().new Inner();
2）当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private：将内部类在外部类中进行封装。
静态内部类
static：内部类就具备static的特性。当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。
*在外部其他类中，如何直接访问static内部类的非静态成员呢？
new Outer.Inner().function();–>inner:3

*在外部其他类中，如何直接访问static内部类的静态成员呢？
Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。

当外部类中的静态方法访问内部类时，内部类也必须是static的。

class Outer
{
	private static int x = 3;
	static class Inner//静态内部类
	{
		static void function()
		{
			System.out.println("inner:" + x);
		}
	}
	static class inner2
	{
		void show()
		{
			System.out.println("inner2 show");
		}
	}

	public static void method()
	{
		Inner.function();
	}
}
class InnerClassDemo
{
	public static void main(String[] args) 
	{
		//Outer.method();
		new Inner2().show();
	}
}

class Outer
{
	private int x = 3;
	class Inner//内部类
	//private  class Inner
	//内部类可以被私有修饰，当内部类在外部类成员位置上是可以
	//static  class Inner//静态内部类
	{
		int x = 4;
		void function()
		{
			int x = 6;
			System.out.println("inner:" + x);//-->x = 6内部有不出去找
			//System.out.println("inner:" + this.x);//-->x = 4
			//System.out.println("inner:" + Outer.this.x);//-->x = 3
		}
	}
	void method()
	{
		Inner in = new Inner();
		in.function();
	}
}
/*
class Outer2
{
	class Inner
	{
	}
}
*/

class InnerClassDemo
{
	public static void main(String[] args) 
	{
		Outer out = new Outer();
		out.method();

		//直接访问内部类中的成员
		//Inner in = new Inner();//-->有两个同名内部类不知道访问哪个
		//Outer.Inner in = new Outer().new Inner(); 
		//in.function();
}

内部类定义原则
当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部事物的内容（函数和变量）。
当一个类需要直接访问到另外一个类中的成员的时候，把那个类写到这类的里面，写完后封装起来不对外暴露，而对外提供方法来访问内部事物。
class Body
{
private class XinZang
{
}
public void show()
{
new XinZang();
}
}
内部类定义在局部时
1.不可以被成员修饰符修饰
2.可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

class Outer
{
	int x = 3;
	void method()
	{
		final int y = 4;
		class Inner
		//不能被静态修饰，static只修饰成员，现在Inner为局部
		//局部内部类不能有static，不能定义静态成员
		{
			void function(final int a)
			{
				//System.out.println(Outer.this.x);
				//System.out.println(y);
				System.out.println(a);
			}
		}
		new Inner().function();
	}
}

class  InnerClassDemo2
{
	public static void main(String[] args) 
	{
		//new Outer().method(7);
		Outer out = new Outer();
		out.method(7);
		out.method(8);
	}
}

匿名内部类
1.匿名内部类其实就是内部类的简写格式。
2.定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
3.匿名内部类的格式：new 父类或者接口（构造函数传参数）{定义子类的内容}
4.其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，可以理解为带内容的子类对象。（看到匿名内部类，是一个子类对象，是把定义类和建立对象封装在一体的表现形式）
5.匿名内部类中定义的方法最好不要超过3个。

abstract class AbsDemo
{
	abstract void show();
}

class Outer
{
	int x = 3;
	/*
	class Inner extends AbsDemo//继承了一个类
	{
		void show()//复写
		{
			System.out.println("show : " + x);
		}
	}
	*/
	public void function()
	{
		//创建内部类的对象和方法
		//new Inner().show();//调用
		/*
		//new Inner().show();
		new AbsDemo()//用父类替代
		{
			void show()
			{
				System.out.println("x = " + x);
			}
		}.show();//调用方法
		*/
		AbsDemo d = new AbsDemo()//创建对象后带着内容
		//这个整体是AbDemo的子类对象，只有子类才能复写AbsDemo中的抽象方法
		{
			void show()
			{
				int num = 9;
				System.out.println("num ====" + num);
				
			}
			void abc()
			{
				System.out.println("haha");
			}//.show();//一个匿名对象只能调用一个子类对象
		};
		d.show();
		//d.abc();编译失败，父类中没定义过
	}
}

class InnerClassDemo3
{
	public static void main(String[] args) 
	{
		new Outer().function();
	}
}

interface Inter
{
	void method();
}

class Test
{
	//不足代码，通过匿名内部类
	/*
	static class Inner implements Inter
	{
		public void method()
		{
			System.out.println("method run");
		}
	}
	*/
	static Inter function()
	{
		//return new Inner();Inner的父类接口代替
		renturn new Inter()
		{
			public void method()
			{
				System.out.println("method run");
			}
		};
	}
}

class  InnerClassTest
{
	public static void main(String[] args) 
	{
		//Test.function():Test类中有一个静态的方法function。
		//.method():function这个方法运算后的结果是一个对象，而且是一个Inter类型的对象。
		//因为只有是Inter类型的对象，才可以调用method方法。
		Test.function().method();
		//method方法非静态，抽象-->function方法运算后是一个对象
		//只有返回对象，对象才能调用method方法-->Inter对象（）返回值类型
		//Inter不能new对象，只有子类对象可以
		
		//Inter in = Test.function();同上面那一句
		//in.method();
		
		show(new Inter()
		{
			public void method()
			{
				System.out.println("method show run");
			}
		});
		//{}子类包含代码范围 ()参数结束符号 ;这条语句结束
	}
//当使用的方法是一个接口类型时，接口中的方法不超过3个
//可以定义匿名内部类，把匿名内部类作为参数传进去
	public static vid show(Inter in)
	{
		in.method();
	}
}


//没有父类，没有接口，怎么写匿名内部类，建立一个方法让它运行
class InnerTest
{
	/*
	static class Inner//主函数静态
	{
		void function()
		{}
	}
	*/
	public static void main(String[] args)
	{
		//new Inner().function();
		new Object()//;-->建立Object对象
		//Object o = new Object()
		//这样不可以，父类Object引用里没有function方法，只能有直接子类对象的调用
		// {} -->建立Object子类对象，只有子类对象才能调用方法
		{
			public void function()
			{

			}
		}.function();
	}
}

异常
1.异常的体系
Throwable
Error 通常出现重大问题如：运行的类不存在或者内存溢出等。不编写针对代码对其处理。
Exception 在运行时运行出现的异常情况，可以通过try catch finally
Exception和Error的子类名都是以父类名作为后缀。

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

对于问题的划分：两种：一种是严重的划分，一种是非严重的问题。
对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。
对于非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。

无论Error或者Exception都具有一些共性内容。比如：不正常的情况信息，引发原因等。
Throwable(查看帮助文档 API)
|–Error
|–Exception
2.异常的处理 try catch
java提供了特有的语句进行处理。
try
{
需要被检测的代码；
}
catch(异常类 变量)
{
处理异常的代码：（处理方式）
}
finally
{
一定会执行的语句；
}

3.对捕获到的异常对象进行常见方法操作。
String getMessage()： 获取异常信息。
toString() ： 异常名称：异常信息
printStackTrace()： 异常名称：异常信息,异常出现的位置

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

class  ExceptionDemo
{
	public static void main(String[] args)  //throws Exception
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(4,0);
			System.out.println("x = " + x);
		}
		catch (Exception e)//Exception e = new ArithmeticExcepion();
		{
			System.out.println("除0啦");
			System.out.println(e.getMessage());//  /by zero
			System.out.println(e.toString());// 异常名称：异常信息
			e.printStackTrace();//异常名称：异常信息,异常出现的位置
		//其实jvm默认的异常处理机制么就是在调用printStackTrace方法。打印异常在堆栈中的跟踪信息。
		}
		
		System.out.println("over");
	}
}

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

多异常处理
1.声明异常时，建议声明更为具体的异常，这样处理的可以更为具体。
2.对方声明几个异常，就对应有几个catch块，不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
建议在进行catch处理时，catch一定要定义具体处理方式。不要简单定义一句e.printStackTrace()，也不要简单的就书写一条输出语句。

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  ExceptionDemo
{
	public static void main(String[] args) //throws Exception
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(4,0);
			System.out.println("x = " + x);
		}
		catch (ArithmeticException e)
		{
			System.out.println(e.toString());
			System.out.println("被0除啦");
		}
		catch (ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
			System.out.println("脚标越界啦");		
		}
		System.out.println("over");
	}
}

自定义异常
因为项目中会出现特有的问题，而这些问题并未被java所描述的对问题封装的思想，将特有的问题进行自定义的异常封装。
自定义异常
需求：在本程序中，对于除数是负数，也视为是错误的，是无法进行运算的。那么就需要对这个问题进行自定义的描述。
当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。
一般情况在函数内出现异常，函数上需要声明。
发现打印的结果中只有异常的名称，却没有异常的信息。因为自定义的异常并没定义信息。

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

自定义异常：必须是自定义类继承Exception。
继承Exception原因：异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性，这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
throw和throws区别
throw使用在函数内。后面跟的是异常对象。
throws使用在函数上（小括号和大括号之间）。后面跟的异常类，可以跟多个，用逗号隔开。

class FuShuException extends Exception//getMessage();
{
	//private String msg;
	//FuShuException(String msg)
	//{
	//	super();
	//}可以建立一个空参数,有一个隐身的super
	private int value;
	FuShuException(String msg,int value)
	{
		//this.msg = msg;
		super(msg);
		this.value = value;
	}
	public int getValue()
	{
		return value;
	}
	/*不需要覆盖以及定义了
	public String getMessage()
	{
		return msg;
	}
	*/
}

/*
class Person extends Throwable或Exception或Error
{
}
如果下面，Person和throwavle没关系，必须要继承
int div(int a,int b) throws Person
*/
class Demo
{
	int div(int a,int b) throws FuShuException
	{
		//自定义的对象java不认识，所以需要手动建立对象并传输进去
		if(b<0)
			throw new FuShuException("出现了除数是负数的情况---/by fushu",b);
		//手动通过throw关键字抛出一个自定义异常对象
		return a/b;
	}
}

class  ExceptionDemo
{
	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");
	}
}

/*
class Throwable
{
	private String message;
	Throwable(String message)
	{
		this.message = message;
	}
	public String getMessage()
	{
		return message;
	}
}
class Exception extends Throwable
{
	Exception(String message)
	{
		super(message);
	}
}
new Exception("haha").getMessage();


///
class Person
{
	String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}
class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}
new Student("lisi").getName();
*/

RuntimeException
Exception中有一个特殊的子类异常RuntimeException运行时异常。如果在函数内容抛出该异常，函数可以不用声明，编译一样通过。如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。
之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
自定义异常时，如果该异常的发生无法在继承继续进行运算，就让自定义异常继承RuntimeException。
对于异常分两种：
1.编译时被检测的异常。
2.编译时不被检测的异常（运行时异常。RuntimeException以及其子类）

class FuShuException extends RuntimeException
{
	FuShuException(String msg)
	{
		super(msg);
	}
}
class Demo
{
	int div(int a,int b)//throws ArithmeticException
	//int div(int a,int b) throws Exception
	//下面为Exception，必须标识，否则编译失败，编译时被检测异常
	//这个异常是可处理的，让调用者标识处理,
	//如果标识了，调用者必须有对应的处理方式，要么抛出异常，要么try
	{
	// e instanceof RuntimeException 运行时异常
		if (b < 0)
			throw new FuShuException("出现了除数为负数了");
			//throw new Exception("出现了除数为负数了");如果这里是Exception
		if(b == 0)
			throw new ArithmeticException("被0除了");
		return a/b;
	}
}

class ExceptionDemo5
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		int x = d.div(4,-9);
		System.out.println("x = " + x);
		
		System.out.println("over");
	}
}
/*
class Person
{
	public void checkName(String name)
	{
		//if(name.equals("lisi"))//NullPointerException
		if("lisi".equals(name))//if(name != null && name.equals(""lisi))
			System.our.println("YES");
		else
			System.our.println("NO");
	}
}
main()
{
	Person p = new Person();
	p.checkName(null);
}

*/

异常练习

/*
毕老师用电脑上课
开始思考上课中出现的问题，比如问题 电脑蓝屏、电脑冒烟
要对问题进行描述，封装成对象。
可是当冒烟发生后，出现讲课进度无法继续，出现了讲师的问题，课时计划无法完成。
*/
class LaPingException extends Exception
{
	LaPingException(String message)
	{
		super(message);
	}
}

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

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

class Computer
{
	private int state = 3;//1为正常状态
	public void run() throws LaPingException,MaoYanException
	{
		if (state == 2)
			throw new LaPingException("蓝屏了");
		if (state == 3)
			throw new MaoYanException("冒烟了");
		
		System.out.println("电脑运行");

	}
	public void reset()
	{
		state = 1;
		System.out.println("电脑重启");
		//run();
	}

}

class Teacher
{
	private String name;
	private Computer cmpt;
	Teacher(String name)
	{
		this.name = name;
		
		cmpt = new Computer();
	}
	public void prelect() throws NoPlanException //prelect 演讲
	{
		try
		{
			cmpt.run();
		}
		catch (LaPingException e)
		{
			cmpt.reset();
		}
		catch (MaoYanException e)
		{
			test();
			throw new NoPlanException("可是无法继续" + e.getMessage());
			//throw单独存在时下面不要再写语句，函数结束标志，下一句执行不到
		}
		System.out.println("讲课");
	}
	public void test()
	{
		System.out.println("做练习");
	}
}
class  ExceptionTest
{
	public static void main(String[] args) 
	{
		Teacher t = new Teacher("毕老师");
		try
		{
			t.prelect();
		}
		catch (NoPlanException e)
		{
			System.out.println(e.toString());
			System.out.println("换老师或者放假");
		}
		
	}
}

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
		{
			int x = d.div(4,-1);
			System.out.println("x = " + x);
		}
		catch (FuShuException e)
		{
			System.out.println(e.toString());
			return;//-->over不执行
		}
		finally
		{
			System.out.println("fianlly");//finally中存放的是一定会被执行的代码
		}
		System.out.println("over");
	}
}



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

	try
	{
		连接数据库；
		数据操作；//throw new SQLException();
	}
	catch (SQLException e)
	{
		会对数据库进行异常处理；
		throw new NoException();
	}
	finally
	{
		关闭数据库；
	}
}

处理语句其他格式
catch是用于处理异常，如果没有catch就代表异常没有被处理过，如果该异常时检测时异常，那么必须声明。

格式1：
try
{
	
}
catch ()
{
}
格式2：
try
{
	
}
catch ()
{
}
finally
{
}
格式3：
try
{
	
}
finally
{
}
格式4：
try
{
	
}
catch ()//多个catch
{
}

class Demo
{
	public void method()
	{
		try
		{
			throw new Exception();
			//只要问题被解决，问题可以不声明；
			//问题没有解决，问题必须声明
			//有catch 就是解决了问题
		}
		finally
		{
			//关资源
		}
//如果在一个功能当中定义了一些必须要执行的代码，
//使用try finally的形式把一定会执行的代码存放在finally中。		
		/*catch (Excptiion e)
		{
			try
			{
				throw e;
			}
			catch ()
			{
			}
			
		}
		*/
	}
}
class  
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

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

class AException extends Exception
{
}

class BException extends AException
{
}
class CException extends Exception
{
}
/*
Exception
	|--AException
		|--BException
	|--CException
*/
class Fu
{
	void show() throws AException
	{

	}
}

class Test
{
	void function(Fu f)
	{
		try
		{
			f.show();
		}
		catch (AException e)
		{
		}
		
	}
}

class Zi extends Fu
{
	void show() throws BException//或AException，不能抛CException
	{
	//如果子类中真的会发生C异常，必须在内部处理 try，不能抛出.
	}
}

class  
{
	public static void main(String[] args) 
	{
		Test t = new Test();
		t.function(new Zi());
	}
}

异常练习
有一个圆形和长方形，都可以获取面积。对于面积如果出现非法的数值，视为获取面积出现问题，问题通过异常来表示。
现在对这个程序进行基本设计：

class NoValueException extends RuntimeException
{
	NoValueException(String message)
	{
		super(message);
	}
}

interface Shape
{
	void getArea();
} 

class Rec implements Shape
{
	private int len,wid;
	Rec(int len,int wid)//throws NoValueException，覆盖方法
	//使用RuntimeException停掉程序，不需要标识，主函数也不需要处理，不知道问题会发生
	{
		if (len <= 0 || wid <= 0) 
			//System.out.println("错了")；
			throw new NoValueException("出现非法值");
		//else
		//{
		this.len = len;
		this.wid = wid;
		//}
		
	}
	public void getArea()
	{
		System.out.println(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(PI * radius * radius);
	}
}

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

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

异常体系：
Throwable
|–Error
|–Exception
|–RunTimeException

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

throw和throws的用法：throw定义在函数内，用于抛出异常对象。throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。
当函数内有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。
注意，RunTimeException除外，也就是说，函数内如果抛出的RunTimeException异常，函数上可以不声明。
如果函数声明了异常，调用者需要进行处理。处理方式可以throw可以try。

异常有两种：1.编译时被检测异常：该异常在编译时，如果没有处理（没有抛也没有try），编译失败。
2.运行时异常（编译时不检测）;在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。

异常处理语句：
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或者throws。
2.调用到抛出异常的功能时，抛出几个就处理几个。一个try对应多个catch。
3.多个catch，父类的catch放到最下面。
4.catch内，需要定义针对性的处理方式，不要简单的定义pringtStackTrace，输出语句。也不要不写。
当捕获到的异常，本个ing能处理不了时，可以继续在catch中抛出。
try
{
throw new AException();
}
catch(AException e)
{
throw e;
}
如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，在抛出和该功能相关的异常。
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道并 处理。也可以将捕获异常处理后，转换新的异常。
try
{
throw new AException();
}
catch(AException e)
{
//对AException处理。
throw new BException();
}
比如，汇款的例子。

异常的注意事项：
在子类覆盖时：1.子类抛出的异常必须是父类异常的子类或者子集。2.如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。
例子：ExceptionTest.java 老师用法电脑上课、ExceptionTest1.java 图形面积

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

包的出现可以让java的运行文件和源文件相分离，只给运行文件就可以运行。

当前目录下没有这个类，可以把目录切换到C盘，或者使用set classpath，指向包的父目录即可。

包于包之间的访问
javac -d c:\myclass DemoA.java 先编译DemoA
javac -d c:\myclass PackageDemo.java

javac -d c:\myclass PackageDemo.java 不用编译DemoA

set classpath=c:\myclass
javac -d c:\myclass PackageDemo.java

public class DemoA（类的修饰符：共有权限、外部权限）重新编译DemoA
javac -d c:\myclass DemoA.java
javac -d c:\myclass PackageDemo.java

package packa;

public class DemoA  extends packb.DemoB 
{
	public void show()
	{
		//可以继承
		System.out.println("demoa run show");
		method();
		
		//packb.DemoB d = new packb.DemoB();
		//d.method();
	}
}

-------------------------------------------------------------------

package packb;

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

class C extends DemoB
{
	//public\protected void method(){}
}
-------------------------------------------------------------------

package pack;

class PackageDemo
{
	public static void main(String[] args) 
	{
		packa.DemoA d = new packa.DemoA();
		d.show();
	}
}

总结：1.包于包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。
2.不同包中的子类还可以直接访问父类中被protected权限修饰的成员。
包于包之间可以使用的权限只有两种，public、protected(只能子类使用)
用于覆盖，权限>=可以覆盖
public protected default(默认，不写) private
同一个类中 ok ok ok ok
同一个包中 ok ok ok
子类 ok ok
不同包中 ok

类名加public以后，类名和java文件名必须保持一致。不允许这样写。一个java文件里不允许出现两个以上共有类或接口。

多层包目录 包中有包 子包

导入import
为了简化类名的书写，使用一个关键字：import。
mport packb.haha.hehe.heihei.*;//把当前目录下的类全部都倒进到所需要的目录中来。
下面建立新对象：
DemoC c = new DemoC();
1.import 倒入的是包中的类。
建议不要写通配符 * ，需要用到包中的哪个类，就导入哪个类。
c:\myclass\packb\DemoA.class–>可以倒入类DemoA.class
c:\myclass\packb\haha\DemoZ.class–>DemoZ.class不可以，haha是packb中的子包
import packb. *;
import packb.haha. *;倒入子包中所有的类
2.倒入包中会出现重名的包，在建立新的对象的时候，前面必须加包名。
packb.DemoC c = new DemoC();
3.建议定义包名不要重复，可以使用url（域名）来完成定义，url是唯一的。
www.itcast.cn
package cn.itcast.demo
package cn.itcast.test

jar包
方便项目的携带。
方便于使用，只要在classpath设置jar路径即可。
数据库驱动，SSH框架等都是以jar包体现的。

切换到指定打包目录
–> jar -cf haha.jar packa pack
创建指定打包的名字 后面是要打包的两个包
–>jar -tf haha.jar
列出指定打包档案目录
set classpath= c:myclass\haha.jar–>把路径指向jar包还可以运行

–>jar -tf a.jar >c:\1.txt -->存到指定txt文件中