java_面向对象_02_静态（代码块）_main_单例设计模式

***************静态

 static特点：

1、随着类的加载而加载。

   也就说：静态会随着类的消失而消失，说明它的生命周期最长。

2、优先于对象的存在

   明确一点：静态是先存在，对象是后存在。

3、被所有对象所共享

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

 

静态使用注意事项

1.静态方法只能访问静态成员，非静态方法可以既可以访问静态  也可以访问非静态

2.静态方法中不可以定义this，super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this

3.主函数是静态的

 

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用之外，还可以直接被类名调用。形式：类名.静态成员变量。

 

什么时候使用静态？

要从两方面下手：成员变量和函数。

1、什么时候定义静态变量呢？

当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据（成员变量）定义成非静态存在于堆内存中。

2、什么时候定义静态函数呢？

当功能内部没有访问到非静态数据（对象的特有数据），那么可以定义成静态的。

 

小知识：静态的一个重要应用是工具类

每一个应用程序都有共性的功能，可以将这些功能抽取，独立封装，一边复用。这时就可以建立一个专门放功能方法的类，不需要独立运行，可以将其放在一个独立的java文件里，当所调用的函数编译时，会将该java文件先进行编译，生成class文件，从而实现其功能。

虽然可以通过建立工具类的对象使用这些工具方法，但是我们会发现，在工具类里并没有特有的数据，而对象是用来封装数据的，其次操作数组的每一个方法都没有用到工具类里对象中的特有数据，这时为了使程序更加严谨，我们可以将工具类里的方法都定义成static的，直接通过类名调用即可，而不用再创建对象。

将方法都静态后，可以便于使用，但是该类还是可以被其他程序建立对象，为了更加严谨，强制让该类不能创建对象，可以把构造函数也私有化

封装完以后就可以将编译生成的class文件给别人使用了，其他人只要将该文件设置到classpath路径下，就可以使用该类工具了，但是其他人并不知道该类定义了多少方法，对如何使用也不清楚，因为没有说明书。所以要制作说明书

java的说明书通过javadoc文档注释来完成

可以通过/**   */来分别对工具类中的各个方法进行说明，而且可以对该工具类的版本、作者等信息进行标识；然后在dos页面下通过调用javadoc指令自动生成该工具类的帮助文档，以网页的形式

 

 实例变量和类变量（静态变量）的区别：

1、存放位置。

   类变量随着类的加载而存在于方法区中。

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

2、生命周期：

   类变量生命周期最长，随着类的消失而消失。

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

 

注意事项：

静态的利弊

利：1、对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份。

    2、可以直接被类名调用

弊：1、生命周期过长

    2、访问出现局限性。（1.static方法只能访问static变量，不能访问实例变量2.static方法只能调用static方法）

    3、main函数是静态的

 

 

********main

主函数：是个特殊的函数，作为程序的入口，可以被jvm调用。

主函数的定义：

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

static：代表住函数随着类的加载就已经存在。

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

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

(String[] arr):函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串类型的数组。

 

主函数是固定格式的：jvm识别。

 

jvm在调用主函数，传入的是new String[0];下面的例子可以O：

*/

class MainTest{

   public static void main(String args[]){

          System.out.println(args);

}

}

这个图，说明 main函数传入的东西是一个实体数组，即new String[0];

 

class MainTest{

   private static int x=1;

 public static void main(String[] args){

          System.out.println(args);

         main(x);

}

  public static void main(int x){        

           System.out.println(x);

}

}

结果是：

说明的问题是，main在一个类中不仅仅只是一个，可以是多个。换句话说，main是可以方法重载的。

又如下面的例子：

class MainTest{

 private static int x=1;

 public static void main(String[] args,int x){

     System.out.println(x); 

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

     System.out.println(args[i]);

        

}

  public static void main(String[] args){        

       String[] arr={"hehe","haha","xixi","fuck"};

            

               main(arr,1); 

}

}

输出结果：

**注：如果上面这例子，还可以不用main构造，即2个方法都是main(String[] args)。但是前提是，必须不同类。

 

/*

静态代码块。

格式：

Static

{

    静态代码块中的执行语句。

}

 

特点：随着类的加载而执行，只执行一次。并优先于主函数

可以用来对类进行初始化~~

小知识点：一个类中，只有用到该类的东西的时候，该类才加载。

*/

小考点：构造代码块，静态代码块，构造方法的一个先后顺序。

class Fuck

{

   int num=1;

     Fuck()

   {

  System.out.print("a");

}

 

{

  System.out.print("b"+this.num);//这里的this可以省略。

}

 

static

{

 System.out.print("c");

}

 

Fuck(int x)

{

 System.out.print("d");

}

public static void main(String[] args)

{

   new Fuck(10);

}

}

这个例子，的输出是：c b1 d;  如果如下：

class Fuck

{

   int num=1;

     Fuck()

   {

  System.out.print("a");

}

 

{

  System.out.print("b");

}

 

static

{

 System.out.print("c"+this.num);/*这样就挂了，因为static中不能写this的，所以num的引用是不OK的，所以要+num，那就让num前面加上static就O了*/

}

 

Fuck(int x)

{

 System.out.print("d");

}

public static void main(String[] args)

{

   Fuck p=new Fuck(10);

 

}

}

 

Fuck p=new Fuck(10);

这句话做了什么事？

1、  由于new,所以会先找到Fuck.class文件并加载到内存中。

2、  执行该类中的static代码块，对该类进行初始化。如果有的话~~

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

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

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

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

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

8、  将内存地址付给在栈内存中的P变量。

 

一个类中默认会有一个空参数的构造函数

这个默认的构造函数的权限和所属的类一致

如果类被public修饰，那么默认的构造函数也带public修饰符

如果类没有被public修饰那么默认的构造函数也没有public修饰

即默认构造函数的权限是随着类的变化而变化的

*******************单例设计模式 

         设计模式：解决某一类问题行之有效的方法。java中包含23种设计模式

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

         步骤：1).将构造函数私有化

                    2).在类中创建一个本类对象。

                    3).提供一个方法获取对象。

        举例：

                 //饿汉式

                 class Demo{

                         private Demo(){}                          //构造函数私有化

                         private Demo d=new Demo();      //本类中创建对象并私有化。

                         public static Demo getInstance(){ //对外提供方法获取该对象,因为无法创建对象，所以静态方法

                                      return d;

                          }

                 }  

               //懒汉式 --延迟加载。       据说面试经常考

             class Single

{

         private static Single s =null;

         private Single(){}

         public static Single getInstance()

         {

                  if(s==null)

                          s=new Single();

                  return s;

         }

}

 

这是懒汉式的，加锁~能提高效率，不过还是会有问题。所以开发一定使用饿汉式，因为get()里面就一句语句，不会出错~（注：只有2句以上，在CPU切换处理线程的时候，才有可能出错）；

class Demo{

                       private Demo(){}

                       private Demo d=null;

                       public static Demo getInstance(){  //对外提供方法获取该对象,因为无法创建对象，所以静态方法

                                 if(d==null){

                                           synchronized(Demo.class){

                                                  if(d==null)

                                                          d=new Demo();     //调用时，并经过层层判断后在创建

                                           }

                                 }

                                 return d;

                       }

              }