面向对象( 6 )中(static 单例设计)

一、static关键字

 1.用法：
  (1)是一个修饰符，用于修饰成员（成员变量和成员函数）。
  (2)当成员被静态修饰后，就多了一个调用方式，除了被对象调用外，还可以直接被类名调用。格式：类名.静态成员
 

2.static特点：
  (1)随着类的加载而加载。比如Person类进内存的时候，country="CN"已经在内存中开辟好空间。也就是说静态会随着类的消失而消失，说明它的生命周期最长。
  (2)优先于对象而存在。明确一点：静态是先存在的，对象是后存在的。
  (3)被所有对象所共享。
  (4)可直接被类名所调用。
 

3.实例变量和类变量的区别：
  (1)存放位置：
      类变量随着类的加载而存在于方法区中。
      实例变量随着对象的建立而存在于堆内存中。
  (2)生命周期：
      类变量生命周期最长，随着类的消失而消失。
      实例变量生命周期随着对象的消失而消失。
 

4.静态使用注意事项：
  (1)静态方法只能访问静态成员。非静态主法即可以访问静态也可以访问非静态。
  (2)静态方法中不可以定义this,super关键字。因为静态优先于对象存在，所以静态方法中不可以出现this.因为没有对象.
  (3)主函数是静态的.

 

5.静态的利与弊：
  (1)利：
  节省空间。对对象的共享数据进行单独空间才存储，没有必要每个对象都存储一份.
  可直接被类名调用。
  (2)弊：
  生命周期过长。
  访问出现局限性。（静态虽好，只能访问静态）

 6.什么时候使用静态
  (1)什么时候定义静态变量（类变量）
   当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
  (2)什么时候定义静态函数
  当功能内部没有访问到非静态数据（对象的特有数据）,那么该功能就可以定义成静态的。
 

class Person{String name;//成员变量，实例变量    非静态变量static String country="CN";//static 静态，就不在堆内存中了（方法区、共享区、数据区）public void show()//如果这里用静态修饰方法 public static void show()就不能调用非静态的name。{System.out.println(name+"::"+country);}}class StaticDemo {public static void main(String[] args) {Person p=new Person();p.name="simida";p.show();System.out.println(Person.country);//被类名调用。}}

  7.主函数：

    public static void main(String[] args)

    主函数：是一个特殊的函数。作为程序的入口，可以被JVM调用。
    主函数的定义：
    public：代表着该函数访问权限是最大的。
    static:代表主函数随着类的加载就已经存在了。
    void：主函数没有具体的返回值。就是调用 没什么结果回来的意思。
    main：不是关键字。但是是一个特殊的单词，可以被jvm识别。
    (String[] args)：函数的参数,参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

