黑马程序员__java基础__面向对象（多态、异常）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

多态

一.多态的描述

（1）定义：多态可以理解为事物存在的多种体现形态。

（2）体现：父类或者接口的引用指向或者接收自己的子类对象。

（3）作用：多态的存在提高了程序的扩展性和后期可维护性。

（4）前提：1. 需要存在继承或者实现关系。 2、存在覆盖。父类中有方法被子类重写。

（5）好处：提高了代码的扩展性和后期可以维护性。

（6）弊端：前期定义的内容不能使用（调用）后期子类的特有内容。

二.多态的特点

（1）成员变量（编译和运行都参考等号的左边）

编译时：参考引用型变量所属的类中的是否有调用的成员变量。有，编译通过，没有，编译失败。

运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。

（2）非静态成员函数（编译看左边，运行看右边）

编译时：参考引用型变量所属的类中是否有调用的函数。有，编译通过。没有，编译失败。

运行时：参考的是对象所属的类中是否有调用的函数。

（3）静态成员函数（编译和运行看左边）

编译时：参考的是对象所属的类中是否有调用的函数。

运行时：参考的是对象所属的类中是否有调用的函数。

（4）例子：

/** * 多态中成员变量、非静态函数、静态函数的特点演示 * @author hy */class Person{String name;int age=25;//父类对年龄初始化Person(String name){this.name=name;}public static void show(){System.out.println("speak");}public  void study(){System.out.println("study");}}class Student extends Person//继承父类{int age=18;//子类对年龄初始化Student(String name){super(name);}public static void show()//复写父类的静态函数{System.out.println("Student speak");}public  void study()//复写父类的非静态函数{System.out.println("Student study");}}public class DuoTai {public static void main(String[] args){Person p=new Student("zhangsan");System.out.println(p.age);//输出结果为25，父类的属性值p.show();//输出结果为speak，调用了父类的静态函数p.study();//输出结果为Student study，调用了子类的非静态函数}}

内部类

一.内部类的描述

（1）定义：将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）。

（2）特点：1.内部类可以直接访问外部类中的成员，包括私有成员。 

                  2.而外部类要访问内部类中的成员必须要建立内部类的对象。

二.内部类的访问

（1）内部类定义在外部类的成员位置上时：

            1.可以在外部其他类中，直接建立内部类对象。如：  Outer.Inner in =new Outer().new Inner();

            2.可以被private、static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。

            3.在外部其他类中，直接访问static内部类的非静态成员的格式为：如：new  Outer.Inner().function();

            4.在外部其他类中，直接访问static内部类的静态成员格式为：如：Outer.Inner().function();

（2）内部类定义在局部：

            1.不可以被成员修饰符修饰。如public、private、static等修饰符修饰。它的作用域被限定在了声明这个局部类的代码块中

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

三.匿名内部类

（1）描述：

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

           2.内部类必须是继承一个类或者实现接口。

           3.匿名内部类的格式：  new父类或者接口(){定义子类的内容}。

           4.其实匿名内部类就是一个匿名子类对象。可以理解为带内容的对象。

           5.匿名内部类中定义的方法最好不要超过3个。

（2）利与弊：

           1.利：简化书写

          2.弊：不能直接调用自己的特有方法、不能做强转动作。

（3）练习 

interface Inter  {         void method();  }  class Test {       //用匿名内部类补足代码}  public class Demo {public static void main(String[] args)    { Test.function().method();     }}/** * 分析：1.Test.function()可知function()为静态方法 *     2.function().method()可知function()返回inter类型的对象 */

完整代码为：

interface Inter  {         void method();  }  class Test {       static Inter function()     {     return new Inter()     {     public void method()     {     System.out.println("haha");     }     };     }}  public class Demo {public static void main(String[] args)    { Test.function().method();     }}

异常

 一.异常描述

 （1）定义：在运行时期发生的不正常情况。

 （2）特点：1. 以前正常流程代码和问题处理代码相结合，现在将正常流程代码和问题处理代码分离，提高阅读性。
                   2. 其实异常就是java通过面向对象的思想将问题封装成了对象，用异常类对其进行描述。
                   3. 不同的问题用不同的类进行具体的描述 。比如角标越界、空指针异常等等。
                   4. 问题很多，意味着描述的类也很多，将其共性进行向上抽取，形成了异常体系。

二. 异常体系

（1）Throwable

                   |---Error  //通常出现重大问题如：运行的类不存在或者内存溢出等。一般不编写针对性的代码对其进行处理。

                   |---Exception //运行时出现的一些情况。可以使用针对性的处理方式进行处理。

                              |---R       untimeException    //特殊异常类，抛时不需要声明

（2）特点：1.异常体系中的所有类以及建立的对象都具备可抛性。

                  2. 也就是说可以被throw和throws关键字所操作。                   

                  3.只有异常体系具备这个特点。

 三.异常处理

（1）格式：

try{需要被检测的代 码      

}

catch（异常类  变量）{处理异常的代码；（处理方式）

}       

 finally{  一定会执行的语句；

}

注：try可单独与catch组合；try也可单独与finally组合。特殊：当执行到System.exit(0);fianlly不会执行。

（2）throw和throws的用法：

           throw定义在函数内，用于抛出异常对象。

           throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

           当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。

           注意：RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。

（3）常见的操作方法：

            1. getMessage()：获取异常信息，返回字符串。
            2. toString()：获取异常类名和异常信息，返回字符串。
            3. printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void。
            4. printStackTrace(PrintStream s)：通常用该方法将异常内容保存在日志文件中，以便查阅。

四.自定义异常

（1）可以自定义出的问题称为自定义异常。

（2）自定义异常时，要么继承Exception，要么继承RuntimeException。

五.异常的处理原则

（1）函数内容如果抛出需要检测的异常，那么函数上必须要声明。否则，必须在函数内用try/catch捕捉，否则编译失败。
（2）如果调用到了声明异常的函数，那么try/catch，要么throws，否则编译失败。    
（3）什么时候catch，什么时候throws呢？功能内容可以解决，用catch。 解决不了，用throws告诉调用者，由调用者解决。
（4）一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性处理。
         内部有几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。

六.异常实例

/**毕老师用电脑上课。问题领域中涉及两个对象。毕老师，电脑。分析其中的问题。比如电脑蓝屏，冒烟等。*/class LanPingException extends Exception{      LanPingException(String msg){             super(msg);      }}class MaoYanException extends Exception{      MaoYanException(String msg){             super(msg);      }}class NoPlanException extends Exception{      NoPlanException(String msg){             super(msg);      }}class Computer{       private int state = 1;//0 2       public void run() throws LanPingException,MaoYanException{             if(state == 1)                   throw new LanPingException("电脑蓝屏啦！");             if(state == 2)                   throw new MaoYanException("电脑冒烟啦！");             System. out.println("电脑运行");       }       public void reset(){            state = 0;            System.out.println("电脑重启");       }}class Teacher{       private String name ;       private Computer comp ;       Teacher(String name){             this.name = name;             comp = new Computer();       }       public void prelect() throws NoPlanException{             try{                  comp.run();                  System. out.println(name + "讲课");             } catch(LanPingException e){                  System.out.println(e.toString());                  comp.reset();                  prelect();             } catch(MaoYanException e){                  System. out.println(e.toString());                  test();                   //可以对电脑进行维修                   throw new NoPlanException("课时进度无法完成，原因：" + e.getMessage());             }       }       public void test(){            System.out.println("大家练习");       }}class ExceptionDemo{       public static void main(String[] args){            Teacher t = new Teacher("毕老师");             try{                  t.prelect();             } catch(NoPlanException e){                  System.out.println(e.toString() + "......." );                  System.out.println("换人");             }       }}