黑马程序员--Java面向对象之this、static和单例设计模式

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

一、this关键字

this代表所在函数所属对象的引用，换言之，this代本类对象的引用，正因为能代表本类对象的引用所以能区分局部变量和成员变量同名情况。

谁调用了this所在的函数this就代表哪个对象，但凡本类功能内部使用了本类功能都用this表示。

this还可以用于构造函数间的调用

格式：this（实际参数）

this对象后面跟上“.”调用的是成员属性和成员方法

this对象后面跟上“（）”调用的是本类中的对应参数的构造函数。

注意：this语句用于构造函数之间进行互相调用。用this调用构造函数必须定义在函数的第一行，因为构造函数用于初始化，所以初始化动作一定更要先执行，否则编译失败

class Person  
{  
    private String name;  
    private int age;  
    Person(int age)  
    {  
         this();//this语句 :用于构造函数之间进行互相调用。  
        this.age = age;  
    }  
    Person(String name)  
    {  
        this(name);  
        this.name = name;  
    }  
    Person(String name,int age)  
    {  
         this("hah");  
        this.name = name;  
        this.age = age;  
    }  
    public void speak()  
    {  
        System.out.println("name="+this.name+"...age="+this.age);  
        this.show();  
    }  
    public void show()  
    {  
        System.out.println(this.name);  
    }  
    /* 
    需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。 
    */  
    public boolean compare(Person p)  
    {  
        return this.age==p.age;  
    }  
}  
class PersonDemo3   
{  
    public static void main(String[] args)   
    {  
        Person p1 = new Person(20);  
        Person p2 = new Person(25);  
        boolean b = p1.compare(p2);  
        System.out.println(b);  
        Person p = new Person("lisi");  
        Person p1 = new Person("zhangsan");  
        p.speak();  
        p1.speak();  
        p.speak();  }  
}  

------------------------------------------------------------------------------------------------------------------------------

static：静态关键字

static是一个修饰符，用于修饰成员（成员变量和成员函数），被static修饰后除了可以被对象调用外还可以直接被类名调用

格式：类名.静态成员

特点：

1，static会随着类的加载而加载，生命周期最长。

2，优先于对象存在：静态是先存在的，而对象是后存在的

3，被对象共享，如果想实现对象中的共享数据，那可以将数据进行静态修饰

4，可以直接被类名调用

实际变量和类变量的区别：

1，成员变量属于对象，静态变量属于类

2，成员变量存在堆内存，静态变量存在方法区

3，成员变量随着对象创建而存在，而静态变量是随着类的加载而存在的

4，成员变量只能被对象调用，而静态变量不仅可以被对象调用还能被类名调用

综上所诉,区别在于两方面:存放位置和生命周期

静态的生命周期是最长的

注意事项:

1,静态方法只能访问静态成员。不可以访问非静态成员,非静态方法既可以访问静态也可以访问非静态。

2,静态方法中不可以定义this，super关键字

3,主函数是静态的

静态有利有弊

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

class Person  
{  
    String name;//成员变量，实例变量。  
    static String country = "CN";//静态的成员变量，类变量。  
    public static void show()  
    {  
        System.out.println("::::");  
        this.haha();  
    }  
    public void haha()  
    {}  
}  
class  StaticDemo  
{  
    public static void main(String[] args)   
    {  
        Person p = new Person();  
        p.name = "zhangsan";  
        p.show();  
        System.out.println(p.country);  
        System.out.println(Person.country);  
        Person.show();  
    }  
}   

如果成员变量里数据特有就不能用静态修饰,如果成员函数有特有数据,则不能被静态修饰

静态代码块

静态代码块：就是一个有静态关键字标示的一个代码块区域。定义在类中。

作用：可以完成类的初始化。静态代码块随着类的加载而执行，而且只执行一次（new 多个对象就只执行一次）。如果和主函数在同一类中，优先于主函数执行。

格式

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

静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块>构造代码块>构造函数；

使用静态的原因

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

2,当功能内部没有访问到肺静态数据(对象的特有数据)，那么该功能可以定义成静态的。

主函数
主函数：是一个特殊的函数。作为程序的入口，可以被JVM调用。
public static void main(String[] args)
 
主函数的定义：
public：代表着该函数访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被JVM识别。
（String[] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组.
JVM在调用主函数时，传递的实际参数的是new String[0];
主函数是固定格式的：JVM识别。
JVM默认传递的是长度为0的字符串数组，我们在运行该类时，也可以指定具体的参数进行传递。可以在控制台，运行该类时，在后面加入参数。参数之间通过空格隔开。JVM会自动将这些字符串参数作为args数组中的元素，进行存储。

生成Java帮助文档：命令格式：javadoc –d文件夹名 –auther –version *.java
/**     //格式
*类描述
*@author 作者名
*@version 版本号
*/
/**
*方法描述
*@param  参数描述
*@return  返回值描述
*/

--------------------------------------------------------------------------------------------------------------------------------------------

单例设计模式

设计模式的概念:解决某一类问题最行之有效的方法,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。java中有23种设计模式

单例设计模式：保证一个类在内存中的对象唯一性。即解决一个类在内存只存在一个对象。

Runtime()方法就是单例设计模式进行设计的。

单例模式的格式:

1，私有化构造函数；
2，创建私有并静态的本类对象；
3，定义公有并静态的方法，返回该对象。

单例模式的几种实现模式

1,饿汉式:

class Single  
{  
//私有化构造函数。    
private Single(){}  
//创建私有并静态的本类对象。  
    private static Single s = new Single();  
//定义公有并静态的方法，返回该对象。  
    public static Single getInstance()  
    {  
        return s;  
    }  
}  

2,懒汉式，对象是方法被调用时，才初始化，也叫做对象的延时加载。

class Single  
{  
    private static Single s = null;  
    private Single(){}  
    public static Single getInstance()  
    {  
        if(s==null)  
        {  
            synchronized(Single.class)// 由于对象不唯一了synchronized锁一样，解决方案，加上这个程序的效率就低了，  
            {                 
                if(s==null)  
                    s = new Single();  
            }  
        }  
        return s;  
    }  
}  

注意:

饿汉式和懒汉式的区别
饿汉式:Single类一进内存，就已经创建好了对象

懒汉式:Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象

实际开发式用饿汉式,面试时用懒汉式

懒汉式存在安全问题.在多线程的情况下
需要加锁.,但是效率不高.解决效率问题需要双重判断
懒汉式锁是该类所属的字节码文件对象。

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------

详情请查看：http://edu.csdn.net/heima