黑马程序员------面向对象（二）

黑马程序员------面向对象（二）

1.1 构造函数

1.1.1特点：

1、函数名与类名相同

2、不用定义返回值类型

3、不可以写return语句

4、对象一建立就会调用与之对应的构造函数

 

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

 

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

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

3、多个构造函数是以重载的形式存在的。 

 

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

1、在写法上有不同，在运行上也有不同。

2、构造函数：在对象一建立就运行。给对象初始化。

3、一般方法：对象调用才执行，给是对象添加对象具备的功能。

4、构造函数：对象创建时，会调用并且只调用一次。

5、一般函数：对象创建后，可以被调用多次。

 

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

示例1：

class Person
{
    private String name ;
    private int age ;
    {
        //System.out.println("person run code" );//构造代码块
        cry();   
    }
    Person()//定义一个空参数的Person类构造函数
    {
        System.out.println("person run code" );
    }
    public void cry()
    {    
        System.out.println("........cry......");
    }
}

class PersonDemo
{
    public static void main(String[] args)
    {
        Person p = new Person();//创建对象并初始化
        p.cry();    
    }
}     

 

1.1.4构造代码块。

{
   语句
}

作用：给对象进行初始化。
对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别：
构造代码块是给所有对象进行统一初始化，
而构造函数是给对应的对象初始化.

构造代码快中定义的是不同对象共性的初始化内容。

 

 

2.1 this关键字：隐式参数，用于区分成员和局部变量的同名情况

this代表其所在函数所属对象的引用。换言之，this代本类对象的引用。

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

在普通方法中，this总是指向调用该方法的对象。

在构造方法中，this总是指向正要初始化的对象。

this不能用于static方法中。还可以用来调用其他的构造方法。

 

this关键字的应用。

在定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this表示这个对象，但凡本类功能内部使用到了本类对象，都用this表示。

this关键字在构造函数间调用：

this（）;用于构造函数间的调用。

通过this调用构造方法，必须位于第一句。

示例2：

class Person
{
    private String name ;
    private int age ;
 
    Person(String name)
    {
         this.name = name;//通过this区分成员变量和局部变量
    }
    
    Person(String name, int age)
    {
         //this用于在构造函数中调用其他构造函数
         this(name);
         this.age = age;
    }
     
    public void tell()
    {
        System.out.println(name + ":" + age );
    }
    /*
    需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。
    */
    public boolean compare(Person p)
    {
        return this.age==p.age;
    }
}

class staticDemo
{
    public static void main(String[] args)
    {
        Person p1 = new Person("不三" );
        p1.tell();
        Person p2 = new Person("不四" ,10);
        p2.tell();
    }
} 

 

注意：通过this在构造函数中调用其他构造函数的时候，只能定义在构造函数的第一行，因为初始化动作要先执行，否则就会报错。

 

 

3.1 static关键字

3.1.1 static特点：

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

也就说：静态会随着类的消失而消失。说明它的生命周期最长。

2、优先于的对象存在
明确一点：静态是先存在。对象是后存在的。

3、被所有对象所共享
4、可以直接被类名所调用。

 

3.1.2 实例变量和类变量的区别：
1，存放位置。
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2，生命周期：
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。

 示例3：

class Person
{
    String name;//成员变量，实例变量。
    static String country = "CN";//静态的成员变量，类变量,卑static修饰的属性为所有对象所共享
    public static void show()
    {
        System.out.println("::::");
        this.haha();
    }
    public void haha()
    {
    }
}

class  StaticDemo
{
    public static void main(String[] args) 
    {
        Person p = new Person();
        //p.name = "zhangsan";
        //p.show();

        //System.out.println(p.country);

        //System.out.println(Person.country);//用类名直接调用

        Person.show();
    }
}

 

3.1.3 静态使用注意事项：
1、静态方法只能访问静态成员。
非静态方法既可以访问静态也可以访问非静态。
2、静态方法中不可以定义this，super关键字。
因为静态优先于对象存在。所以静态方法中不可以出现this。
3、主函数是静态的。

 

4、静态方法只能访问静态成员，如果访问非静态成员，就会报错！（参考示例4）
    原因：静态方法和变量存在的时候，对象还不存在，非静态变量也不存在，肯定无法访问

示例4：

class Person
{
    String name;
    static String country = "CN";
    //静态方法
    public static void show()
    {
           System.out.println(country + ":" + name);
    }
}

 

 

3.1.4 静态有利有弊
利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
可以直接被类名调用。
弊端：生命周期过长。
访问出现局限性。(静态虽好，只能访问静态。)

 

3.1.5主函数：是静态的，是一个特殊的函数，作为程序的入口，可以被jvm调用。

主函数的定义：
public：代表着该函数访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
（String[] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

主函数是固定格式的：jvm识别。

jvm在调用主函数时，传入的是new String[0];

示例6：

class MainDemo 
{
    public static void main(String[] args)//new String[]
    {
        String[] arr = {"hah","hhe","heihei","xixi","hiahia"};

        MainTest.main(arr);
    }
}

 

3.1.6  静态什么时候用？

1. 静态变量(类变量)

当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。

       
 2. 静态函数

 

当功能内部没有访问到肺静态数据(对象的特有数据)，
那么该功能可以定义成静态的。

示例7：

class Person
{
    String name;
    static String country = "cn";
    public  static void show()
    {
        System.out.println(contry+"haha");    
    }

}


class  
{
    public static void main(String[] args) 
    {
        Person p = new Person();
        p.show();
        //Person .show();
    }

}

 

3.1.7 静态代码块

格式：
static
{
　　静态代码块中的执行语句。
}

特点：随着类的加载而执行，只执行一次,并优先于主函数。
用于给类进行初始化的。

示例8：

class StaticCode
{
    int num = 9;
    StaticCode()//构造代码块，可以给所有对象进行初始化的
    {
        System.out.println("b");
    }

    static
    {
        System.out.println("a");
    }
    {
        System.out.println("c"+this.num);
    }

    StaticCode(int x)
    {
        System.out.println("d");
    }
    public static void show()
    {
        System.out.println("show run");
    }
}

class StaticCodeDemo 
{
    static
    {
        //System.out.println("b");
    }
    public static void main(String[] args) 
    {
        new StaticCode(4);//a c d 
        //new StaticCode();
        //new StaticCode();
        //System.out.println("over");
        //StaticCode.show();
        //StaticCode s = null;
        //s = new StaticCode();

        //StaticCode.show();


    }
    static
    {
        ///System.out.println("c");
    }
}