Java面向对象之构造方法、静态、this关键字

第一讲  构造函数

    构造函数也叫构造方法，是方法名与类名相同，不用定义返回值类型，并且为对象进行初始化的特殊函数。对象一建立，就会调用与之对应的类的构造函数。

    当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。

    默认构造构造函数的权限是随着的类的变化而变化的。例如：如果类被public修饰，那么默认的构造函数也带public修饰符。

    但是当在类中自定义了构造函数后，默认的构造函数就没有了。 

构造函数和一般函数的区别：

    1、构造函数是在对象一建立时就运行，为对象初始化；而一般方法则是需要对象调用时才能执行，主要是为对象添加所具备的功能。 

    2、一个对象建立后，构造函数只运行一次；而一般方法可以被该对象调用多次。 

什么时候定义构造函数？

    当分析事物时，该事物存在具备一些特性或者行为，那么就可以将这些内容定义在构造函数中。 

构造代码块

作用：给对象进行初始化。

特点：对象一建立就运行，而且优先于构造函数执行。 

构造代码块和构造函数的区别：

    构造代码块中定义的是不同对象共性的初始化内容，给所有对象进行统一初始化；而构造函数是给对应的对象初始化。

例：

class PersonTest
{
      String name;
      int age;
      
     //构造代码块
     {
        System.out.println("构造代码块运行");
     }

     //无参数的构造函数
     PersonTest()
     {
       System.out.println("无参数的构造函数运行");
     }

     //有一个参数的构造函数
     PersonTest(String name)
     {
         System.out.println("有一个参数的构造函数运行");
     }
}

class PersonTestDemo
{
   public static void main(String[] args)
      {
          System.out.println("下面是建立第一个对象p1后的运行结果：");
          PersonTest p1 = new PersonTest();
          System.out.println();
          System.out.println("下面是建立第二个对象p2后的运行结果：");
          PersonTest p2 = new PersonTest("zhangsan");
      }
}

编译后运行结果如下：

    通过运行结果可以看出，每次创建好对象后，构造代码块中的内容都会被执行；而重载的其他构造函数，是在其所属的对象被创建时，才开始执行。

第二讲  this关键字

1、this关键字用于区分局部变量和成员变量同名情况。

    this代表它所在函数所属对象的引用，简单地说，哪个对象在调用this所在的函数，this就代表哪个对象。

    This关键字的应用：当定义类中功能（方法）时，并且该函数内部要用到调用该函数的对象，这时用this来表示这个对象。通俗的说就是，只要本类功能内部使用了本类对象，就用this关键字进行区分。

例：

class  Person
{   
    String name;  //定义成员变量（实例变量）
    int age;
    Person(String name,int age)   //定义构造函数
    {
       this.name=name;  //此处的this用于区分成员变量和局部变量
       this.age=age;     //此处的this用于区分成员变量和局部变量
    }
    public boolean Compare(Person p)
     {
         return this.age==p.age;   //此处的this表示调用该函数的对象
     }
}

class  ThisDemo
{
   public static void main(String[] args)
   {
      Person p1=new Person("zhangsan",30); //定义对象p1
      Person p2=new Person("lisi",36);     //定义对象p2
      boolean b=p1.Compare(p2);        //p1调用Compare函数，并把对象p2作为参数传递给Compare函数

 //输出结果
      if(b)
         System.out.println(p1.name+"与"+p2.name+"年龄相等");
      else
         System.out.println(p1.name+"与"+p2.name+"年龄不相等");
    
   }
}

2、this语句用于构造函数之间进行互相调用。

    this语句只能定义在构造函数的第一行，因为初始化要先执行。并且this()不能用用在一般函数中，只能用在构造函数间。

class  Person
{
    String name;   //定义成员变量
    int age;
    Person()      //构造方法
    {
     System.out.println("this()语句被执行");  //判断this()语句是否执行
    }

   Person(String name)     //构造方法
   {
      this();     //this语句只能放在构造函数的第一行
      this.name=name;
      System.out.println("在创建对象时this(name)语句被执行，"+"这里的this是"+this.name+"所属的对象");     

                //判断this(name)语句是否执行
   }
   
   Person(String name,int age)    //构造方法
   {
      this(name);      //this语句只能放在构造函数的第一行，调用构造函数 
      this.name=name;  
      this.age=age;   //此处this为关键字，表示调用该函数的对象，用于区分成员变量和局部变量
      
      System.out.println("我叫"+this.name+"我的年龄是"+this.age);  
      System.out.println();   
     
   }

}

