黑马程序员—this关键字及单例设计模式

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

一、this关键字的应用
1.this看上去，是用于区分局部变量和成员变量同名情况。
  this代表本类对象，当前创建使用的对象
  this代表它所在函数所属对象的引用
  简单说：哪个对象在调用this所在的函数，this就代表哪个对象
eg:
class Person{
private String name; // 定义成员变量name
private int age;

Person(String name){ // 定义局部变量name
name = name;
}
Person(String name, int a){ // 定义局部变量name
this.name = name;
age = a;
}
public void speak(){
System.out.println("name="+name+",age="+age);
}
}
class PersonDemo1{
public static void main(String[] args){
Person p = new Person("zhangsan");
Person p1 = new Person("lisi",23);
p.speak();
p1.speak();
}
}
执行结果：
name=null,age=0
name=lisi,age=23


2.当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象
  但凡本类功能内部使用了本类对象，都用this表示。
eg：
Person类中定义如下函数：
public boolean compare(Person p){
return this.age==p.age;
}
主函数中：
Person p1 = new Person("lisi",23);
Person p2 = new Person("zhangsan",24);
boolean b = p1.compare(p2);
System.out.println(b);
执行结果：
false


3.this语句用于构造函数之间进行相互调用
  this语句只能定义在构造函数的第一行，因为初始化要先执行。
eg:
class Person{
private String name;
private int age;

Person(String name){
this.name = name;
}
Person(String name, int age){
this(name); // 注意写法
this.age = age;
}
public void speak(){
System.out.println("name="+name+",age="+age);
}
}




二、单例设计模式
用处：解决一个类在内存中只存在一个对象
解决方法：
1.为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象
  操作：将构造函数私有化
2.为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象
  操作：在类中创建一个本类对象
3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式
  操作：提供一个方法可以获取到该对象
方式1：饿汉式，先初始化，建议使用
class Single{
private Single(){}
private static final Single s = new Single();
public static Single getInstance(){
return s;
}
}
class SingleDemo{
public static void main(String[] args){
Single ss = Single.getInstance();
Single ss1 = Single.getInstance();
}
}
此时，s、ss与ss1指向堆内存同一地址


方式2：懒汉式，后初始化，延时加载，代码繁琐，不建议使用 
class Single{
private static Single s = null;
private Single(){}
public static Single getInstance(){
if(s==null){
s = new Single();
}
return s;
}
}
以上代码，当遇到多线程访问时，会存在安全隐患，如下：
public static Single getInstance(){
if(s==null){
————>假如某A线程进入，挂掉
————>此时某B线程进入，执行
s = new Single();
————>某B线程创建一个实例化对象，执行完毕，同时某A线程苏醒，也会执行s = new Single()并创建一个实例化对象
}
return s;
}
改进：
class Single{
private static Single s = null;
private Single(){}
public static synchronized Single getInstance(){
if(s==null){
s = new Single();
}
return s;
}
}


发现如此改进，会低效，所以又做如下改进，添加双重判断：
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;
}
}