Java基础记忆（类与对象02）

1.构造函数  

    1. 显示初始化，对对象进行初始化。

class Demo01{
    public static void main(String[] args){
        int age=20;                  //年龄
        String name="zhanghao";      //姓名
        Person p=new Person(age,name);      //构造方法
        System.out.println(p.name+","+p.age);  //输出

    }
}
class Person{
    int age;
    String name;
    public Person(int age,String name){    //全参构造
        this.age=age;                      //给对象赋予age值
        this.name=name;                    //给对象赋予name值
    }
}

    2. 构造代码块初始化。

    3.发现子类构造函数运行时，先运行了父类的构造函数。为什么呢?
        因为子类中所有的构造函数的第一行默认都有一个隐式的super();语句。
        调用本类中的构造函数用this(实参列表)语句。
        调用父类中的构造函数用super(实参列表)语句。
    4.为什么子类对象初始化都要先访问父类中的构造函数呢？
        因为子类继承了父类中的内容，所以创建对象时必须要先看父类是如何对内容进行初始化的。这就是子类的实例化过程。
注意：
    5.当父类中没有空参数构造函数时，子类需要通过显示定义super语句指定要访问的父类中的构造函数。
    6.用来调用父类构造函数的super语句，在子类构造函数中必须定义在第一行，因为父类的初始化要先完成。
    7.子类所有的构造函数中，至少保证要有一个构造函数要通过super调用父类构造函数。(构造子类对象，一定要先进行父类初始化一次)
问题：
    8.this和super用于调用构造函数，可以同时存在吗？
       不可以，因为他们只能定义在第一行。
    9.用于调用构造函数的this和super语句，为什么需要定义在第一行？
       因为初始化动作要先执行。
 

2.构造函数与普通函数 

    

    1. 一般函数是用于定义对象应该具备的功能。而构造函数定义的是，对象在调用功能之前，在建立时，应该具备的一些内容。也就是对象的初始化内容。

    2. 构造函数是在对象建立时由jvm调用, 给对象初始化。一般函数是对象建立后，当对象调用该功能时才会执行。

    3. 普通函数可以使用对象多次调用，构造函数就在创建对象时调用。

    4. 构造函数的函数名要与类名一样，而普通的函数只要符合标识符的命名规则即可。

    5.构造函数没有返回值类型。

注意6. 当类中没有定义构造函数时，系统会指定给该类加上一个空参数的构造函数。这个是类中默认的构造函数。当类中如果自定义 了构造函数，这时默认的构造函数就没有了。

       7.在一个类中可以定义多个构造函数，以进行不同的初始化。多个构造函数存在于类中，是以重载的形式体现的。因为构造函数的名称都相同。

3.成员变量和静态变量

    1. 名称上的区别：
           成员变量也叫实例变量(非静态变量)。
           静态变量也叫类变量。
    2. 内存存储上的区别：
           成员变量存储到堆内存的对象中。
           静态变量存储到方法区的静态方法区中。
    3. 生命周期不同：
           成员变量随着对象的创建而加载，随着对象的回收而消失。每创建一个对象,堆中的对象中就有一份实例变量
           静态变量随着类的加载而加载，随着类的消失而消失。无论创建多少对象,类变量仅在方法区中,并且只有一份
   4. 调用方法不同：
           成员变量只能被对象所调用。
           静态变量可以被对象调用，也可以被类名调用。
           所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

4.super关键字   

    1：主要存在于子类方法中，用于指向子类对象中父类对象。

    2：访问父类的属性 访问父类的函数 访问父类的构造函数

    3：子类的构造函数默认第一行会默认调用父类无参的构造函数，隐式语句super();

    4：在子类构造函数第一行通过super关键字调用父类任何构造函数。如果显式调用父类构造函数，编译器自动添加的调用父类无参数的构造就消失。构造函数间的调用只能放在第一行，只能调用一次。super()和this()不能同时存在构造函数第一行。

class Demo02{
	public static void main(String[] args){
		Zi z = new Zi();
		z.show();
	}
}
class Fu{
	int age = 50;//即使private，子类对象中也有。
    void Fu(){
        System.out.println("Fu......");
    }
    
}
class Zi extends Fu{
	int age = 20;
	void show(){
		int age = 21;
        super.Fu();                           //调用父类的函数
		System.out.println("age = "+age);     //与成员变量重名，没有this关键字
		System.out.println("age = "+this.age);//当本类的成员和局部变量同名用this区分。
		System.out.println("age = "+super.age);//当子父类中的成员变量同名用super区分父类。
        System.out.println("this: "+this);
		//System.out.println("super: "+super);//编译失败！super不是父类对象的引用。
	}
    
}

 5.覆盖(重写)

函数的两个特性：
    1.重载：本类中。overload。(参数个数 或者参数类型 或者参数顺序不同)
    2.覆盖：子类中。override。(是否能被外界访问到，是否静态，返回值类型，函数名，参数列表都一致)(又叫重写)
    什么时候使用覆盖操作？
    当对一个类进行子类的扩展时，子类需要保留父类的原有功能，但是子类在该功能存在特有内容时，就使用覆盖操作完成。
    覆盖的注意事项：
    1.子类方法覆盖父类方法，必须要保证权限大于等于父类权限。(public > 默认权限 > private)
      (父类private，子类public，不叫覆盖，因为原本的父类方法就无法访问，不符合覆盖定义)
    2.覆盖时，要么都静态，要么都不静态。 (静态只能覆盖静态，或者被静态覆盖)
      (并且，如果覆盖操作，子父类的方法都是静态的，则静态方法体中不可以使用this或者super，它俩是基于对象的，而静态成员先于对象存在)

class Demo03{
    public static void main(String[] args){
		iPhone p = new iPhone();
        p.call();
        p.message();
		p.show();
    }
}
//描述手机：打电话，发短信，来电显示。
class Phone{
	public void call(){}
	public void message(){}
	public void show(){
		System.out.print("打电话");
	}
}
//手机出新了，来电显示更给力。
class iPhone extends Phone{
	//定义了来电显示功能。注意了，父类已经定义了来电显示的功能，子类直接拿过来用就可以了。
	//但是如果,子类对功能的内容要有自己的定义。那就保留父类功能的声明，建立子类功能特有的内容：覆盖的应用。
    public void call(){
        System.out.println("视频电话");
    }
    public void message(){
        System.out.println("发彩色短信");
    }
	public void show(){
		//System.out.println("number");
		super.show();//如果show是静态的，不可以使用super。因为静态方法先于对象加载，没有对象存在，用类名亦可调用show，但是super必须有父类对象。
		System.out.print(" 多功能");
	}
}

6.静态变量、静态方法和静态块