黑马程序员——java学习5（107-126）——内部类,异常,包

 1 package learn;
 2 class Outer{
 3 private int x=3;
 4 class Inner{//内部类
 5 int x=4;
 6 void function(){
 7 int x=5;
 8 System.out.println("inner"+x);
 9 System.out.println("inner"+this.x);
10 System.out.println("inner"+Outer.this.x);
11 }
12 }
13 void method(){
14 Inner in=new Inner();
15 in.function();
16 }
17 }
18 public class InnerClassDemo {
19 public static void main(String[] args) {
20 Outer out=new Outer();
21 out.method();
22 //内部类非私有时可如下访问
23 Outer.Inner Inn=new Outer().new Inner();
24 Inn.function();
25 }
26 }

package learn;

class Outer{
    int x=3;
    void method(){
        class Inner{
            void function(){
                //内部类调用外部类的成员变量
                System.out.println(Outer.this.x);
            }
        }
        //非静态类，没对象不运行
        new Inner().function();
    }
}
public class InnerClassDemo3 {
    public static void main(String[] args) {
        new Outer().method();
    }
}

 1 package learn;
 2 
 3 class Outer3{
 4     int x=3;
 5     void method(){
 6         final int y=4;
 7         class Inner{
 8             void function(){
 9                 //内部类访问它所在的局部中的变量，必须为final
10                 System.out.println(y);
11             }
12         }
13         //非静态类，没对象不运行
14         new Inner().function();
15     }
16 }
17 public class InnerClassDemo3 {
18     public static void main(String[] args) {
19         new Outer3().method();
20     }
21 }

 1 package learn;
 2 
 3 abstract class AbsDemo{
 4     abstract void show();
 5 }
 6 
 7 class Outer4{
 8     int x=3;
 9 //    class Inner4 extends AbsDemo{
10 //        void show(){
11 //            System.out.println("show"+x);
12 //        }
13 //    }
14 //    public void function(){
15 //        new Inner4().show();
16 //    }
17 //    
18     public void function2(){
19     //AbsDemo d=new AbsDemo()也可以
20     new AbsDemo(){
21         void show(){
22             System.out.println("show"+x);
23         }
24             
25     }.show();
26     
27     }
28 }
29     
30 public class InnerClassDemo4 {
31     public static void main(String[] args) {
32 //        new Outer4().function();
33         new Outer4().function2();
34     }
35 }

 1 package learn;
 2 interface Inter{
 3     void method();
 4 } 
 5 class Test{
 6     static class Inner implements Inter{
 7         public void method(){
 8             System.out.println("1");
 9         }
10     }
11     static Inter function(){
12 //        return new Inner();//内部类
13         //匿名内部类
14         return new Inter(){
15             public void method(){
16                 System.out.println("1");
17             }
18     };
19 }
20 }
21 public class InnerClassDemo5 {
22     public static void main(String[] args) {
23         //倒推
24         Test.function().method();
25         //Test类中有个静态方法function，
26         //.method:function方法运算后的结果是一个对象，而且是一个Inner类型的对象
27         //因为只有Inner类型的对象，才可以调用method方法
28     }
29     
30 }

 1 package learn;
 2 class Demo{
 3     int div(int a,int b)
 4     {
 5         return a/b;
 6     }
 7 }
 8 
 9 public class ExceptionDemo {
10 public static void main(String[] args) {
11     Demo d=new Demo();
12     try
13     {
14         int x=d.div(4, 0);   //new Exception()
15         System.out.println("x="+x);
16     }
17     catch(Exception e)//Exception e=new Exception()
18     {
19         System.out.println("除零了");
20         System.out.println(e.getMessage());//  /byzero详细消息的字符串
21         System.out.println(e.toString());//异常名称:异常信息
22         e.printStackTrace();//打印堆栈中的跟踪信息,异常名称，异常信息，异常出现的位置
23         //其实jvm默认的异常处理机制就是在调用printStackTrace方法
24     }
25 }
26 }

1 class Demo{
2     int div(int a,int b)throws Exception//在功能上通过throws关键字声明了该功能可能出现问题
3     {
4         return a/b;
5     }
6 }

 1 package learn;
 2 class FuShuException extends Exception{
 3     private int value;
 4     FuShuException(){
 5         super();
 6     }
 7     FuShuException(String msg,int value){
 8         super(msg);
 9         this.value=value;
10     }
11     public int getValue(){
12         return value;
13     }
14 }
15 class Demo3{
16     int div(int a,int b)throws Exception{//函数上
17         if(b<0)
18             //函数内
19             throw new FuShuException("出现了除数是负数的情况，",b);//手动通过throw关键字抛出一个自定义异常
20         return a/b;
21     }
22 }
23 
24 class ExceptionDemo3{
25     public static void main(String[] args){
26         Demo3 d=new Demo3();
27         try
28         {
29             int x=d.div(4, -1);   
30             System.out.println("x="+x);
31         }
32         catch(Exception e)
33         {
34             System.out.println(e.toString());
35             System.out.println("除数变负数");
36         }
37         System.out.println("over");
38     }
39 }
40 
41 //// 1,2推出3,
42 //class Throwable{
43 //    private String message;           //3
44 //    Throwable(String message)
45 //    {
46 //        this.message=message;         //2
47 //    }
48 //    public String getMessage(){
49 //        return message;               //1
50 //    }
51 //}
52 //
53 //class Exception extends Throwable{
54 //    Exception(String message)
55 //    {
56 //        super(message);
57 //    }
58 //}