五、Java语言基础5（static关键字、单例设计模式）

这些是笔者学习Java基础时的笔记，供后来者参考（学习是持之以恒的的事情，一定要坚持哟，切记！切记！！！）

一、static关键字

1.基本用法，是一个修饰符，用于修饰成员（成员变量，成员函数）
（内存中单独提取出来，对象之间可以共享，存储于方法区中）

2.两种调用方式
    <1>当成员被静态修饰时，静态成员多了一种调用方式，除了可以被对象调用外，
    <2>还可以直接被类名调用。类名，静态成员。

3.static特点
    <1>.随着类的加载而加载。
        也就是说：静态随着类的消失而消失，因此生命周期最长。
    <2>.优先于对象存在
    <3>.被所有对象共享
    <4>.可以直接被类名所调用

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

5.静态使用注意事项
    <1>.静态方法只能访问静态成员
        非静态方法既可以访问静态也可以访问非静态。
    <2>.静态方法中不可以定义this，super关键字。
        因为静态优先于对象存在。所以静态方法不可以出现this。
    <3>.主函数是静态的
    *注：java中的内存分配：堆内存、栈内存、方法区（共享区、数据区）

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

7.什么时候使用静态?
    <1>什么时候定义静态变量？
        当对象中出现共享数据是时，该数据被静态所修饰。
        对象中的特有数据要定义成非静态存储于堆内存中。
    <2>什么时候定义静态函数？
        当功能内部没有访问非静态数据时，那么该功能使用静态定义。

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

9.对象初始化的过程：
    Person p=new Person("zhangsan",20);这句话的执行过程：
    1.将Person.class文件加载到内存。
    2.执行该类中的static代码块，给Person类进行初始化。
    3.在堆内存中开辟空间，分配内存地址。
    4.在堆内存中建立对象的特有属性，成员变量的默认初始化。
    5.成员变量的显示初始化。
    6.构造代码块的初始化。
    7.构造函数的执行。
    8.将内存地址赋值给栈内存中的p变量。

10.拓展：
    （1）main函数：public static void main(String[] args)
        1.主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。
        2.主函数的定义：
            public：代表着该函数访问权限是最大的。
            static：代表主函数随着类的加载就已经存在啦！
            void：主函数没有具体的返回值。
            main：不是关键字，但是是特殊的单词，可以被jvm识别。
            （String[] arr）：函数的参数，参数类型是一个数组，该数组的元素是字符串。
        3.主函数是固定格式的：可被jvm识别。
        4.jvm在调用主函数时，传入的是new String[0]。

    （2）帮助文档的制作
        命令：javadoc -d myhelp -author -version ArrayTool.java
        注意：
            1.注释形式为。
            2.要生成帮助文档的类必须用public修饰。
            3.构造函数的修饰符默认和所在类的修饰符一样。

二、单例设计模式

1.什么是设计模式？
    设计模式解决某一问题最行之有效的方法。

2.单例模式想要解决的问题：
    一个类在内存中，只可以存在一个对象的问题，主要是想要保证对象唯一性。

3.思路：
    1.为了避免其他程序过多建立对象。先禁止其他程序建立该对象。
    2.为了改程序可以访问该对象，只好在本类中，自定义一个对象。
    3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

4.代码体现：
    1.将构造函数私有化。
    2.在类中创建一个本类对象。
    3.提供一个方法可以获取到该对象。

5.代码实现：
    <1>饿汉式：
    //将构造函数私有化
    private Single(){}
    //在类中创建一个本类对象
    private static Single s = new Single();
    //提供一个方法可以获取到该对象
    public static Single getInstance()
    {
        return s;
    }

    <2>懒汉式：
    1.代码：
    private Single(){}
    private static Single s = null;
    public static Single getInstance()
    {
        return s = new Single();
    }

2.特点：延迟加载
3.存在的问题多用户并发时不够安全，有可能在内存中创建出多个对象。
4.解决方法（加锁机制）：
public static synchronized Single getInstance()
{
    if(s==null)
    {
        s = new Single();
    }
    return s;
}

5.性能优化（将加锁机制内置）
public static Single getInstance()
{
    if(s == null)       //此处添加一个判断，减少判断锁的次数
    {
        synchronized(Single.class)
        {
            if(s == null)
            s = new Single();
        }
    }
    return s;
}
*建议：使用饿汉式（此处可以参考剑指offer，单例的实现方式不止两种）。