JAVASE_06天_@面向对象_构造和静态和单例设计模式

1.关键字static

1.1静态:static

     用法: 是一个修饰符,用于修饰成员(成员变量,,成员函数)------------静态的成员变量,也叫 类变量，类方法

1. 静态内容被类的所有对象所共享..--放在了方法区(共享区,数据区)，

2.局部变量无法使用static修饰符

3. 类名可以直接调用

当成员被静态修饰后,就多了一种调用方式,除了可以被对象调用外,还可以直接被类名调用. 形式:类名.静态成员 

1.2，static特点:

        1.随着类的加载而加载.随着类的消失而消失,,,,,说明它的生命周期最长.

                 类加载时,成员变量(实例变量)不存在,当创建对象时,才存在

        2.优先于对象存在

        3.被所有对象所共享

        4.可以直接被类名所调用

1.3，实例变量和类变量的区别:

    1.存放位置

            类变量随着类的加载而存在与方法区中.

            实例变量随着对象的建立而存在与堆内存中

    2.生命周期

            类变量生命周期长,随着类的消失而消失

            实例变量生变周期随着对象的消失而消失

1.4，静态使用注意事项:

        1.静态方法只能访问静态成员.----错误提示:无法从静态上下文中引用非静态变量

                 非静态方法既可以访问静态也可以访问非静态

         2.静态方法中不可以定义this,super关键字.

                 因为静态优先于对象存在,所以静态方法中不可以出现this.

        3.主函数是静态的

静态有利有弊

利处: 对对象的共享数据进行单独空间的存储,节省空间.

        没有必要每一个对象中都存储一份.

         可以直接被类名调用

