JAVA基础学习(六)---面向对象二---static，类的初始化和调用顺序、单例模式

一、static关键字

1.1、static关键字

静态：static
用法：是一个修饰符，用于修饰成员（成员变量，成员函数）
static 修饰的内容，所有对象共享
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以被类名.静态成员

package com.day06;/** * 人类 * @author Administrator *静态：static *用法：是一个修饰符，用于修饰成员（成员变量，成员函数） *static 修饰的内容，所有对象共享 *当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外， *还可以被类名.静态成员 */public class Person {//属性static String country="CN";String name;public void show(){System.out.println(this.name+"  "+this.country);}public static void main(String[] args) {//多个对象使用同一个属性国家Person p=new Person();Person p1=new Person();p.name="张三";p1.name="李四";p.show();p1.show();System.out.println(Person.country); //类名.静态成员变量}}

特点：

1.随着类的加载而加载--也就是：静态会随着类的消失而消失，它的生命周期最长。

2.优先于对象存在---

静态是先存在，对象是后存在。

3.被所有对象共享

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

1.2、实例变量和类变量的区别

1.存放位置

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

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

       2.生命周期

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

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

1.3、使用注意事项

静态方法只能访问静态成员（静态成员和静态方法）

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

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

因为静态优先于对象存在，所以静态中不可以出现this

主函数是静态的

静态有利有弊

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

       可以直接被类名调用。

弊端：生命周期过长

         访问出现局限性。（静态虽好，只能访问静态。）

1.4、主函数是静态的

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

定义：

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

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

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

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

函数的参数：String[] args--是一个数组，数组中的元素是字符串，字符串类型的数组

主函数是固定格式的，JVM识别。

args:arguments

JVM在调用主函数时，传入的是new String[0]

package com.day06;public class MainTest {public static void main(String[] args) {//遍历主函数for (int i = 0; i < args.length; i++) {System.out.println(args[i]);}}}

package com.day06;public class MainDemo {public static void main(String[] args) {String [] arr={"张三","李四","王五","赵六","钱七"};MainTest.main(arr);}}

结果：

张三
李四
王五
赵六
钱七

1.5、什么时候使用静态

2个方面：

静态修饰的内容有成员变量和函数

什么时候定义静态变量？

 当对象在出现共享数据时，该数据被static修饰

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

什么时候定义静态函数
当功能内部没有访问到非静态数据（对象的特有数据）

那么该 功能可以定义成静态

1.6、静态工具类

package com.day06;/** * 建立一个用于操作数组的工具类， 其中包含着常见的对数组操作的函数， 如：最值，排序等。 *  * @author Denny * @version v1.0 */public class ArrayTool {/** * 为了不让外界创建对象，将构造方法私有化 * @author Denny *  * @version v1.0 */private ArrayTool() {}/** * 获取整型数组的最大值 *  * @param arr *            接收一个元素为int 类型的数组 * @Return 该数组的最大的元素值 */public static int getMax(int[] arr) {int maxIndex = 0;for (int x = 1; x < arr.length; x++) {if (arr[x] > arr[maxIndex])maxIndex = x;}return arr[maxIndex];}/** * 对数组进行选择排序 *  * @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);}}}// 用于给数组进行元素的位置置换。private static void swap(int[] arr, int a, int b) {int temp = arr[a];arr[a] = arr[b];arr[b] = temp;}/** * 获取指定的元素在指定数组中的索引 *  * @param arr *            接收一个元素为int 类型的数组 * @param key *            要找的元素 * @return 返回该元素第一次出现的位置，如果不存在则返回 -1 */public static int getIndex(int[] arr, int key) {for (int x = 0; x < arr.length; x++) {if (arr[x] == key)return x;}return -1;}/** * 将int数组转换成字符串，格式是：[e1,e2,...] *  * @param arr *            接收一个元素为int类型的数组 * @return 返回该数组的字符串表现形式 */public static String arrayToString(int[] arr) {String str = "[";for (int x = 0; x < arr.length; x++) {if (x != arr.length - 1)str = str + arr[x] + ",";elsestr = str + arr[x] + "]";}return str;}}

使用类名.静态方法

二、静态代码块

2.1、静态代码块

static{

代码块;

}

package com.day06;/** * 静态代码块 *  * @author Denny static{ 静态代码块中的语句 } *  特点：随着类的加载而执行， 只执行一次 用于给类进行初始化 *  并优先于主函数 */class StaticDemo {static {System.out.println("static code A");}}public class StaticCode{static {System.out.println("static code B");}static {System.out.println("static code C");}public static void main(String[] args) {//2个匿名对象new StaticDemo();new StaticCode();}}

结果：

static code B
static code C
static code A

只执行一次就不在执行了

三、对象初始化过程

3.1、初始化过程

<span style="font-size:14px;">package com.day06;/** * 静态代码块 *  * @author Denny  * static{ 静态代码块中的语句 }  * 特点：随着类的加载而执行， 只执行一次 用于给类进行初始化 并优先于主函数 */public class StaticCode {int num=9;public StaticCode() {System.out.println("static code A");}static {System.out.println("static code B");}{System.out.println("con code C  "+this.num);}public StaticCode(int num) {System.out.println("con code D");}public static void show(){System.out.println("E");}public static void main(String[] args) {new StaticCode(4);}}</span>

结果：

static code B
con code C  9
con code D

四、对象调用成员过程

4.1、初始化过程

1.因为new 用到了类.class，所以会先找到类.class

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

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

4.在堆内存中建立对象的特有属性，并默认初化成员变量

5.对对象进行显示初始化

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

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

8.将内存地址赋给内存中的对象变量

五、单例模式

设计模式：对问题行之有效的解决方式，其实，它是一种思想。

    单例设计模式解决的问题：就是可以保证一个类在内存中的对象唯一性。
    比如多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

    如何保证对象唯一性呢？
    1、不允许其他程序用new创建该类对象。
    2、在该类创建一个本类实例。
    3、对外提供一个方法让其他程序可以获取该对象。

    步骤：
    1、私有化该类构造函数。
    2、通过new在本类中创建一个本类对象。
    3、定义一个公有的方法，将创建的对象返回。

5.1、饿汉式

<span style="font-family:Microsoft YaHei;font-size:14px;">package com.day06;/** * 饿汉式 * @author denny * */public class SingleDemo {private String name;private int age;private static SingleDemo singleDemo=new SingleDemo();//私有 构造方法private SingleDemo(){}//提供公有的访问public static SingleDemo getNewIntance(){return singleDemo;}public static void main(String[] args) {SingleDemo s1=SingleDemo.getNewIntance();SingleDemo s2=SingleDemo.getNewIntance();System.out.println(s1==s2);}}</span>

结果：true

5.2、懒汉式

<span style="font-family:Microsoft YaHei;font-size:14px;">package com.day06;/** * 饿汉式 * @author denny * */public class SingleDemo2 {private String name;private int age;private static SingleDemo2 singleDemo2;//私有 构造方法private SingleDemo2(){}//提供公有的访问public static SingleDemo2 getNewIntance(){if(singleDemo2==null){singleDemo2=new SingleDemo2();}return singleDemo2;}public static void main(String[] args) {SingleDemo2 s1=SingleDemo2.getNewIntance();SingleDemo2 s2=SingleDemo2.getNewIntance();System.out.println(s1==s2);}}</span>

结果：true