Java（2012/1/28）

一、抽象类（abstract class）和抽象方法（abstract method）

       1）抽象类： 使用了abstract关键字所修饰的类叫做抽象类。抽象类无法实例化，也就是说，不能用new出来一个抽象类的对象（实例）

       2）抽象方法：使用abstract关键字所修饰的方法叫做抽象方法（只有声明）。抽象方法需要定义在抽象类中。相对于抽象方法，之前所定义的方法叫做具体方法（有声明，有实现）

       3）如果一个类包含了抽象方法，那么这个类一定要声明成abstract class，也就是说，该类一定是抽象类；反之，如果某个类是抽象类，那么该类既可以包含抽象方法（只有声明），也可以包含具体方法（有声明，有实现）。

       4）在子类继承父类（父类是个抽象类）的情况下，该子类必须要实现父类中所定义的所有抽象方法；否则该子类需要声明成一个abstract class。

       5）抽象类的作用（例子）：

             public class AbstractTest
             {
                         public static void main(String[] args)
                         {
                                     Shape shape = new Triangle(10,6);
                                     int area = shape.computeArea();
                                     System.out.println("triangle:" + area);
                                     shape = new Rectangle(10,6);
                                     area = shape.computeArea();
                                     System.out.println("rectangle:" + area);

                          }
              }
              abstract class Shape
              {
                                     public abstract int computeArea();
              }

              class Triangle extends Shape
              {
                                     int width;
                                     int height;
                                     public Triangle(int width,int height)
                                     {
                                                  this.width = width;
                                                  this.height = height;
                                      }
                                     public int computeArea()
                                     {
                                                  return width * height / 2;
                                      }
              }

             class Rectangle extends Shape
             {
                                     int width;
                                     int height;
                                     public Rectangle(int width,int height)
                                     {
                                                  this.width = width;
                                                  this.height = height;
                                      }
                                     public int computeArea()
                                     {
                                                  return width * height;
                                     }
              }

二、接口（interface）

       1）接口的地位等同于class，定义接口不再用class关键字，而是用interface关键字，接口中的所有方法都是抽象方法（abstract method），都是public；在声明接口中方法的时候，可以使用abstract关键字，也可以不使用。在通常情况下，都会省略abstract关键字；接口中也可以定义属性，且这个属性是public、final、static。

       2）可以将接口看做是特殊的抽象类（抽象类中可以有具体方法，也可以有抽象方法，而接口中只能由抽象方法， 不能有具体方法）；同样的接口不能实例化。

       3）类可以实现接口。实现使用关键字implements，代表某个类实现了某个接口；一个类实现了某个接口，那么该类必须要实现接口中声明的所有方法；如果该类是抽象类，那么就无需实现接口中的方法了。

       4）Java中类是单继承的，也就是说一个类只能有一个父类，但可以实现多个接口。

       5）接口的继承：一个接口可以有多个直接父接口

 

三、static关键字：可以用来修饰属性、方法、类

       1）static修饰属性：无论一个类生成了多少个对象，所有这些对象公共使用唯一一份静态的成员变量；一个对象对该静态成员变量进行了修改，其他对象的该静态成员变量的值也会随之发生变化。如果一个成员变量是static，那么我们可以通过类名.成员变量名的方式来使用它。

       2）static修饰方法：static修饰的方法叫做静态方法，对于静态方法来说，可以使用类名.方法名的方式来访问。静态方法只能继承，不能override，子类和父类的两个相同方法要么全静态，要么全非静态。

       3）静态的方法只能访问静态的属性和静态的方法，非静态的方法可以访问非静态的属性和非静态的方法也可以访问静态的属性和静态的方法；不能在静态方法中使用this关键字。

       4）static代码块：静态代码块；静态代码块的作用也是完成一些初始化工作。首先执行静态代码块，然后执行构造方法。静态代码块在被类加载的时候执行，而构造方法是在生成对象的时候执行； 要想调用某个类来生成对象，首先需要将类加载到Java虚拟机（JVM）上，然后由JVM加载这个类来生成对象。

       5）类的静态代码块只会执行一次，是在类被加载的时候执行的，因为每个类只会被加载一次，所以静态代码块也只会被执行一次；而构造方法则不然，每次生成一个对象的时候都会调用类的构造方法，所以new一次就会调用构造方法一次。

       6）如果继承体系中既有构造方法，又有静态代码块，那么首先执行最顶层类的静态代码块，一直执行到最底层类的静态代码块，然后再去执行最顶层类的构造方法，一直执行到最底层类的构造方法。注意：静态代码块只执行一次。

 

       *一个类不能既是final又是abstract。

 

四、final关键字：可以修饰属性、方法、类。

        1）final修饰类：当一个类被final所修饰时，该类表示为终态类，不能被继承。

        2）final修饰方法：当一个方法被final所修饰时，该方法表示为终态方法，不能被重写（override）。

        3）final修饰属性：当一个属性被final所修饰时，该属性表示为一个常量，其值不能被改变。当final修饰一个原生数据类型时，表示该原生数据类型的值不能发生变化；如果final修饰一个引用类型时，表示该引用类型不能再指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。

        4）对于final类型的成员变量，一般来说有两种赋初值方式：

              ①在声明final类型的成员变量时就赋上初值；

              ②在声明final类型的成员变量时不赋初值，但在类的所有构造方法中都为其赋上初值。

 

五、包（package）：        用于将完成不同功能的类分门别类，放在不同的目录（包）下。包的命名规则：将公司域名反转作为包名，如：www.shengsiyuan.com，com.shengsiyuan(包名)；对于包名：每个字母都是小写的；如果定义类的时候没有使用package，那么Java就认为我们的类位于默认包里面（default package）。

        1）Java包机制需要2个方面保证：①源文件里使用package语句指定包名；②class文件必须放在对应的路径下。

        2）编译带有package声明的Java源文件有两种方式：

              ①直接编译，然后根据类中所定义的包名，逐一手工建立目录结构，最后将生成的class文件放到该目录结构中（很好使用，比较麻烦）。

              ②使用编译参数-d，方式为javac -d . 源文件.java，这样编译后，编译器会自动帮助我们建立好包所对应的目录结构。

        3）有两个报名，分别是aa.bb.cc和aa.bb.cc.dd，那么我们称后者为前者的子包。

 

六、包导入（import）：将使用package分离的类用import导入回来

        1）Java默认为所有源文件导入java.lang包下的所有类。

        2）import语法：import  a.b.*;       //导入b包下所有的类

                                      import  a.b.C;       //导入b包下的C类

        3）import aa.bb.*并不会导入aa.bb.cc包下的类。

        4）关于package、import、class的顺序问题：

              ①首先需要定义包（package），可选

              ②接下来使用import进行包导入，可选

              ③然后才是class或interface的定义

        5)如果两个类在同一包下，则不需要导入，直接使用即可。