弊端: 上生命周期过长.

         访问出现局限性.(静态虽好.只能访问静态）

1.5，java 类加载过程（静态变量、成员变量、静态块、静态方法、构造方法）

静态变量——>静态块——>成员变量——>构造代码块——>构造函数——>静态方法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

class ClassLoad{      static int number = 1; //静态变量(类变量)      int xmember = 7; //成员变量      ClassLoad(){          System.out.println( "构造函数运行了" +number+xmember); //编译通过      }      static{          System.out.println( "静态代码块运行了" +number); //既然能调用说明静态变量先入内存          //System.out.println(xmember);//编译失败,说明成员变量还未初始化      }      {          System.out.println( "构造代码块运行了" +number+xmember); //编译通过      }      public static void show(){          number = number+5;      } } public class  Client{      public static void main(String[] args){          System.out.println(ClassLoad.number);          ClassLoad t2 =  new  ClassLoad();         ClassLoad.show();//      } }

2.主函数main

/*

 * 主函数:是一个特殊的函数.作为程序的入口,可以被jvm调用

 * public:代表着该函数访问权限是最大的.

 * static:代表主函数随着类的加载就已经存在了.

 * void:主函数没有具体的返回值

 * main:不是关键字,但是是一个特殊的单词,可以被jvm识别

 * (String[] args):函数的参数,字符串类型的数组args是arguments的缩写

 * jvm在调用主函数时,传入的是new String[0];

 * 主函数是固定格式的:JVM识别

 */

public  class  MainDemo {

     public  static  void  main(String[] args){

         String[] arr = { "heihei" , "haha" , "hehe" , "hiahia" };

         MainTest.main(arr);

     }

 

}

class  MainTest{

     public  static  void  main(String[] args){

         

     }

}

3.静态---什么时候使用

        1.什么时候定义静态变量(类变量)?

                当对象中出现共享数据时(不是相同属性),该数据被静态所修饰

                对象中的特有数据要定义成非静态存在于堆内存中

        2.什么时候定义静态函数?

                 当功能内部没有访问到非静态数据(对象的特有数据);

---

---

4.静态的应用----工具类

 * 静态的应用。

 * 每一个应用程序中都有共性的功能，

 * 可以将这些功能进行抽取，独立封装。

 * 以便复用。

 * 

 * 虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。

 * 发现了问题：

 *1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。

 *2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。

 *

 *这时就考虑，让程序更严谨，是不需要对象的。

 *可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。

将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。

为了更为严谨，强制让该类不能建立对象。

可以通过将构造函数私有化完成。

 *接下来，将ArrayTool.class文件发送给其他人，其他人只要将该文件设置到classpath路径下，就可以使用该工具类。

 *

 *但是，很遗憾，该类中到底定义了多少个方法，对方去不清楚。因为该类并没有使用说明书。

 *

 *开始制作程序的说明书。java的说明书通过文档注释来完成。

 */

/**

 *这是一个看可以对数组进行操作的工具类,该类中提供了,获取最值,排序等功能.

 *@author Administer

 *@version v1.1

 *

 */

public   class  ArrayTool {

     /**

      * 空参数构造函数

      */

     private  ArrayTool(){} //将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。

                          // 为了更为严谨，强制让该类不能建立对象。可以通过将构造函数私有化完成。

     /**

      *获取一个整形数组中的最大值。

      *@param arr 接收一个int类型的数组。

      *@return 会返回一个该数组中最大值。

      */

     public  static  int  getMax( int [] arr){

         int  max =  0 ;

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

             if (arr[i]>arr[max]){

                 max = i;

             }

         }

         return  arr[max];

     }

     /**

      *获取一个整形数组中的最小值。

      *@param arr 接收一个int类型的数组。

      *@return 会返回一个该数组中最小值。

      */

     public  static  int  getMix( int [] arr){

         int  min =  0 ;

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

             if (arr[i]>arr[min]){

                 min = i;

             }

         }

         return  arr[min];

     }

     /**

     给int数组进行选择排序。

     @param arr 接收一个int类型的数组。

     */

     public  static  void  selectSort( int [] arr){

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

             for ( int  j=i;j<arr.length;j++){

                 if (arr[i]>arr[j]){

                     swap(arr,i,j);

                 }

             }

         }

     }

     /**

     给int数组进行冒泡排序。

     @param arr 接收一个int类型的数组。

     */

     public  static  void  bubbleSort( int [] arr){

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

             for ( int  j= 0 ;j<arr.length-i- 1 ;j++){

                 if (arr[j]>arr[j+ 1 ]){

                     swap(arr,j,j+ 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;

     }

     /**

     用于打印数组中的元素。打印形式是：[elemet1, element2, ...]

     */

     public  static  void  printArray( int [] arr){

         System.out.println( "[" );

         for ( int  x= 0 ;x<arr.length;x++){

             if (x!=arr.length- 1 ){

                 System.out.println(arr[x]+ " ," );

             }

             else  {

                 System.out.println(arr[x]+ "]" );

             }

             

         }

     }

}







5.帮助文档的制作   

    javadoc的java文件中类必须是public

   代码在上面

  命令: javadoc -d myhelp -author - version Arraytool.java

javadoc生成的就是API---Application_Program_Interface

---

---

6.静态代码块

/*

  * 静态代码块:给类初始化

  * 格式:

  *static{

  *   执行语句.

  *}

  *特点: 随着类的加载而执行,只执行一次，并优先于主函数，无论在什么地方

  */

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

//代码一 class StaticCode{      {          System.out.print( "a" ); //构造代码块      }      static{          System.out.print( "b" ); //      } } public class StaticCodeDemo{      static{          System.out.print( "c" );      }      public static void main(String[] args){          new  StaticCode();          new  StaticCode(); //此句代码会执行,但是内存里面.class文件已经加载，因此里面的静态代码块不会执行          StaticCode s =  null ;          System.out.print( "d" );      }      static{          System.out.print( "e" );      } //结果cebaad

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

//方法二 class StaticCode{      int num = 9;             { //构造代码块,给对象初始化          System.out.print( "a" +num); //注意：字符串加号问题,this可以省略      }      static{ //静态代码块,给类初始化 //      System.out.print("b"+mum);//无法从静态上下文中引用非静态变量，如果将num加上static修饰就可以          System.out.print( "b" );      }      StaticCode(){ //构造函数          System.out.println( "c" );      }      StaticCode(int x){ //带参数的构造函数          System.out.println( "d" );      } } public class StaticCodeDemo{      public static void main(String[] args){          new  StaticCode(4); //到带参数的构造函数      } //结果ba9d, }

1 2 3 4 5 6 7

//代码三 //简单的代码块 public void show(){          {              System.out.println( "xxxxxxxx" );          } }

---

---







7.对象的初始化过程

/*

Person p = new Person("zhangsan",20);

 

该句话都做了什么事情？

1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。

2，执行该类中的 static代码块 ，如果有的话，给Person.class类进行初始化。

3，在堆内存中开辟空间，分配内存地址。

4，在堆内存中建立对象的特有属性。并进行默认初始化。

5，对属性进行 显示初始化 。

6，对对象进行构造代码块初始化。

7，对对象进行对应的构造函数初始化。

8，将内存地址付给栈内存中的p变量。

 

*/

如图所示:

---

---

8.对象调用成员变量

---

---

9. 单例设计模式方式一

/*

设计模式：解决某一类问题最行之有效的方法。

java中有23种设计模式,

单例设计模式：解决一个类在内存只存在一个对象。

 

 

想要保证对象唯一。

1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象

2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。

3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

 

这三部怎么用代码体现呢？

1，将构造函数私有化.

2，在本类中创建一个静态的本类对象,以为方法是静态的!!

3，提供一个方法可以获取到该对象。

注意:本类对象和属性全部私有!,对象和方法全部static




对于事物该怎么描述，还怎么描述。

当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

*/

 完整代码：本例中只有一个对象，3个引用s, s1, s2.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

class  Student{      private  String name;             private  Student(){} //将构造函数私有化      private  static  Student s =  new  Student(); //在本类中创建一个本类对象      public  static  Student getInstance(){ //提供获取该对象           return  s;      }      public  void  setName(String name){          this .name = name;      }      public  String getName(){          return  name;      }  } public  class  SingleDemo {      public  static  void  main(String[] args){          Student s1 = Student.getInstance();          Student s2 = Student.getInstance(); //只有一个对象      } }




*************************************************************************************************







---

---

10.单例设计模式方式二

1 2 3 4 5 6 7 8 9 10

称为：饿汉式。------开发常用   这个是先初始化对象。 Single类已加载，就已经创建好了对象。此时方式去中s已经有对象的引用地址 class  Single{      private  static  Single s =  new  Single();      private  Single(){}      public  static  Single getInstance(){          return  s;      } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

/*对象是方法被调用时，才初始化，也叫做对象的延时加载。 称为：懒汉式。------------面试考 Single类加载，s=null，此时对象还未存在，只有调用了getInstance方法时，才建立对象。 */ class  Single{      private  static  Single s =  null ;      private  Single(){}      public  static  Single getInstance(){          if (s== null ){              //双重判断, 只在第一次创建实例时才同步，以后就不需要同步了提好了效率              synchronized (Single. class ){                   if (s== null )                      s =  new  Single();              }          }          return  s;      } }

//记录原则：定义单例，建议使用饿汉式。

比较上面两种写法：

饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间。