1，finally：通常用于关闭资源
class AException extends Exception
{}
class CException extends Exception
{}
class Fu
{
void show()throws AException
{
}
}
class Zi extends Fu
{
void show()throws CException
{}
}
class Test
{
void function(Fu f)
{
try
{
f.show();
}
catch (AException e)
{
}
}
}
class ExceptionDemo2
{
public static void main(String[] args)
{
Test t = new Test();
t.function(new Zi());//Fu f = new Zi();调用的是子类的show方法，抛出C异常，编译失败。
System.out.println("Hello World!");
}
}
eg2:
class FushuException extends RuntimeException
{
FushuException(String msg)
{
super(msg);
}
}
interface Share
{
void getArea();
}
class Rec implements Share
{
private int Chang,Kuan;
Rec(int Chang,int Kuan)//throws FushuException
{
if(Chang<0||Kuan<0)
throw new FushuException("边长不能小于等于0");
this.Chang=Chang;
this.Kuan=Kuan;
}
public void getArea()
{
System.out.println(Chang*Kuan);
}
}
class Circle implements Share
{
private int Zhi;
public static final double PI=3.24;
Circle(int Zhi)
{
if(Zhi<=0)
throw new FushuException("圆的直径不能小于等于0");
this.Zhi=Zhi;
}
public void getArea()
{
System.out.println(Zhi*Zhi*PI);
}
}
class ExceptionDemo3
{
public static void main(String[] args)
{
// try
// {
// Rec r = new Rec(-9,9);
// r.getArea();
// }
// catch (FushuException e)
// {
// System.out.println(e.toString());
// }
Rec r = new Rec(-9,9);//小于0时必须让程序停止，提示哪里出了问题，然后对代码进行修正，这时候应该抛出RuntimeException或者其子类
r.getArea();
Circle c = new Circle(-7);
c.getArea();
System.out.println("Hello World!");
}
}
class TestDemo1
{
public static void func()throws Exception
{
try
{
//throw new Exception();//没抛出，结果为：B A D
}
//catch(Exception e){}//抛出了，这里处理了，结果为：B A D,抛出，这里没有处理，结果为：B C D
finally//有一种情况不会执行：System.exit(0);退出jvm，之后所有的代码都不再执行
{
System.out.println("B");
}
}
public static void main(String[] args)
{
try//只看句中的代码
{
func();
System.out.println("A");
}
catch(Exception e)
{
System.out.println("C");
}
System.out.println("D");
}
}
eg4:
class Test
{
int a;
Test(){};//子类中每个构造函数第一行都会有一个隐式的语句super();就是代表这个语句。
Test(int a)
{
System.out.println("Test");
}
}
class TestDemo2 extends Test
{
TestDemo2()
{
//super(4);//这里必须手动调用构造函数，否则编译失败，因为系统找不到默认的Test()这个空参数的构造函数。
//这里省略了：super();
System.out.println("Demo");
}
public static void main(String[] args)
{
new TestDemo2();
new Test(3);
}
}
interface A{//String func();}
class B implements A
{
public String func()
{
return "func";
}
}
class Demo
{
public static void main(String[] args)
{
A a=new B();
System.out.println(a.func());//编译失败，接口A中没有定义func方法，多态引用：成员变量只看引用所属的对象，成员函数看引用中是否有该函数，静态只看引用
}
}
class Demo
{
int show(int a,int b){return 0;}
}
下面那些函数可以存在于Demo的子类中。
A.public int show(int a,int b){return 0;}//可以，覆盖。
B.private int show(int a,int b){return 0;}//不可以，权限不够。
C.private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。
D.public short show(int a,int b){return 0;}//不可以，因为该函数不可以和给定函数出现在同一类中，或者子父类中。
E.static int show(int a,int b){return 0;}//不可以，静态只能覆盖静态。小结：一般方法可以覆盖：条件是函数的返回值类型，函数名称，参数列表必须都相同；子类权限必须大于等于父类函数的。子类中的构造函数不可以覆盖父类中的构造函数，因为名称相同。
class Demo
{
public static void func()
{
try
{
throw new Exception();//throw单独存在，下面不要定义语句，因为执行不到。
System.out.println("A");
}
catch(Exception e)
{
System.out.println("B");
}
}
public static void main(String[] args)
{
try
{
func();
}
catch(Exception e)
{
System.out.println("C");
}
System.out.println("D");
}
}
//编译失败。 因为打印“A”的输出语句执行不到。
记住：throw单独存在，下面不要定义语句，因为执行不到。
符号： 类 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 错误
错误原因：类公有后，被访问的成员也要公有才可以被访问。
6，包与包之间访问：
范围\修饰符号 public protected default private 同一个类中 ok ok ok ok 同一个包中 ok ok ok 1子类(同包/不同包) ok ok 2不同包中 ok