继承、final、多态、内部类、异常

class Fu{
     public String name = "Fu";
     public static String address= "Fu address";
     public void method1(){
          System.out.println("Fu method1");
     }
          public void method2(){
          System.out.println("Fu method2");
     }

     public static void method4(){
          System.out.println("static Fu method4");
     }
}
class Zi extends Fu{
     public static String address= "Zi address";
     public String name = "Zi";
     public void method1(){
          System.out.println("Zi method1");
     }
     public void method2(){
          System.out.println("Zi method2");
     }
     public void method3(){
          System.out.println("Zi method3");
     }
     public static void method4(){
          System.out.println("static Zi method4");
     }
     public void method5(){
          System.out.println(name);
     }
     public void method6(){
          System.out.println(super.name);
     }
     public void method7(){
          System.out.println(name);
     }
}

public class Test{
     public static void main(String args[]){
          /*关于非静态/和静态函数的演示*/
          //Fu z = new Zi();
          //z.method3();//编译会报错
          //z.method2();//Zi method2
          /*为什么会出现下面的这种情况？
               因为静态方法是静态绑定好的，
               无论是在什么情况在最初的时候就已经在静态方法区把静态方法和类绑在一起，所以静态方法不存在覆盖
               不管引用指向哪个对象不没有用。
               而非静态方法是在new对象的时候把非静态方法和对象绑定一起，通过对象去调用非静态方法。
          */
          //z.method4(); //static Fu method4
          //Zi z1 = new Zi();
          //z1.method4();//static Zi method4

          /*成员变量的演示*/
          Zi z2 = new Zi();
          System.out.println(z2.name);//Zi
          //（在堆内存中同时存在两个变量，
          //那么会先找定义引用的那个类的那个变量值 和 方法不同）
          Fu z4 = new Zi();
          System.out.println(z4.name);//Fu
         
          /*为什么会出现这种情况？
               在非静态成员变量中，对象的引用去取成员变量是根据左边的类去找相对应的值
               在静态成员变量中是根据静态绑定的原理一样一开始就把类和静态成员绑定在一起。
               不管自己指向哪个对象
               静态的成员或方法都是直接和类进行绑定在一起称之为静态绑定
          
               绑定回去好好看下下...........
               
               java对非静态方法的调用是采取动态绑定(编译期判断但运行时才绑定)的方法，
               对静态成员、属性的调用是采取静态绑定（编译时就绑定并且判断）的方法。
          */
          //Fu z3 = new Zi();
          //System.out.println(z3.address);//Fu address
          //Zi z4 = new Zi();
          //System.out.println(z4.address);//Zi address
     }
}

class MainBoard{
     public void start(){
          System.out.println("MainBoard start!");
     }
     public void controllerCard(PCI p){//向外暴露一个接口只要是实现了该接口的方法就可以被调用执行
          if(p != null){
               p.open();
               p.close();
          }
     }
}
class SourdCard implements PCI{
     public void open(){
          System.out.println("SourdCard open");
     }
     public void close(){
          System.out.println("SourdCard close");
     }
}
interface PCI{

     public abstract void open();
     public abstract void close();
}
public class Test2{
     public static void main(String args[]){
          MainBoard mb = new MainBoard();
          mb.start();
          mb.controllerCard(new SourdCard() );
     }
}

内部的访问规则：

          内部类可以直接访问外部类的成员，包括私有。

          外部类要想访问内部类，必须建立对象。

          之所以可以直接访问外部类的成员，因为内部类持有外部类的引用,格式：Outer.this.x

   

     访问格式：

          在内部类定义在外部类中的成员位置上，而且是非私有，可以在外部的其他类中。

          可以直接建立内部类的对象。

          格式：1. 外部类.内部类 变量名 = 外部对象.内部对象;

                  Outer.Inner in = new Outer().new Inner();

               2. 当内部类在成员位置上，就可以被成员修饰符修饰。

                    比如 private：将内部类在外部类中进行封装。

                         static: 内部类具有了static特性。 

                                 当内部类被static修饰时，只能直接访问外部类的static成员，

                                 出现了想问局限。

               3.在外部类中，如何直接访问static内部类中非静态成员？

                       new Outer.Inner().function();

               4. 在外部类中，如何直接访问static内部类中的静态成员？

                        Outer.Inner.function();

     注意：

          当在内部类中定义了静态成员，那么内部类必须是静态内部类。（内部类中不能有静态声明除非内部类也是静态的）。

          当外部类中的静态方法访问内部类中的方法时，那么内部类必须为静态的。

     什么时候使用内部类：

          当描述的事物时，事物内部还有事物，该事物就应该用内部类封装：人-人体（private）                                                                                                                                                                    

          内部类中定义在局部时，

              1. 不可被成员修饰符修饰。

              2. 可以直接访问外部类中的成员，因为他还持有外部类的引用，

                 但是是不可以访问他所在的局部变量，只能访问被final修饰过的局部变量 。

      匿名内部类：

          1. 匿名内部类其实就是内部类的简写格式。      

          2. 定义匿名内部类的前提：

                内部类必修是继承一个类或者是接口

          3. 匿名内部类的格式：

                new 父类或者接口(){定义子类的内容}

          4. 其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，也可以说是带内容的对象。

          5. 在匿名内部类中可以写其他成员，但每次只能调用一个方法，

             但可以帮他取个名字用父类的引用指向子类的对象。

       使用情况： 当使用的方法的参数类型是一个接口类型时，直接向调用方法传入一个匿名对象。

    面试题：假如我没有父类，也没有接口让我去实现，还能写匿名内部类吗？

           答案 ：能

     public class{

        new Object(){

            public void function(){}

          }

     }

---

jvm默认的异常处理机制就是调用printStackTrace方法
     对于多异常的处理。应该是定义更具体的异常来捕捉捕捉问题
     捕获异常代码块出现继承关系 应该把被继承的异常放在子类异常块的后面

throw 和 throws的区别
throw是是用在函数上，而throws是使用在函数内
throw后面跟的是异常对象，而throws跟的是异常类可以 多个

对异常的分类：
1.编译时被检测到的异常。
  （值得去处理的异常，或者是希望得到调用者处理，并不影响运算意向）
2.编译时不被检测到的异常（运行时异常RuntimeException以及他的子类）
  （不值得去处理的，交给jvm去处理，出现这种异常假如处理的会影藏异常影响了
  运算意向，eg ：角标越界、内存溢出、除0运算、空指针）