lesson5 高级类特性

1.static关键字

     静态块比构造器先执行

     静态方法只能访问静态的，非静态方法可以访问静态的和非静态的

 

2.单子（Sington）设计模式

    在整个应用中，只有一个实例存在。

   例：  public class Single

            {  

                  private double r;

                  private static Single sp;

                  private Single()                      //私有构造器，因此不能随便new

                  {   r = Math.random();  }        //产生一个随机数

                  public static Single getInstance()       //返回Single的实例

                  {

                       if(sp == null)

                       {

                           sp = new Single();

                           return sp;

                       }

                 }

                 public double getR()

                 {    return  r;  }                         //用于检测是否为同一个实例

                 public static void main(String[] args)

                 {

                      Single s1 = Single.getInstance();

                      Single s2 = Single.getInstance();

                      System.out.println(s1.getR());

                      System.out.println(s2.getR());

                 }                                            //两个结果相同，表示是同一个实例

3.final关键字

       final类，不可被继承

       final变量，在初始化后不可改变变量值（如果final变量是引用变量，则不可以改变它的引用对象，但可以改变对象的数据）

       final方法，不可被覆盖

4.abstract关键字

      abstract抽象类，不能被实例化

      abstract抽象方法，只有方法声明，没有方法的实现

      抽象类里面并非一定需要抽象方法，但是没有抽象方法，抽象类就没有存在的必要

  在以下任一条件成立时，类必须定义成抽象类：

      1）类中有至少一个抽象方法

      2）类继承了父类中的抽象方法，但是至少有一个抽象方法没有实现

      3）类实现了某个接口，但没有全部实现接口中的方法

5.模板设计模式（Template Pattern）

    在类中定义了某个算法的骨架，但不具体实现，而在其子类中实现

6.接口（interface）：是方法和常量值的定义的集合

     接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有实现

     定义格式：<modifier> interface <name> [extends<superinterface>]

                      {    [<attribute declarations>]

                           [<abstract method declarations>]

                      }

  抽象类里可以有非抽象的方法和属性，也可以有抽象的方法和属性

  接口中只包含常量和方法的定义，没有实现

7.接口的继承

    接口和类类似，也可以从一个父接口中派生，接口的继承也是使用extends来完成

   语法：<modifier> interface <name>

             [extends <super interface>,<super interface>]

             {    [<attribute   declarations>]

                  [<abstract method declarations>]

             }

   和类不同的是，一个接口可以继承多个父接口

8.实现接口：

      多个无关的类可实现同一个接口，一个类可实现多个无关的接口

  语法：  <class declaration>  ::=

               <modifier> class <name> [extends<superclass>]  [implements<interface> [<interface>]*]

               {   <declaration> *  }

   在java中，可以通过接口来模拟多继承

例： 抽象类    public abstract class People

                       {

                             public abstract int yearSalary();

                        }

                       public class Worker extends People

                       {

                              public int yearSalary()

                              { ....}

                       }

        接口        public interface Pelple

                       {

                              public int yearSalary();

                       }

                       public class Worker implements People

                       {

                              publci int yearSalary()

                              { ....}

                       }

9.多态（Polymorphism）

   一个类型为Aclass的变量既可以指向类型为Aclass的对象，又可以指向Aclass的任何子类的对象（继承的对象和实现的对象）

     一个对象只能有一种确切的数据类型

      一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法

10.对象造型（Casting）

     所谓造型就是Java对象间的类型转换，分为自动造型和强制造型

        对象的造型只用在有继承关系的对象之间

11.内部类（inner class）

       允许一个类的定义出现在另一个类中，将处于另一个类中的“寄生类”称为内部类

        内部类对其封装类的内部成员有访问权限

       实例化内部类的两种方法：

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

              2) Outer o = new Outer();

                  Outer.Inner = o.new Inner();

               如果内部类是static的，也可以用下面的方法：

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

12.异常

             try{ 程序代码段 业务逻辑 }

             catch(Exception e) { 异常信息 }

             finally{程序一定会运行的代码，程序尾声 }

    RuntimeException:是那些可能在Java虚拟机正常运行期间抛出的异常的超类。

          如：ArithmeticException,EmptyStackException,IndexOutOfBoundsException

    抛出异常：在定义一个方法的时候，如果并不能确定如何处理其中可能出现的异常，可以不在方法中对异常进行处理，而是将可能发生的异常让这个方法的调用者来处理。

        不要抛出如下异常：1）从Error中派生的那些异常   2）从RuntimeException中派生的那些异常

    方法中抛出异常的格式： <modifier> <returnType> methodName ([argument_list>]) throws <exception_list>  {....}

    捕获和抛出结合使用：捕获异常和抛出异常的方式，并不是排它的，它们可以结合使用

 方法覆盖中的异常：

            当子类中的方法覆盖父类中的方法时，可以抛出异常

            覆盖方法抛出的异常，可以抛出与被覆盖方法的相同的异常或者被覆盖方法的异常的子类异常

    Error：例 IOError, ThreadDeath , VirtualMachineError