码迷,mamicode.com
首页 > 其他好文 > 详细

基础学习day06---面向对象二---static,类的初始化和调用顺序、单例模式

时间:2015-09-10 12:58:01      阅读:162      评论:0      收藏:0      [点我收藏+]

标签:

一、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] + ",";
            else
                str = 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、初始化过程

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);

    }
}

 

 


结果:

 

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、饿汉式

 

 

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);

    }

}

 

 


结果:true

 

 

5.2、懒汉式

 

 

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);

    }

}

结果:true

 

基础学习day06---面向对象二---static,类的初始化和调用顺序、单例模式

标签:

原文地址:http://www.cnblogs.com/liunanjava/p/4788315.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!