1.假设在类定义int类型成员变量年龄age，在构造方法使用的是a(age=a)，这样造成可读性比较差，所以需要将一个类中表示年龄的变量统一的命名，都声明为age。此时当成员变量和局部变量名一样导致在构造方法中无法访问对象的其他成员。，这时候在java程序中引用了这个this关键字。
2.this关键字可以为调用了方法的那个对象生成相应的地址，从而获得了对调用本方法的那个对象的引用。当方法需要访问类的成员变量时，就可以使用this引用指明要操作的对象。
3.解决成员变量和局部变量的名一样，我们可以使用this关键字去访问一个类的成员变量。
例如：
public class Person1 {
public String name;//成员变量--年龄
public int age;//成员变量--年龄
public Person1(String name, int age){
this.name = name;//为name属性赋值
this.age = age;//为age属性赋值
}
//say()方法
public void say(){
System.out.println("你好！我是" + this.name + "，今年" + this.age + "岁。");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Person1 p1 = new Person1("李华", 20);//创建第一个对象
Person1 p2 = new Person1("小名", 19);//创建第二个对象
p1.say();//调用对象的方法
p2.say();//调用对象的方法
}
}
输出的结果是：
- 你好！我是李华，今年20岁。
- 你好！我是小名，今年19岁。
上面代码中，构造方法的参数定义为(String name,int age)，它是一个局部变量，在类中定义了成员变量name和age，如果在构造方法使用name和age访问的是局部变量，在构造方法使用this.name和this.age的访问的是成员变量。
4.通过this关键字调用成员方法：
public class Person1 {
public String name;//成员变量--年龄
public int age;//成员变量--年龄
public Person1(String name, int age){
this.name = name;//为name属性赋值
this.age = age;//为age属性赋值
}
//print()方法
public void print() {
System.out.println("************************");
}
//say()方法
public void say(){
this.print();//调用方法
System.out.println("你好！我是" + this.name + "，今年" + this.age + "岁。");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Person1 p1 = new Person1("李华", 20);//创建第一个对象
Person1 p2 = new Person1("小名", 19);//创建第二个对象
p1.say();//调用对象的方法
p2.say();//调用对象的方法
}
}
输出的结果是：
- ************************
- 你好！我是李华，今年20岁。
- ************************
- 你好！我是小名，今年19岁。
上面代码中,通过this关键字调用成员方法，写了一个print()方法在say()放在中调用成员方法并输出。5.构造方法在实例化对象时被java虚拟机(JVM)自动调用，在程序不能像调用其他方法去调用构造方法，可以在构造方法中使用this([参数1，参数2，...,参数n])的方式来调用其他的构造方法。
例如：
public class Person2 {
public String name;
public int age;
//定义无参的构造方法
public Person2(){
System.out.println("无参构造方法被调用....");
}
//定义两个有参的构造方法
public Person2(String name,int age){
this();//调用无参的构造方法
this.name=name;
this.age=age;
System.out.println("你好!我叫"+this.name+"今年"+this.age+"岁!");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Person2 p=new Person2("李华",19);//实例化Person2对象
}
}
输出的结果是：
- 无参构造方法被调用....
- 你好!我叫李华今年19岁!
上面代码中，在实例化Person2对象后，调用了两个有参的构造方法，在这个方法中调用了无参的构造方法，并打印出”无参构造方法被调用....”，在实例化Person2对象中传入了参数的值，最后输出”你好!我叫李华今年19岁!”，这两个构造方法都被调用了。
二、单例模式
1.什么是单例模式
单例模式是：一个类当中只有一个实例，并且提供一个访问它的全局访问点。
2.单线程中，单例模式根据实例化对象时机不同，由两种经典实现分别是饿汉式单例和懒汉式单例。
3.饿汉式单例定义类的静态私有变量同时进行实例化
饿汉式单例案例：
public class Singleton {
// 自己创建一个对象
private static Singleton singleton = new Singleton();
// 私有的构造方法
private Singleton(){
}
// 提供返回这个对象的静态方法
public static Singleton getInstance() {
return singleton;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Singleton s1=Singleton.getInstance();
Singleton s2=Singleton.getInstance();
System.out.println(s1==s2);
}
}
输出的结果是：true
从上面的代码中，声明静态私有类变量，并且立马实例化，实例化一次。类的构造方法中使用private修饰，这样就不能在类的外部使用new来创建实例化对象。私有的构造方法，是为了防止外部实例化，如果想让类的外部获取类的实例对象，提供public中的getInstance()方法获取单例实例。
4.懒汉式单例就是延迟加载，等到需要使用的时候去创建实例，不是主动创建。
懒汉式单例案例
public class Singleton1 {
//声明私有变量
private static Singleton1 singleton1 = null;
// 私有的构造方法
private Singleton1() {
}
//提供返回这个对象的静态方法
public static Singleton1 getInstance() {
//被动创建，真正需要使用时才去创建
if (singleton1 == null) {
singleton1 = new Singleton1();
}
return singleton1;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Singleton1 s1=Singleton1.getInstance();
Singleton1 s2=Singleton1.getInstance();
System.out.println(s1==s2);
}
}
输出的结果是:true
从上面的代码中，单例实例被延迟加载，只要真正需要用到的时候才会实例化一个对象交给自己使用。
三、总结
本文主要介绍了this关键字、单例模式。
this关键字可以为调用了方法的那个对象生成相应的地址，从而获得了对调用本方法的那个对象的引用。当方法需要访问类的成员变量时，就可以使用this引用指明要操作的对象。
单例模式是一个类当中只有一个实例，并且提供一个访问它的全局访问点。通过饿汉式和懒汉式案例来理解这个单例模式的用法。希望大家通过本文的学习，对你有所帮助!
原文地址：https://mp.weixin.qq.com/s/MRTkNju_eRQb3ja08U8jpg
