黑马程序员——Java面向对象之构造方法、静态、this关键字

------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

第一讲  构造函数

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

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

    默认构造构造函数的权限是随着的类的变化而变化的。例如：如果类被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，运行结果截图如下：

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