JAVA基础知识点（三）--this，static，main函数，单例设计模式

一、this关键字：

this关键字代表了所属函数的调用者对象。

this关键字作用：

         1.如果存在同名成员变量与局部变量时，在方法内部默认是访问局部变量的数据，可以通过this关键字指定访问成员变量的数据。

         2.在一个构造函数中可以调用另外一个构造函数初始化对象。

 

this关键字要注意事项：

         1.存在同名的成员变量与局部变量时，在方法的内部访问的是局部变量(java 采取的是“就近原则”的机制访问的。)

         2.如果在一个方法中访问了一个变量，该变量只存在成员变量的情况下，那么java编译器会在该变量的前面添加this关键字。

 

class Animal{

         Stringname ;  //成员变量

         Stringcolor;

         publicAnimal(String n , String c){

                  name= n;

                  color= c;

         }

        

         //this关键字代表了所属函数的调用者对象

         publicvoid eat(){

                  //System.out.println("this:"+this);

                  Stringname = "老鼠"; //局部变量

                  System.out.println(name+"在吃...");//会输出老鼠在吃，改为this.name后输出成员变量（暂时没有）

         }

}

 

 this关键字调用其他的构造函数要注意的事项：

         1.this关键字调用其他的构造函数时，this关键字必须要位于构造函数中的第一个语句。

         2.this关键字在构造函数中不能出现相互调用的情况，因为是一个死循环。

 

class Student{

         intid;  //身份证

         Stringname;  //名字

         //目前情况：存在同名的成员变量与局部变量，在方法内部默认是使用局部变量的。

         publicStudent(int id,String name){  //一个函数的形式参数也是属于局部变量。

                  this(name);//调用了本类的一个参数的构造方法

                  this();//调用了本类无参的构造方法。

                  this.id= id; //局部变量的id给成员变量的id赋值

                  System.out.println("两个参数的构造方法被调用了...");

         }

         publicStudent(){

                  System.out.println("无参的构造方法被调用了...");

         }

         publicStudent(String name){

                  this.name= name;

                  System.out.println("一个参数的构造方法被调用了...");

         }

}

class Demo7

{

         publicstatic void main(String[] args)

         {

                  Students = new Student(110,"铁蛋");

                  System.out.println("编号："+s.id +" 名字：" + s.name);

 

/*会输出：    一个参数的构造方法被调用了...

无参的构造方法被调用了...

两个参数的构造方法被调用了...

编号：110名字：铁蛋

*/

                  Students2 = new Student("金胖子");

                  System.out.println("名字：" +s2.name);

        

/*会输出：    一个参数的构造方法被调用了...

名字：金三胖

*/

         }

}

二、static(静态\修饰符)

         1.static修饰成员函数:

         2.static修饰成员变量：如果有数据需要被共享给所有对象使用时，那么就可以使用static修饰。        

         静态成员变量的访问方式：

                 方式1：可以使用对象进行访问。

                                  格式：对象.变量名。

                 方式二：可以使用类名进行访问。

                                  格式：类名.变量名;

                 注意：

                          1.非静态的成员变量只能使用对象进行访问，不能使用类名进行访问。

                          2.千万不要为了方便访问数据而使用static修饰成员变量，只有成员变量的数据是真正需要被共享的时候才使用static修饰。              

                  static修饰成员变量的应用场景：如果一个数据需要被所有对象共享使用的时候，这时候即可好实用static修饰。

 class Student{

         Stringname;  //非静态成员变量

         static        String country  = "中国";    //静态的成员变量

         publicStudent(String name){

                  this.name= name;

         }

}

class Demo10 {

         publicstatic void main(String[] args)

         {

                  Students1 = new Student("狗娃");

                  Students2 = new Student("狗剩");      

                  System.out.println("国籍："+Student.country);    //输出国籍：中国

                  System.out.println("名字："+s1.name+"，国籍："+ s1.country);   //输出名字：狗娃，国籍：中国

                  System.out.println("名字："+s2.name+"，国籍："+ s2.country);   //输出名字：狗剩，国籍：中国

         }

}

 

三、main函数的详解：

public ：公共的。权限是最大，在任何情况下都可以访问。原因：为了保证让jvm在任何情况下都可以访问到main方法。

static:  静态。静态可以让jvm调用main函数的时候更加的方便。不需要通过对象调用。

void:  没有返回值。因为返回的数据是给 jvm，而jvm使用这个数据是没有意义的。所以就不要了。

main: 函数名。注意： main并不是关键字,只不过是jvm能识别的一个特殊的函数名而已。

arguments ：担心某些程序在启动需要参数。

 

 

 

四、单例设计模式：保证一个类在内存中只有一个对象。

模式：模式就是解决一类问题的固定步骤。

单例设计模式的步骤：       

饿汉单例设计模式

         1. 私有化构造函数。

         2. 声明本类的引用类型变量，并且使用该变量指向本类对象。

         3. 提供一个公共静态的方法获取本类的对象。

懒汉单例设计模式：

         1. 私有化构造函数。

         2. 声明本类的引用类型变量，但是不要创建对象，

         3. 提供公共静态的方法获取本类的对象，获取之前先判断是否已经创建了本类对象，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，然后再返回。

推荐使用：饿汉单例设计模式。 因为懒汉单例设计模式会存在线程安全问题，目前还不能保证一类在内存中只有一个对象。

 

//饿汉单例设计模式 ---->保证Single在在内存中只有一个对象。

class Single1{

         //声明本类的引用类型变量，并且使用该变量指向本类对象

         private static   Single s = new Single();

         //私有化构造函数

         private Single(){}

         //提供一个公共静态的方法获取本类的对象

         public       static  Single getInstance(){

                  return s;

         }

}

 

//懒汉单例设计模式 ---->保证Single在在内存中只有一个对象。

class Single2{

         //声明本类的引用类型变量，不创建本类的对象

         private static Single2 s;

         //私有化了构造函数

         private Single2(){}

         //

         public static Single2 getInstance(){

                  if(s==null){

                          s = new Single2();

                  }

                  return s;

         }

}