    主函数是固定格式的：jvm识别。
    jvm在调用主函数时，传入的是new String[0]；

class MainDemo {public static void main(String[] args) //args:arguments{String[] arr={"haha","heihei","xixi","simida"};MainTest.main(arr);}}class MainTest{public static void main(String[] args){for (int x=0;x<args.length;x++){System.out.println(args[x]);}}}

8.静态的应用 (工具类)

/*静态的应用.每一个应用程序中都有共性的功能.可以将这些功能进行抽取独立封装以便复用.虽然可以通过建立ArrayTool的对象使用这些工具方法,对数组进行操作.发现了问题:1,对象是用于封装数据的,可是ArrayTool对象并未封装特有数据.2,操作数组的每一个办法都没有用到ArrayTool对象中的特有数据.这时就考虑,让程序更严谨,是不要对象的.可以将ArrayTool中的方法都定义为static的.直接通过类名调用即可.将方法都静态后,可以方便于使用,但是该类还是可以被其他程序建立对象的.为了更严谨,强制让该类不能建立对象.可以通过将构造函数私有化完成.接下来,将ArrayTool.class文件发送给其他人,其他人只要将该文件设置到classpath路径下,就可以使用该工具类.不过,该类中到底定义了多少个方法,对方不清楚.因为该类没有说明书.开始制作程序的说明书.*//**这是一个可以对数组进行操作的工具类,该类中提供了,获取最值,排序等功能.@author 张三@version V1.1*/public class ArrayTool{/**空参数构造函数.*//*一个类中默认会有一个空参数的构造函数.这个默认的构造函数的权限和所属类一致.如果类被public修饰,那么默认的构造函数也带public修饰符.如果类没有被public修饰,那么默认的构造函数,也没有public修饰.默认构造构造函数的权限是随着类的变化而变化的.*/private ArrayTool(){}   //这里即是将构造函数私有化./**获取一个整型数组中的最大值.@param arr 接受一个int类型的数值.@return 会返回一个该数组中的最大值.*/public static int getMax(int[] arr){int max=0;    for (int x=1;x<arr.length ;x++ ){if (arr[x]>arr[max]){max=x;}     }    return arr[max];}/**获取一个整型数组中的最小值.@param arr 接受一个int类型的数值.@return 会返回一个该数组中的最小值.*/public static int getMin(int[] arr){int min=0;    for (int x=1;x<arr.length ;x++ ){if (arr[x]<arr[min]){min=x;}     }    return arr[min];}/**给int数组进行选择排序.@param arr 接受一个int类型的数组.*/public static void selectSort(int[] arr){for (int x=0;x<arr.length-1 ;x++ ){for (int y=x+1;y<arr.length ;y++ ){if (arr[x]>arr[y]){swap(arr,x,y);}}}}/**给int数组进行冒泡排序.@param arr 接受一个int类型的数组.*/public static void bubbleSort(int[] arr){for (int x=0;x<arr.length-1 ;x++ ){for (int y=0;y<arr.length-x-1 ;y++ ){if (arr[y]>arr[y+1]){swap(arr,y,y+1);}}}}/**给数组中的元素进行位置的置换.@param arr 接受一个int类型的数组.@param a 要置换的位置.@param b 要置换的位置.*/private static void swap(int[] arr,int a,int b)//私有的即使写了说明,说明书上也不会体现.{int temp=arr[a];arr[a]=arr[b];arr[b]=temp;}/**用于打印数组中的元素.打印形式是:[element1,element2,...]*/public static void printArray(int[] arr){System.out.print("[");for (int x=0;x<arr.length ;x++ ){if(x!=arr.length-1)System.out.print(arr[x]+",");elseSystem.out.println(arr[x]+"]");}}}

class ArrayToolDemo {public static void main(String[] args) {int[] arr={3,1,87,32,8};int max=ArrayTool.getMax(arr);System.out.println("max="+max);ArrayTool.printArray(arr);ArrayTool.selectSort(arr);ArrayTool.printArray(arr);int[] arr1={5,2,3,25,36};ArrayTool.printArray(arr1);ArrayTool.bubbleSort(arr1);ArrayTool.printArray(arr1);/*ArrayTool tool=new ArrayTool();int max=tool.getMax(arr);System.out.println("max="+max);int min=tool.getMin(arr);System.out.println("min="+min);tool.printArray(arr);tool.selectSort(arr);tool.printArray(arr);int[] arr1={};ArrayTool tool1=new ArrayTool();*/}}

   制作帮助文档
  (1)帮助文档就是类的说明书，可帮助更好地使用类和程序。
  (2)制作帮助文档使用的是javadoc.exe工具

   
9.静态代码块：
  (1)格式：
  static
  {
   静态代码块中的执行语句;
  }
  (2)特点：
  随着类的加载而执行，只执行一次，并优先于主函数执行，用于给类进行初始化。

class StaticCode{int num=9;StaticCode(){System.out.println("b");//没有创建与之对应的对象,就没有执行过.}static{System.out.println("a");//静态代码块,给类初始化的}{System.out.println("c"+this.num);//构造代码块,给对象初始化的}StaticCode(int x){System.out.println("d");//构造函数,给对应对象初始化的.}public static void show(){System.out.println("show run");}}class StaticCodeDemo {static{//System.out.println("b");}public static void main(String[] args) {new StaticCode(4);//这里运行结果是 a c9 d//new StaticCode();//new StaticCode();//System.out.println("over");StaticCode.show();}static {//System.out.println("c");}}//d:\>java0217\day06>java StaticCodeDemo// 运行结果 b c a over

 

二、 对象的初始化过程
 1.对象的初始化过程：
  Person p = new Person("lisi",20);该句话都做了什么？
  (1)因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中。
  (2)执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
  (3)在堆内存中开辟空间，分配内存地址。
  (4)在堆内存中建立对象的特有属性，并进行默认初始化。
  (5)对属性进行显示初始化。
  (6)对对象进行构造代码块初始化。
  (7)对对象进行对应的构造函数初始化。
  (8)将内存地址赋给栈内存中的p变量。

class PersonDemo {public static void main(String[] args) {Person p=new Person("gaga",25);p.setName("lisi");}}class Person{private String name;private int age;private static String country="CN";Person(String name,int age){this.name=name;this.age=age;}{System.out.println(name+".."+age);}public void setName(String name){this.name=name;}public void speak(){System.out.println(this.name+"..."+this.age);}public static void showCountry(){System.out.println("country="+Person.country);//静态前是 类名.  非静态前是this.Person.method();}public static void method(){System.out.println("method run");}}

 

三、单例设计模式

 1.设计模式
  (1)设计模式：解决某一类问题最行之有效的方法。java中有23种设计模式。
  (2)单例设计模式：解决一个类在内存中只存在一个对象的问题。

 2.单例设计的思想与步骤：
  (1)将构造函数私有化。
  (2)在类中创建一个本类对象。
  (3)提供一个方法可以获取到该对象。

3.想要保证对象唯一.
  (1),为了避免其他程序过多建立该类对象.先禁止其他程序建立该类对象.
  (2),还为了让其他程序可以访问到该类对象,只好在本类中,自定义一个对象.
  (3),为了方便其他程序对自定义对象的访问,可以对我提供一些访问方式.

4.单例设计模式方式一：饿汉式(开发一般用这个)
   (1)这个方式是先初始化对象。
   Single类一进内存，就已经创建好了对象
   (2)代码：

class Single{private static Single s=new Single();private Single(){}public static Single getInstance(){return s;}}

 4.单例设计模式方式二：懒汉式
  (1)对象是方法被调用时，才初始化，也叫对象的延迟加载。
  Single类进内存，对象还没有存在，只有调用了getInstance方法时才建立对象。
  (2)代码：
  

class Single{private static Single s=null;private Single(){}public static Single getInstance(){if(s==null)s=new Single();return s;}}

  (3)实例的延迟加载，多线程访问时会出安全问题。使用判断优化如下：

  public static Single getInstance()  {   if(s==null)   {    synchronized(Single.class)    {     if(s==null)      s=new Single();    }   }   return s;  }