一篇文章带你了解This关键字和单例模式

 一、this关键字

安国网站制作公司哪家好，找创新互联公司！从网页设计、网站建设、微信开发、APP开发、自适应网站建设等网站项目制作，到程序开发，运营维护。创新互联公司2013年至今到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联公司。

1.假设在类定义int类型成员变量年龄age，在构造方法使用的是a(age=a)，这样造成可读性比较差，所以需要将一个类中表示年龄的变量统一的命名，都声明为age。此时当成员变量和局部变量名一样导致在构造方法中无法访问对象的其他成员。，这时候在java程序中引用了这个this关键字。

2.this关键字可以为调用了方法的那个对象生成相应的地址，从而获得了对调用本方法的那个对象的引用。当方法需要访问类的成员变量时，就可以使用this引用指明要操作的对象。

3.解决成员变量和局部变量的名一样，我们可以使用this关键字去访问一个类的成员变量。

例如：

 
 
 
 
    
  
  
  
  
  1. public class Person1 {
    2. 
  
  
  
  
  2. public String name;//成员变量--年龄
    3. 
  
  
  
  
  3. public int age;//成员变量--年龄
    4. 
  
  
  
  
  4. public Person1(String name, int age){
    5. 
  
  
  
  
  5.         this.name = name;//为name属性赋值
    6. 
  
  
  
  
  6.         this.age = age;//为age属性赋值
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. //say()方法
    9. 
  
  
  
  
  9. public void say(){
    10. 
  
  
  
  
  10.     System.out.println("你好！我是" + this.name + "，今年" + this.age + "岁。");
    11. 
  
  
  
  
  11. }
    12. 
  
  
  
  
  12. public static void main(String[] args) {
    13. 
  
  
  
  
  13.     // TODO Auto-generated method stub
    14. 
  
  
  
  
  14.     Person1 p1 = new Person1("李华", 20);//创建第一个对象
    15. 
  
  
  
  
  15.     Person1 p2 = new Person1("小名", 19);//创建第二个对象
    16. 
  
  
  
  
  16.     p1.say();//调用对象的方法
    17. 
  
  
  
  
  17.     p2.say();//调用对象的方法
    18. 
  
  
  
  
  18.     }
    19. 
  
  
  
  
  19. }
    20.

输出的结果是：

 
 
 
 
    
  
  
  
  
  1. 你好！我是李华，今年20岁。
    2. 
  
  
  
  
  2. 你好！我是小名，今年19岁。
    3.

上面代码中，构造方法的参数定义为(String name,int age)，它是一个局部变量，在类中定义了成员变量name和age，如果在构造方法使用name和age访问的是局部变量，在构造方法使用this.name和this.age的访问的是成员变量。

4.通过this关键字调用成员方法：

 
 
 
 
    
  
  
  
  
  1. public class Person1 {
    2. 
  
  
  
  
  2. public String name;//成员变量--年龄
    3. 
  
  
  
  
  3. public int age;//成员变量--年龄
    4. 
  
  
  
  
  4. public Person1(String name, int age){
    5. 
  
  
  
  
  5.         this.name = name;//为name属性赋值
    6. 
  
  
  
  
  6.         this.age = age;//为age属性赋值
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. //print()方法
    9. 
  
  
  
  
  9. public void print() {
    10. 
  
  
  
  
  10. System.out.println("************************");
    11. 
  
  
  
  
  11. }
    12. 
  
  
  
  
  12. //say()方法
    13. 
  
  
  
  
  13. public void say(){
    14. 
  
  
  
  
  14. this.print();//调用方法
    15. 
  
  
  
  
  15.     System.out.println("你好！我是" + this.name + "，今年" + this.age + "岁。");
    16. 
  
  
  
  
  16. }
    17. 
  
  
  
  
  17. public static void main(String[] args) {
    18. 
  
  
  
  
  18.     // TODO Auto-generated method stub
    19. 
  
  
  
  
  19.     Person1 p1 = new Person1("李华", 20);//创建第一个对象
    20. 
  
  
  
  
  20.     Person1 p2 = new Person1("小名", 19);//创建第二个对象
    21. 
  
  
  
  
  21.     p1.say();//调用对象的方法
    22. 
  
  
  
  
  22.     p2.say();//调用对象的方法
    23. 
  
  
  
  
  23.     }
    24. 
  
  
  
  
  24. }
    25.

输出的结果是：

 
 
 
 
    
  
  
  
  
  1. ************************
    2. 
  
  
  
  
  2. 你好！我是李华，今年20岁。
    3. 
  
  
  
  
  3. ************************
    4. 
  
  
  
  
  4. 你好！我是小名，今年19岁。
    5.

上面代码中,通过this关键字调用成员方法，写了一个print()方法在say()放在中调用成员方法并输出。5.构造方法在实例化对象时被java虚拟机(JVM)自动调用，在程序不能像调用其他方法去调用构造方法，可以在构造方法中使用this([参数1，参数2，...,参数n])的方式来调用其他的构造方法。

例如：

 
 
 
 
    
  
  
  
  
  1. public class Person2 {
    2. 
  
  
  
  
  2. public String name;
    3. 
  
  
  
  
  3. public int age;
    4. 
  
  
  
  
  4. //定义无参的构造方法
    5. 
  
  
  
  
  5. public Person2(){
    6. 
  
  
  
  
  6.     System.out.println("无参构造方法被调用....");
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. //定义两个有参的构造方法
    9. 
  
  
  
  
  9. public Person2(String name,int age){
    10. 
  
  
  
  
  10.     this();//调用无参的构造方法
    11. 
  
  
  
  
  11.     this.name=name;
    12. 
  
  
  
  
  12.     this.age=age;
    13. 
  
  
  
  
  13.     System.out.println("你好!我叫"+this.name+"今年"+this.age+"岁!");
    14. 
  
  
  
  
  14.     
    15. 
  
  
  
  
  15. }
    16. 
  
  
  
  
  16. public static void main(String[] args) {
    17. 
  
  
  
  
  17.     // TODO Auto-generated method stub
    18. 
  
  
  
  
  18.     Person2 p=new Person2("李华",19);//实例化Person2对象
    19. 
  
  
  
  
  19.     }
    20. 
  
  
  
  
  20. }
    21.

输出的结果是：

 
 
 
 
    
  
  
  
  
  1. 无参构造方法被调用....
    2. 
  
  
  
  
  2. 你好!我叫李华今年19岁!
    3.

上面代码中，在实例化Person2对象后，调用了两个有参的构造方法，在这个方法中调用了无参的构造方法，并打印出”无参构造方法被调用....”，在实例化Person2对象中传入了参数的值，最后输出”你好!我叫李华今年19岁!”，这两个构造方法都被调用了。

二、单例模式

1.什么是单例模式

单例模式是：一个类当中只有一个实例，并且提供一个访问它的全局访问点。

2.单线程中，单例模式根据实例化对象时机不同，由两种经典实现分别是饿汉式单例和懒汉式单例。

3.饿汉式单例定义类的静态私有变量同时进行实例化

饿汉式单例案例：

 
 
 
 
    
  
  
  
  
  1. public class Singleton {
    2. 
  
  
  
  
  2. // 自己创建一个对象
    3. 
  
  
  
  
  3. private static Singleton singleton = new Singleton();
    4. 
  
  
  
  
  4. // 私有的构造方法
    5. 
  
  
  
  
  5. private Singleton(){
    6. 
  
  
  
  
  6. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. // 提供返回这个对象的静态方法
    9. 
  
  
  
  
  9. public static Singleton getInstance() {
    10. 
  
  
  
  
  10.     return singleton;
    11. 
  
  
  
  
  11. }
    12. 
  
  
  
  
  12. public static void main(String[] args) {
    13. 
  
  
  
  
  13.     // TODO Auto-generated method stub
    14. 
  
  
  
  
  14.     Singleton s1=Singleton.getInstance();
    15. 
  
  
  
  
  15.     Singleton s2=Singleton.getInstance();
    16. 
  
  
  
  
  16.     System.out.println(s1==s2);
    17. 
  
  
  
  
  17.     }
    18. 
  
  
  
  
  18. }
    19.

输出的结果是：true

从上面的代码中，声明静态私有类变量，并且立马实例化，实例化一次。类的构造方法中使用private修饰，这样就不能在类的外部使用new来创建实例化对象。私有的构造方法，是为了防止外部实例化，如果想让类的外部获取类的实例对象，提供public中的getInstance()方法获取单例实例。

4.懒汉式单例就是延迟加载，等到需要使用的时候去创建实例，不是主动创建。

懒汉式单例案例

 
 
 
 
    
  
  
  
  
  1. public class Singleton1 {
    2. 
  
  
  
  
  2. //声明私有变量
    3. 
  
  
  
  
  3. private static Singleton1 singleton1 = null;
    4. 
  
  
  
  
  4. // 私有的构造方法
    5. 
  
  
  
  
  5. private Singleton1() {
    6. 
  
  
  
  
  6. }
    7. 
  
  
  
  
  7. //提供返回这个对象的静态方法
    8. 
  
  
  
  
  8. public static Singleton1 getInstance() {
    9. 
  
  
  
  
  9.     //被动创建，真正需要使用时才去创建
    10. 
  
  
  
  
  10.     if (singleton1 == null) {
    11. 
  
  
  
  
  11.     singleton1 = new Singleton1();
    12. 
  
  
  
  
  12.     }
    13. 
  
  
  
  
  13.     return singleton1;
    14. 
  
  
  
  
  14. }
    15. 
  
  
  
  
  15. public static void main(String[] args) {
    16. 
  
  
  
  
  16.     // TODO Auto-generated method stub
    17. 
  
  
  
  
  17.     Singleton1 s1=Singleton1.getInstance();
    18. 
  
  
  
  
  18.     Singleton1 s2=Singleton1.getInstance();
    19. 
  
  
  
  
  19.     System.out.println(s1==s2);
    20. 
  
  
  
  
  20.     }
    21. 
  
  
  
  
  21. }
    22.

输出的结果是:true

从上面的代码中，单例实例被延迟加载，只要真正需要用到的时候才会实例化一个对象交给自己使用。

三、总结

本文主要介绍了this关键字、单例模式。

this关键字可以为调用了方法的那个对象生成相应的地址，从而获得了对调用本方法的那个对象的引用。当方法需要访问类的成员变量时，就可以使用this引用指明要操作的对象。

单例模式是一个类当中只有一个实例，并且提供一个访问它的全局访问点。通过饿汉式和懒汉式案例来理解这个单例模式的用法。希望大家通过本文的学习，对你有所帮助!

本文转载自微信公众号「 Java进阶学习交流」，可以通过以下二维码关注。转载本文请联系 Java进阶学习交流公众号。

网页标题：一篇文章带你了解This关键字和单例模式
路径分享：http://www.mswzjz.cn/qtweb/news2/148602.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

企业网站制作知识

分类信息网

成都网站建设　　 　兴宏源活动板房　　 　成都商城开发　　 　网站建设改版　　 　seo推广公司　　 　成都免费建站　　 　广安网站建设　　 　Google外贸推广　　 　成都广告公司　　 　成都公司注册　　 　香港云空间　　 　贵州义龙电信机房　　 　成都网站营销推广　　 　简阳网站建设　　 　LED显示屏　　 　网站空间　　 　圣月阀门　　 　手机网站开发　　 　重庆网站建设　　 　微信公众号二次开发