java static 关键字

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。

class Circle{         private double radius;   
     public Circle(double radius){this.radius=radius;}     

    public double findArea(){return Math.PI*radius*radius;}} 创建两个Circle对象 Circle c1=new Circle(2.0);  

 //c1.radius=2.0 Circle c2=new Circle(3.0);    //c2.radius=3.0

Circle类中的变量radius是一个实例变量(instance variable)，它属于类的每一个对象，

不能被同一个类的不同对象所共享。 上例中c1的radius独立于c2的radius，

存储在不同的空间。c1中的radius变化不会影响c2的radius，反之亦然。

如果想让一个类的所有实例共享数据，就用类变量！

 

类属性、类方法的设计思想

类属性作为该类各个对象之间共享的变量。

在设计类时,分析哪些属性不因对象的不同而改变，将这些属性设置为类属性

。相应的方法设置为类方法。 如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用。

使用范围：

在Java类中，可用static修饰属性、方法、代码块、内部类  

被修饰后的成员具备以下特点：

• 随着类的加载而加载
• 优先于对象存在
• 修饰的成员，被所有对象所共享
• 访问权限允许时，可不创建对象，直接被类调用

类变量应用举例

class Person {
           private int id;
           public static int total = 0;
           public Person() {
 	         total++;
 	         id = total;
           }
           public static void main(String args[]){
         	Person Tom=new Person();
	Tom.id=0;
	total=100; // 不用创建对象就可以访问静态成员
         }
 }

public class StaticDemo {
            public static void main(String args[]) {
 	         Person.total = 100;  // 不用创建对象就可以访问静态成员
                           //访问方式：类名.类属性，类名.类方法
	         System.out.println(Person.total);
	         Person c = new Person(); 
	         System.out.println(c.total);	//输出101
            }}

类方法

• 没有对象的实例时，可以用类名.方法名()的形式访问由static修饰的类方法。
• 在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构。
• 因为不需要实例就可以访问static方法，因此static方法内部不能有this。(也不能有super ? YES!)
• static修饰的方法不能被重写

单例 (Singleton)设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。”套路”

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

饿汉式

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }

    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single = new Singleton();

    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        return single;
    }
}

懒汉式

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single;
    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        if(single == null) {
            single = new Singleton();
        }
        return single;
    }
}

单例模式的优点

： 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。

举例 java.lang.Runtime

单例(Singleton)设计模式-应用场景

1. 网站的计数器，一般也是单例模式实现，否则难以同步。
2. 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
3. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
4. 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。
5. Application 也是单例的典型应用
6. Windows的Task Manager (任务管理器)就是很典型的单例模式
7. Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

理解main方法的语法

由于Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，又因为Java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数。 又因为main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在之前的例子中多次碰到。

代码块

代码块(或初始化块)的作用： 对Java类或对象进行初始化

代码块(或初始化块)的分类： 一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块(static block)，没有使用static修饰的，为非静态代码块。

static代码块通常用于初始化static的属性

class Person {     public static int total;   

 static {  

           total = 100;//为total赋初值     }     …… //其它属性或方法声明  }

静态代码块：用static 修饰的代码块
    1. 可以有输出语句。
    2. 可以对类的属性、类的声明进行初始化操作。
    3. 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
    4. 若有多个静态的代码块，那么按照从上到下的顺序依次执行。
    5. 静态代码块的执行要先于非静态代码块。
    6. 静态代码块随着类的加载而加载，且只执行一次。

非静态代码块：没有static修饰的代码块
    1. 可以有输出语句。
    2. 可以对类的属性、类的声明进行初始化操作。
    3. 除了调用非静态的结构外，还可以调用静态的变量或方法。
    4. 若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
    5. 每次创建对象的时候，都会执行一次。且先于构造器执行。

 

final

在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”。
final标记的类不能被继承。提高安全性，提高程序的可读性。 
String类、System类、StringBuffer类
final标记的方法不能被子类重写。
比如：Object类中的getClass()。
final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。
final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋值，然后才能使用。
final double MY_PI = 3.14;

抽象类和抽象方法

用abstract关键字来修饰一个类，这个类叫做抽象类。
 用abstract来修饰一个方法，该方法叫做抽象方法。
抽象方法：只有方法的声明，没有方法的实现。以分号结束：
  比如：public abstract void talk();
 含有抽象方法的类必须被声明为抽象类。
 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
 不能用abstract修饰变量、代码块、构造器；
 不能用abstract修饰私有方法、静态方法、final的方法、final的类

接口

接口(interface)是抽象方法和常量值定义的集合。
 接口的特点：
用interface来定义。
接口中的所有成员变量都默认是由public static final修饰的。
接口中的所有抽象方法都默认是由public abstract修饰的。
接口中没有构造器。
接口采用多继承机制。
 接口定义举例
public interface Runner {
    int ID = 1;
    void start();
    public void run();
    void stop();
public interface Runner {
    public static final int ID = 1;
    public abstract void start();
    public abstract void run();
    public abstract void stop();
}

定义Java类的语法格式：先写extends，后写implements
 class SubClass extends SuperClass implements InterfaceA{ }
 一个类可以实现多个接口，接口也可以继承其它接口。
实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
接口的主要用途就是被实现类实现。（面向接口编程）
与继承关系类似，接口与实现类之间存在多态性
 接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(JDK7.0及之前)，而没有变量和方法的实现。

接口和抽象类之间的对比

内部类

成员内部类作为类的成员的角色：
和外部类不同，Inner class还可以声明为private或protected；
可以调用外部类的结构
Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；
成员内部类作为类的角色：
可以在内部定义属性、方法、构造器等结构
可以声明为abstract类 ，因此可以被其它的内部类继承
可以声明为final的
编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）
【注意】
非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
成员内部类可以直接使用外部类的所有成员，包括私有的数据
当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的