abstract class Damo
{abstract void show();  //抽象的函数
}class DemoA extends Dame
{void show()          //如果子类继承抽象类狗没有覆写抽象方法，该子类仍然为抽象类
    {System.out.println("Hello DemoA");        }
}class DemoB extends Demo
{void show(){System.out.println("Hello DemoB");}
}

abstract class Employee     //定义雇员
{    private String name;    //定义成员变量private String id;private int payment;Employee(String name,String id,int payment)//定义成员构造函数
    {this.name = name ;this.id = id ;this.payment = payment ;}public abstract void work(); //定义抽象方法
}//描述程序员
class Programmer extends Employee    //令程序员继承雇员
{Programmer(String name,String id,int payment)    //定义程序员的构造方法
    {super(name,id,payment);}void work()                             //此行覆盖父类中的抽象方法
    {System.out.println("code...");        //定义程序员的特有方法
    }
}
//描述项目经理
class Manager extends Employee        //令项目经理继承雇员
{private int bonus;                //定义成员变量Manager(String name,String id,int payment,int bonus)    //定义项目经理的构造函数
    {super(name,id,payment);        //继承父类构造函数this.bonus = bonus ;}void work()                        //覆盖父类抽象方法
    {System.out.println("manage...");    //定义项目经理特有方法
    }
}

interface InterfaceDemo
{public static final int num = 4 ;abstract void show1();abstract void show2();
}

class  DemoA implements InterfacceDemo  // implements A,B就是多实现
{void show1(){//具体的实际的方法略
    }void show2(){//具体的实际的方法略
    }
}

interface USB                                  //暴露接口规则
{public void open();public void close();public void work();
}class Upan implements USB                     //定义一个符合usb规则的upan
{public void open(){System.out.println("upan open");     //定义具体的实现方法
    }public void close(){System.out.println("upan close");}public void work(){System.out.println("upan work");}
}class Laptop
{public static void main(String[] args){useUSB(new Upan());                 //创建一个upan，并通过定义的使用方法使用
    }public static void useUSB(USB u)        //定义一个使用usb的方法
    {u.open();u.close();u.work();}
}

interface Demo
{void show();
}
class Outsider
{private int num = 3 ;void method()//如无此行，内部类直接写在外部类中时，可用 Outsider.Intersider in2 = new Outsider().new Intersider(); //直接访问内部类中的内容，记格式。
    {final int a = 4 ;   //在内部类中访问局部变量时，必须在变量前加finalclass Intersider{int num = 5 ;void show(){System.out.println("num="+num);System.out.println("num="+Outsider.this.num);  //此时输出的是外部的num = 3. 仅内部类与外部类出现重名变量的时候才这样使用。System.out.println("a="+a);              //要访问a这局部变量，必须在变量前加 final
            }}Intersider in1 = new Intersider();in1.show();System.out.println();}
//以下为演示匿名内部类public void method0(){new Demo()  //此时Demo是抽象类，不能直接创建对象，但此时已经在其中具体了其抽象方法的具体实现，所以这步实际上是创建了一个Demo的子类的对象{                        //这种方法是创建了一个子类，所以可以在其中添加子类特有的方法，例如 show2()public void show()  //public 必须加上(重要)
            {System.out.println("匿名内部类01");}}.show();                      //.show()很重要，和普通一样，表示使用。
Demo in = new Demo()           //这种方法创建的子类，自动向上转型成为了Demo类，所以不可以添加子类特有的方法，仅可以复写Demo中已有的方法。
        {public void show()         //public 必须加上(重要)
            {System.out.println("匿名内部类02");}};                            // ; 很重要
        in.show();}
}class Neibulei
{public static void main(String[] args) {Outsider Out = new Outsider();Out.method();new Outsider().method();                   //此方法为用匿名类new Outsider().method0();}
}

try
{//需要被检测异常的代码
}
catch(异常类 变量)//该变量用于接收发生的异常对象
{//处理异常的代码。
}
finally    //通常用于关闭(释放)资源
{//一定会被执行的代码。
}

class Fushuindex extends RuntimeException    //继承的Exception时，需要throws Fushuindex (添加捕捉自定义声明)
{Fushuindex(String a){super(a);                       //直接调用父类的方法
    }
}
class Demo
{public int method(int [] arr , int index) //继承的Exception时，需要throws Fushuindex (添加捕捉自定义声明)
    {if(arr==null)throw new NullPointerException("数组的角标不能为空");if(index >=arr.length)              //判断问题throw new ArrayIndexOutOfBoundsException("数组角标越界了: "+index);   //自定义异常返回信息else if(index < 0)throw new Fushuindex("数组角标不能小于0: ");elsereturn arr[index];}
}
class  ExceptionDemo
{public static void main(String[] args)  //继承的Exception时，需要throws Fushuindex (添加捕捉自定义声明)
    {int [] a = new int [3];Demo d = new Demo();int num1 = d.method(a,1);System.out.println("Hello World!"+num1);
//以下演示异常捕捉
//多catch 时，父类catch必须放在最下面try{int num2 = d.method(a,-30);System.out.println("num2 = "+num2);}catch (Fushuindex x){System.out.println("负数角标异常");System.out.println(x.toString());  //异常信息
        }catch (Exception e){}System.out.println("over");}
}