黑马程序员——面向对象06（static、对象初始化、单例设计模式）

——- android培训、java培训、期待与您交流！ ———-

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

2，static特点：
(1)，随着类的加载而加载，也就是说：静态会随着类的消失而消失，说明它的生命周期最长。
(2)，优先于对象存在。明确一点：静态是先存在。对象是后存在。
(3)，被所有对象所共享。
(4)，可以直接被类名所调用。

3，由于静态成员可以直接被类名调用，因此静态成员变量又称为类变量。而非静态成员变量又被称为实例变量。
实例变量和类变量的区别：
(1)，存放位置。
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
(2)，生命周期。
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。

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

5，什么时候使用静态？
从两方面下手： 因为静态修饰的内容有成员变量和函数。
(1)，什么时候定义静态变量（类变量）呢？
当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。
(2)，什么时候定义静态函数呢？
当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

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

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

8，对象的初始化过程：
定义一个新对象都做了哪些事情？
1、把类名.class文件加载到内存中。
2、执行该类中的static代码块，如果有得话，给该类进行初始化。
3、在堆内存中开辟空间，分配内存地址。给对象
4、在堆内存中建立对象的特有属性，并进行默认初始化。
5、对属性进行显示初始化。
6、对对象进行构造代码块初始化。
7、对对象进行对应构造函数初始化。
8、将内存地址赋给栈内存中的对象名变量。

示例：

class Person
{
    private Person(){}
    private String name = "hah";
    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);
        Person.method();
    }
    public static void method()
    {
        System.out.println("method run");
    }

}

class  PersonDemo
{
    public static void main(String[] args) 
    {
        Person p = new Person("zhangsan",20);
        p.setName("lisi");
        new Person();
    }
}
/*
Person p = new Person("zhangsan",20);

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

*/

1.2：主函数
主函数是一个特殊的函数。作为程序的入口，可以被JVM调用。
主函数的定义：
public：代表着该函数访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被JVM识别。
（String[] arr）：函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。
args：arguments 参数 。唯一可以更改的地方。
主函数是固定格式的：被JVM识别。

1.3：单例设计模式
1，设计模式：解决某一问题最行之有效的方法。java中共有23种设计模式。

2，单例设计模式：保证一个类在内存只存在一个对象。

3，代码体现单例设计模式
1、将构造函数初始化。
2、在类中创建一个本类对象。
3、提供一个访问方法可以获取到该对象。

4，单例设计模式的两种方式：
(1)，饿汉式：类一进内存就初始化对象。
(2)，懒汉式：方法被调用时才初始化对象，这也叫对象的延时加载。

示例：

/*
这个是先初始化对象。
称为：饿汉式。

Single类一进内存，就已经创建好了对象。
class Single
{
    private static Single s = new Single();
    private Single(){}
    public static Single getInstance()
    {
        return s;
    }
}
*/

//对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。
//Single类进内存，对象还没有存在，只有调用了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;
    }
}

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

class  
{
    public static void main(String[] args) 
    {
        System.out.println("Hello World!");
    }
}

——- android培训、java培训、期待与您交流！ ———-