一、内部类
概念：
内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。
内部类可以是静态static的，也可用public，default，protected和private修饰。
而外部顶级类即类名和文件名相同的只能使用public和default。
注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。所以内部类的成员变量/方法名可以和外部类的相同。
内部类的访问规则：
1，内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式外部类名.this
2，外部类要访问内部类，必须建立内部类对象。
访问格式：
1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象。
格式
外部类名.内部类名 变量名 =外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();
请看如下案例：
class Outer
{
private int x = 3;
class Inner//内部类
{
//int x = 4;
void function()
{
//int x = 6;
System.out.println("innner :"+Outer.this.x);//输出6，直接X；输出4，this.x；输出3，Outer.this.x
}
}
/**/
void method()
{
Inner in = new Inner();
in.function();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method();
//直接访问内部类中的成员。
// Outer.Inner in = new Outer().new Inner();
// in.function();
}
}
二、静态内部类+内部类定义规则
1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象。
访问格式：
外部类名.内部类名 变量名 =外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();
2,当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中，如何直接访问static内部类的非静态成员呢？
new Outer.Inner().function();
在外部其他类中，如何直接访问static内部类的静态成员呢？
uter.Inner.function();
注意：当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。
当描述事物（类）时，事物的内部还有事物，该事物用内部类来描述。
因为内部事务在使用外部事物的内容。
如：
class Body
{
private class XinZang
{
}
public void show()
{
new XinZang().
}
}
*/
class Outer
{
private static int x = 3;
static class Inner//静态内部类
{
static void function()
{
System.out.println("innner :"+x);
}
}
static class Inner2
{
void show()
{
System.out.println("inner2 show");
}
}
public static void method()
{
//Inner.function();
new Inner2().show();
}
}
class InnerClassDemo2
{
public static void main(String[] args)
{
Outer.method();
//Outer.Inner.function();
//new Outer.Inner().function();
//直接访问内部类中的成员。
// Outer.Inner in = new Outer().new Inner();
// in.function();
}
}
插曲：
/*
内部类定义在局部时，
内部类定义在外部类中的某个方法中，创建了这个类型的对象时，且仅使用了一次，那么可在这个方法中定义局部类。
特点：
1，不可以被成员修饰符修饰(Static,private)
2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
*/
class Outer
{
int x = 3;
void method(final int a)
{
final int y = 4;
class Inner
{
void function()
{
System.out.println(y);
}
}
new Inner().function();
}
}
class InnerClassDemo3
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method(7);//运行局部成员函数，运行完出栈
out.method(8);
}
三、 匿名内部类
1，匿名内部类其实就是内部类的简写格式。没有内部类名，直接用父类的名称定义。
2，定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式： new父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。因为多方法的话阅读性差。匿名内部类调用方法比较方便
应用：
当使用的方法参数类型是接口类型，该接口方法不超过3个，可以定一个匿名内部类
请看案例：
abstract class AbsDemo
{
abstract void show();
}
class Outer
{
int x = 3;
/*
class Inner extends AbsDemo
{
int num = 90;
void show()
{
System.out.println("show :"+num);
}
void abc()
{
System.out.println("hehe");
}
}
*/
public void function()
{
//AbsDemo a = new Inner();
// Inner in = new Inner();
// in.show();
// in.abc();
AbsDemo d = new AbsDemo()
{
int num = 9;
void show()
{
System.out.println("num==="+num);
}
void abc()
{
System.out.println("haha");
}
};
d.show();
//d.abc();//编译失败;
}
}
class InnerClassDemo4
{
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 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();//通过此简化写法补充匿名内部类实现代码
// Inter in = Test.function();
// in.method();
show(new Inter()
{
public void method()
{
System.out.println("method show run");
}
});
}
public static void show(Inter in)//参数类型是接口类型时可用匿名内部类，用以上红色部分实现
{
in.method();
}
}
//不用接口，父类能用匿名内部类吗？能，任何类都是object的子类
class InnerTest
{
public static void main(String[] args)
{
//new object();创建object类
//创建object的子类对象，调用子类的方法；
new Object()//不要创建父类的引用object 0=new object();再调用函数。因为Object没有此函数
{
public void function()
{
}
}.function();
}
}
四、异常概述+try-catch
概述：
异常是Java中的重要机制，也使用了面向对象的思想，进行了封装。而异常类中所描述的就是程序中可能出现的错误或者问题。如：文件找不到、网络连接失败、非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。Java通过API中Throwable类的众多子类描述各种不同的异常。因而，Java异常都是对象，是Throwable子类的实例，描述了出现在一段编码中的错误条件。当条件生成时，错误将引发异常。
1,使用函数的对象不知道该函数是否会发生问题，及未声明异常
异常：就是程序在运行时出现不正常情况。
异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。
其实就是java对不正常情况进行描述后的对象体现。
对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
对于严重的，java通过Error类进行描述。
对于Error一般不编写针对性的代码对其进行处理。
对与非严重的，java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。
无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等。
Throwable
|--Error
|--Exception
2,异常的处理
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)
{
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 Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。
{
return a/b;
}
}
class ExceptionDemo1
{
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)
{
System.out.println(e.toString());
}
System.out.println("over");
}
}
六、多异常处理
对多异常的处理。
1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
2，对方声明几个异常，就对应有几个catch块。不要定义多余的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 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("hahah:"+e.toString());
}
catch (ArithmeticException e)
{
System.out.println(e.toString());
System.out.println("被零除了!!");
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println(e.toString());
System.out.println("角标越界啦！！");
}
/*如果出现了其他异常，不要用Exception e处理，相当于将错误隐藏了
不处理，程序停止，让开发者知道哪里出问题；
*/
System.out.println("over");
}
}
七、自定义异常
因为项目中会出现特有的问题，
而这些问题并未被java所描述并封装对象。
所以对于这些特有的问题可以按照java的对问题封装的思想。
将特有的问题。进行自定义的异常封装。
自定义异常。
需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的。
那么就需要对这个问题进行自定义的描述。
当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
要么在内部try catch处理。
要么在函数上声明让调用者处理。
一般情况在函数内出现异常，函数上需要声明。
发现打印的结果中只有异常的名称，却没有异常的信息。
因为自定义的异常并未定义信息。
如何定义异常信息呢？
因为父类中已经把异常信息的操作都完成了。
所以子类只要在构造时，将异常信息传递给父类通过super语句。
那么就可以直接通过getMessage方法获取自定义的异常信息。
自定义异常：
必须是自定义类继承Exception。
继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
throws和throw的区别：
throws使用在函数上。
throw使用在函数内。
throws后面跟的异常类。可以跟多个。用逗号隔开。
throw后跟的是异常对象。
如：
class FuShuException extends Exception //getMessage();
{
private int value;
FuShuException()
{
super();
}
FuShuException(String msg,int value)
{
super(msg);//重写父类的构造函数，SUPER指向父类的初始化操作
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");
}
}
/*
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);
}
}
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 Sttdent("lisi").getName();
*/
八、RuntimeException
Exceptoin中有一个特殊的子类异常RuntimeException运行时异常。
如果在函数内容抛出该异常类以及子类，函数上可以不用声明，编译一样通过。
如果在函数上声明了该异常。调用者可以不用进行处理（抛出或try）。编译一样通过；
之所以不用在函数声明，是因为不需要让调用者处理。(未声明异常，不用进行处理)
当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
自定义异常时：如果该异常的发生，无法在继续进行运算，
就让自定义异常继承RuntimeException。
对于异常分两种：
1，编译时被检测的异常。
2，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)
请看如下程序：
class FuShuException extends RuntimeException
{
FuShuException(String msg)
{
super(msg);
}
}
class Demo
{
int div(int a,int b)throws Exception//throws ArithmeticException
{
if(b<0)
throw new Exception("出现了除数为负数了");
if(b==0)
throw new ArithmeticException("被零除啦");
return a/b;
}
}
class ExceptionDemo4
{
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.out.println("YES");
else
System.out.println("no");
}
}
main()
{
Person p = new Person();
p.checkName(null);
}
*/
九、异常-finall
finally代码块：定义一定执行的代码。
通常用于关闭资源。(关闭数据库连接，windows资源等)
如:
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 ExceptionDemo5
{
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;
//System.exit(0);//退出系统。jvm结束。在不退出JVM情况下，finally一定会被执行
}
finally
{
System.out.println("finally");//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
{
关闭数据库;
}
}
十、 throw与throws的区别
区别一： throw 是语句抛出一个异常；throws 是方法抛出一个异常；
throw语法：throw <异常对象>
在方法声明中，添加throws子句表示该方法将抛出异常。throws语法：[<修饰符>]<返回值类型><方法名>（[<参数列表>]）[throws<异常类>]其中：异常类可以声明多个，用逗号分割。
区别二： throws可以单独使用，但throw不能；
区别三： throw要么和try-catch-finally语句配套使用，要么与throws配套使用。但throws可以单独使用，然后再由处理异常的方法捕获。
throws E1,E2,E3 只是告诉程序这个方法可能会抛出这些个异常，方法的调用者可能要处理这些异常。而这些异常E1，E2，E3可能是该函数体产生的。而throw是明确之处这个地方要抛出这个异常。
void doA() throws Exception1, Exception3 {
try {
……
} catch(Exception1 e) {
throw e;
} catch(Exception2 e) {
System.out.println("出错了");
}
if (a != b)
throw new Exception3("自定义异常");
}
代码块……中可能产生异常Exception1、Exception2和Exception3。 如果产生Exception1异常，则捕捉了之后抛出由该方法的调用者去做处理； 如果产生Exception2异常，则该方法自己做了处理(打印出了说出错了)，所以该方法就不会再向外抛出Exception2异常了，void doA() throws Exception1,,Excpetion3里面的 Exception2也就不用写了； 而Exception3异常是该方法的某段逻辑出错，程序员自己作了处理在该段逻辑错误的情况下抛出异常Exception3，则调用者也需要处理。
throw语句用在方法体内,表示抛出异常,由方法体内的语句处理
throws语句用在方法声明后面,表示再抛出异常,由调用这个方法的上一级方法中的语句来处理 throws主要是声明这个方法会抛出这种类型的异常，使其他地方调用它时知道要捕获这个异常。
throw是具体向外抛异常的动作，所以它是抛出一个异常实例。
throws说明你有哪个可能，倾向 throw的话，那就是你把那个倾向变成真实的了
同时：
1）throws出现在方法函数头；而throw出现在函数体；
2）throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常；
3）两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。
练习：以下语句描述的是有关 Throw与 Throws语句的区别，请选出正确的语句。 ABC
A）Throw是用来抛出一个异常，而 Throws 是抛出多个异常。
B）throw总是出现在函数体中，程序会在 throw语句后立即终止，而 throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常
C）throw是语句抛出一个异常；throws是方法抛出一个异常
D）throws可以单独使用，但 throw不能。
E）以上都是正确的
十一、异常-处理语句其他格式
第一个格式：
try
{
}
catch ()
{
}
第二个格式：
try
{
}
catch ()
{
}
finally
{
}
第三个格式：
try
{
}
finally
{
}
//记住一点：catch是用于处理异常。如果没有catch就代表异常没有被处理过，如果该异常是检测时异常。那么必须在方法上声明。
如：
class Demo
{
public void method()
{
try
{
throw new Exception();//抛出异常，需要捕获或者进行声明；
}
finally
{
//关资源。
}
}
}
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 CException
{
}
}
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
{
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
{
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(radius*radius*PI);
}
}
class ExceptionTest1
{
public static void main(String[] args)
{
Rec r = new Rec(3,4);
r.getArea();
Circle c = new Circle(-8);
System.out.println("over");
}
}
十四、异常-总结
异常：是什么？
是对问题的描述。将问题进行对象的封装。
异常体系：
Throwable
|--Error
|--Exception
|--RuntimeException
异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。
也就是说可以被throw和throws关键字所操作。
只有异常体系具备这个特点。
--------------
throw和throws的用法：
throw定义在函数内，用于抛出异常对象。
throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。
在函数体中，当函数内容有throw抛出异常对象，并未进行catch处理。必须要在函数上声明，都在编译失败。
注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。
--------------
如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。
异常有两种：
编译时被检测异常
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
该异常被标识，代表这可以被处理。
运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。
该异常的发生，建议不处理，让程序停止。需要对代码进行修正。
--------------
异常处理语句：
try
{
需要被检测的代码；
}
catch ()
{
处理异常的代码；
}
finally
{
一定会执行的代码；
}
有三个结合格式：
1. try
{
}
catch ()
{
}
2. try
{
}
finally
{
}
3. try
{
}
catch ()
{
}
finally
{
}
注意：
1，finally中定义的通常是 关闭资源代码。因为资源必须释放。
2，finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。
3 , 在return前，会先执行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内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。
也不要不写。
当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}
如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，在抛出和该功能相关的异常。
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，
让调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。
try
{
throw new AException();
}
catch (AException e)
{
// 对AException处理。
throw new BException();
}
比如，汇款的例子。
异常的注意事项：
在子父类覆盖时：
1，子类抛出的异常必须是父类的异常的子类或者子集。
2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。
十五、包-package基本应用
对类文件进行分类管理（可以将源文件与类文件分离）
给类提供多层命名空间
写在程序文件的第一行类名的全称是包名.类名
包也是一种封装形式
========================================================
在dos命令行加入参数
javac -d(指定根文件) . (点表示当前目录)包名.Demo.java：生成包文件夹
完整写法：javac –d . Demo.java
将类文件存到另一盘的文件夹中：生成包文件夹后，设置类路径（set classpath=c:\myclass）不能加上包文件名，指向包的父目录即可；
十六、 包与包之间的访问+导入import
package pack;
为了简化类名的书写，使用一个关键字，import.
import 导入的是包中的类。
建议，不要写通配符 * ，需要用到包中的哪个类，就导入哪个类。
==========================================
c:\myclass
c:\myclass\packb\DemoA.class
c:\myclass\packb\haha\DemoZ.class
import packb.*;在DemoA中不能访问DemoZ
import packb.haha.*;;在DemoA中可以能访问DemoZ
==========================================
*：表示文件夹中的所有.class文件，一般不用*号；
不同包中有相同的类名时：packa.DemoA d = new packa.DemoA();指定包名
=========================================
建议定包名不要重复，可以使用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 (A包的PROTECTED类能够被B包中A包的子类访问)
不同包中 ok(A包的类能够被B包的类访问)
=============================================
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
826
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