class ThisDemo2
{
    public static void main(String[] args)  //主函数
	{
		Person p = new Person("zhangsan",30);  //创建对象
		Person p1 = new Person("lisi",36);
	}
}

此程序运行结果如下图所示：

    通过运行结果可以看出，this语句用在构造方法之间的相互调用；this关键字表示调用this所在函数的所属对象，用于区分局部变量和成员变量。

第三讲  静态

静态static的特点：

1、随着类的加载而加载；

2、被所有对象共享；

3、优先于对象存在；（比对象早开辟内存空间）

4、可以被类名直接调用；（类名.静态成员） 

实例变量（成员变量）和类变量（静态的成员变量）的区别：

1、存放位置不同

     类变量随着类的加载而在方法区（数据区或共享区）中开辟内存空间。

     实例变量则随着对象的建立而存在于堆内存中。

2、生命周期不同

     类变量的生命周期最长，随着类的消失而消失。

     实例变量生命周期随着对象的消失而消失。

静态方法的使用注意事项：

1、静态方法只能访问静态方法；

2、静态方法中不能定义this和super关键字；（因为静态是先于对象存在的，所以静态方法中不可以出现this关键字）

3、main方法是静态方法，所以调用其它方法有两种方式：一是通过创建对象，用对象调用非静态的方法；二是直接调用静态方法。

例：

class MainDemo2
{  
   public static void main(String[] args)
   {
         MainDemo2 T = new MainDemo2(); //创建对象
         T.Print();     //用对象调用非静态方法

         MainTest.Test();     //直接调用静态方法
        
   }
   
   public void Print()
   { 
      System.out.println("在main方法中用对象调用非静态的方法");
   }      
}

class MainTest
{
   public static void Test()
   {
      System.out.println("在Main方法中直接调用静态方法");
   }
}

什么时候定义静态变量（类变量）？

答：当对象中出现共享数据时，该数据被静态所修饰。 

什么时候定义静态函数？

答：当功能内部没有访问到非静态数据时，那么该功能就可以定义成静态的。

例1：

class Person
    {
       String  name;
       public static spesk() //函数中没有访问非静态数据的语句，所以可以直接定义成静态的方法  
         {
             System.out.println("Hello!");
         }
    }
      class Test
    {
       
       public static void main(String[] args)
         {
             Person p =new Person();  //创建对象
             p.speak();     //用对象调用静态方法
             
             Person.speak();   //直接调用静态方法，相当于上面的两句
         }
    }

例2：

class Person   {
       String  name;
       Person(String name)
       {
          this.name=name;
       }
       public void speak() //函数中有访问非静态数据的语句，所以不能定义成静态的方法  
         {
             System.out.println("Hello!"+name);  //name为非静态成员
         }
    }
      class Test
    {
       
       public static void main(String[] args)
         {
             Person p =new Person("zhangsan");  //创建对象
             p.speak(); //只能用对象调用该方法，不能直接调用该方法                       
         }
    }

静态有利有弊：

利处：对对象的共享数据进行单独空间的存储，没有必要每一个对象中都存储一份，从而节省内存空间；另外，静态成员（包括成员变量和成员方法）可以直接被类名调用，使代码更简洁。 

弊端：1、生命周期过长，容易产生内存垃圾；2、静态只能访问静态，从而使访问出现局限性。

静态代码快：用于给类进行初始化。

格式：

static

{

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

}

静态代码块的特点：随着类的加载而执行，只执行一次，并优先于主函数执行。

这个特点可以通过下面的例子看出：

class StaticCode
{
    //静态代码块
     static
         {
            System.out.println("c");
         }
}

class StaticCodeDemo
{
     //因为运行的是主函数所在的类，所以先执行本函数中的静态代码块。
     static
         {
             System.out.println("a");
         }

     public static void main(String[] args)
         {
              new StaticCode();  //打印a
              new StaticCode();  //不再打印a，因为第一次类StaticCode加载时已经开辟内存空间，不需要重复开辟。
              System.out.println("over");
         }
          
     static           
         {
             System.out.println("b");
         }
}

编译执行的输出顺序为：a，b，c，over，运行结果截图如下：

    以上是我通过学习传智播客毕向东老师的视频教程后，自己做的笔记和总结，如有不当之处，请各位大神多多指教！！