day07_java面向对象+构造函数+this+static关键字

//构造函数：构建创造对象时调用的函数。作用：可以给对象进行初始化。

创建对象都必须要通过构造函数初始化。

 

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

 

一般函数和构造函数什么区别呢？

 

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。

一般函数：对象创建后，需要函数功能时才调用。

 

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

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

 

 

什么时候定义构造函数呢？

 

在描述事物时，该事物一存在就具备的一些内容，这些内容都定义在构造函数中。

 

构造函数可以有多个，用于对不同的对象进行针对性的初始化.

多个构造函数在类中是以重载的形式来体现的。

 

 

下面这两个也是重载的构造函数

Person(String n,int a)

    {

        name = n;

        age = a;      

    }

Person(int a,String
g)

    {

       

    }

 

构造函数-内存图解



构造函数细节：

1，构造函数如果完成了set功能。set方法是否需要。

2，一般函数不能直接调用构造函数。

3，构造函数如果前面加了void就变成了一般函数。

4，构造函数中是有return语句的。



当成员变量和局部变量重名，可以用关键字this来区分。

 

this : 代表对象。代表哪个对象呢？当前对象。

例如:

Person p1 = new Person("aa",30);

Person(String name,int age)

    {

        this.name = name;

        this.age = age;      

    }

那么这个this就是指的p1

       this就是所在函数所属对象的引用。

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

 

 

 

This的原理图



其实这里面省略了一个this，才知道是哪一个调用了这个对象

 

this也可以用于在构造函数中调用其他构造函数。

事例:

Person()

    {      

        name =
"baby";

        age = 1;

        System.out.println("person run");

    }  

    Person(Stringname) 

    {

        this();

        this.name = name;

    }

构造函数间调用.bmp



注意：只能定义在构造函数的第一行。因为初始化动作要先执行。

 

this关键字-应用一般在本类对象中调用本类对象的时候使用this

事例:

/*

    判断是否是同龄人。

    */

    public
boolean compare(Person p)

    {

        /*

        if(this.age==p.age)

            return true;

        else

            return false;

        */

         这个this就是指的p2

        return
this.age==p.age;

    }

 

Person p1 = new Person("aa",30);//

        Person p2 = new Person("zz",12);

 

        p2.compare(p1);



static关键字-数据共享

 

static的特点：

1，static是一个修饰符，用于修饰成员。

2，static修饰的成员被所有的对象所共享。

3，static优先于对象存在，因为static的成员随着类的加载就已经存在了。

4，static修饰的成员多了一种调用方式，就可以直接被类名所调用。 类名.静态成员 。

5，static修饰的数据是共享数据，对象中的存储的是特有数据。

class Person{

   // 这个叫做成员变量，还有实例变量，因为这个变量是随着对象的存在而存在在堆里面在,实例就是对象中的变量，成员变量是在堆里面，堆里面保存的全部是实例,对象存在name才存在

String name;

}

    String name;//成员变量，实例变量

    static String country =
"CN";//静态变量。类变量

 

 

成员变量和静态变量的区别？

1，两个变量的生命周期不同。

    成员变量随着对象的创建而存在，随着对象的被回收而释放。

    静态变量随着类的加载而存在，随着类的消失而消失。

 

2，调用方式不同。

    成员变量只能被对象调用。

    静态变量可以被对象调用，还可以被类名调用。

 

3，别名不同。

    成员变量也称为实例变量。

    静态变量称为类变量。

 

4，数据存储位置不同。

    成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.

    静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.

 

static关键字-注意事项

静态使用的注意事项：

1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)

为什么静态的不能访问非静态的成员也:

class Person

{

    String name;//成员变量，实例变量

    static String country =
"CN";//静态变量。类变量

    public static
void show()

    {

        System.out.println(Person.country+":"+name);

    }

你这个是静态吗，会先存在，那个时候没有对象，而这个name要放在对象中，name应该是随着对象的创建而存在，没有对象就没有name，当我调用show方法的时候，不能访问name里面的具体内容 

}

Class StaticDemo

{

Public static void main(String[] args)

{

Person p = new Person();

}

}

2，静态方法中不可以使用this或者super关键字。

为什么不可以使用this，因为this是指的对象，当我使用类名调用show()方法的时候也是不是没有对象，其实show里面的name是省略了this.name这个属性

3，主函数是静态的。

 

 

static关键字-main函数解析

 

/*

public static voidmain(String[] args)

 

主函数特殊之处：

1，格式是固定的。

2，被jvm所识别和调用。

 

public:因为权限必须是最大的。

static:不需要对象的,直接用主函数所属类名调用即可。

void：主函数没有具体的返回值。返回也是给虚拟机

main:函数名，不是关键字，只是一个jvm识别的固定的名字。

String[] args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

 

*/

 

class MainDemo

{

    public
static void main(String[] args)
//new String[0]

    {

        /**/

//      System.out.println(args);//[Ljava.lang.String;@c17164

        System.out.println(args.length);

        for(int x=0; x<args.length; x++)

            System.out.println(args[x]);

       

    }

}

如果我们要想给args里面传参数的话也可以这样传:java MainDemo haha hehe xixi

那么通过System.out.println(args.length);就是三

 

 

static关键字-内存图解



静态什么时候用？

1，静态变量。

    当分析对象中所具备的成员变量的值都是相同的。       

    这时这个成员就可以被静态修饰。

    只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

    如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

 

2，静态函数。

    函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。

    简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。

    如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，

    但是非静态需要被对象调用，而仅创建对象调用非静态的

    没有访问特有数据的方法，该对象的创建是没有意义。

 

*/

 

class Demo

{

    int
age ;

    static
int num = 9;

    Demo(int age)

    {

        this.age = age;

    }

 

    public
static  void speak()

    {

        System.out.println(num);

    }

    public
void show()

    {

        System.out.println(age);

    }

 

}

 

class  StaticDemo3

{

    public
static void main(String[] args)

    {

//      Demo d = new Demo(30);

//      d.speak();

        Demo.speak();

 

//      System.out.println("HelloWorld!");

    }

}

 

静态代码块:



这个的输出结果hahahah

               show run

              show run

不是所有的类都是通过构造函数进行初始化的，有些类是不需要创建对象就要初始化的



构造静态代码块:就说一说面试当中所涉及到的小内容

class Person

{

    private String
name;

    {//构造代码块。可以给所有对象进行初始化的。

 

        System.out.println("constructor code ");

//      cry();

    }

   

    static

    {

        System.out.println("static code");

    }

   

    Person()//是给对应的对象进行针对性的初始化。

    {

        name =
"baby";

//      cry();

    }

    Person(String name)

    {

        this.name  = name;

//      cry();

    }

    public
void cry()

    {

        System.out.println("哇哇");

       

    }

 

    public
void speak()

    {

        System.out.println("name:"+name);

    }

 

    static
void show()

    {

        System.out.println("show run");

    }

}

 

 

class StaticCodeDemo

{

    static

    {

        System.out.println("a");

    }

    public
static void main(String[] args)

    {

 

//      Person p = null;

//      p.speak();

 

        Person p1 = newPerson();

        p1.speak();

        Person p2 = newPerson("旺财");

        p2.speak();

        new Person();

    }

}

构造代码块跟对象有关

上面

Person p1 = new Person();

P1.speak();

Person p2 = newPerson("旺财");

P2.speak();

new Person();

那么输出结果就是:

首先如果有静态代码块先执行静态代码块，如果没有后执行构造代码块

a

static code

constructor code

name:baby

constructor code

name:旺财

constructor code