Java之static_final_abstract

关键字 static

• 在Java类中声明变量、方法和内部类时，可使用关键字static做为修饰符。
• static标记的变量或方法由整个类(所有实例)共享，如访问控制权限允许，可不必创建该类对象而直接用类名加‘.’调用。
• static成员也称类成员或静态成员，如：类变量、类方法、静态方法等。
• 因为不需要实例就可以访问static方法，因此static方法内部不能有this,(也不能有super ? )   
• 在静态方法里只能直接调用同类中其它的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。
•  静态方法不能以任何方式引用this和super关键字。与上面的道理一样，因为静态方法在使用前不用创建任何实例对象，当静态方法被调用时，this所引用的对象根本就没有产生。
•  main() 方法是静态的，因此JVM在执行main方法时不创建main方法所在的类的实例对象，因而在main()方法中，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在以后的例子中会多次碰到。
•     类属性作为该类各个对象之间共享的变量。在设计类时,分析哪些类属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法。
•    如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用

静态初始化

• 一个类中可以使用不包含在任何方法体中的静态代码块(static block )，当类被载入时，静态代码块被执行，且只被执行一次，静态块经常用来进行类属性的初始化。
• static块通常用于初始化static (类)属性

class Person {

         public static int total;

         static {

                total = 100;//为total赋初值

         }

         …… //其它属性或方法声明

 }

单子 Singleton 设计模板

所谓类的单态设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造方法的访问权限设置为private，这样，就不能用new 操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

class Single{

        privatestatic Single onlyone = new Single();//私有的，只能在类的内部访问

        privateString name;

         public static Single getSingle() {   //getSingle()为static，不用创建对象 

                                //即可访问

                 returnonlyone;

        }

        privateSingle() {}     //private的构造器，不能在类的外部创建该类的对象

       }

public classTestSingle{

         public static void main(String args[]){             

         Single s1 = Single.getSingle();      //访问静态方法

         Single s2 = Single.getSingle();

         if (s1==s2){

                                System.out.println("s1 is equals tos2!");

                            }

         }

}

Main函数举例

public classCommandPara {

       public static void main(String[] args) {

        for( int i = 0; i < args.length; i++ ) {

                    System.out.println("args[" + i+ "] = " + args[i]);

         }

       }

   }

//运行程序CommandPara.java

java CommandPara  lisa "bily"  "MrBrown"

//输出结果：

args[0] = lisa

args[1] = bily

args[2] = Mr Brown

关键字 final

• 在Java中声明类、属性和方法时，可使用关键字final来修饰。
• final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次。
• final标记的类不能被继承。提高安全性，提高程序的可读性。
• final标记的方法不能被子类重写。增加安全性。
• final标记的成员变量必须在声明的同时或在每个构造方法中显式赋值，然后才能使用。

            final PI=3.14;

例：

publicfinal class Test{

                   public static inttotalNumber= 5 ;

                   public final int id;

                   public Test(){

                            id =++totalNumber;//只能在构造方法中给final变量赋值

                   }

               publicstatic void main(String[] args) {

                            Test t = new Test();

                            System.out.println(t.id);          

                            final int i = 10;

                            final int j;

                            j = 20;

                            j = 30;                        //非法

                       }

}

抽象类(abstract class)

• 随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。
• 用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。
• 抽象方法：只有方法的声明，没有方法的实现。以分号结束。

     abstract int abstractMethod1( int a );

• 含有抽象方法的类必须被声明为抽象类。
• 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。
• 不能用abstract修饰私有方法，构造方法，静态方法。

例：

abstract classA{  

           abstract void m1( );

           public void m2( ){

                   System.out.println("A类中定义的m2方法");

           }

}

class B extends A{

           void m1( ){

                   System.out.println("B类中定义的m1方法");

           }

}

public class Test{

           public static void main( String args[ ] ){

                   A c = new B( );

                   c.m1( );

                   c.m2( );

           }

}