继承（第二篇）

如果我不但想要输出局部变量定义的number,而且想要输出本类中和父类中定义的的number，如何做呢？

如以下代码：

class Ex{
	public int number = 100;
}

class Exson extends Ex{
	public int number = 200;
	public void show() {
		int number = 300;
		System.out.println(number);
		System.out.println(this.number);     //输出本类中的number
		System.out.println(super.number);    //输出父类中的number
	}
}
public class Example12 {
	public static void main(String[] args) {
		Exson s = new Exson();
		s.show();
	} 
}

this与super的区别：
    this代表本类对应的引用。
    super代表父类存储空间的标识。

用法：
    A:调用成员方法
        this.成员变量  调用本类的成员变量
        super.成员变量  调用父类的成员变量
    B:调用构造方法：
        this(......)   调用本类的构造方法
        super(......)   调用父类的构造方法

继承中构造方法的关系：
    A：子类中所有的构造方法默认都会访问父类中空咱数的构造方法。
    B：原因：
        因为子类会继承父类中的数据，可能还会使用父类的数据。
        所以，子类初始化之前，一定要先完成父类数据的初始化。

    注：子类每一个构造方法的第一条语句默认都是：super();

在子类继承父类时，若父类中没有无参构造方法，那么子类的构造方法会报错
    解决方案：
        A：在父类中加一个无参构造方法。
        B：通过使用super关键字去显示调用父类的带参构造方法。
        C：子类通过this去调用本类的其他的构造方法。
            子类中一定要有一个去访问父类的构造方法，否则父类的数据就没有            初始化。
    注：this(...)或者super(...)必须出现在第一条语句上，若不是，就可能对父类的数据进行了多    次初始化。

如下代码：

class Fa{
/*	public Fa() {
		System.out.println("老子的无参构造方法");
	}*/
	public Fa(String name) {
		System.out.println("老子的带参构造方法");
	}
}

class Fason extends Fa{
	public Fason() {
		super("随意给");
		System.out.println("儿子的无参构造方法");
	}
	public Fason(String name) {
		this();
		//super("随意给");
		System.out.println("儿子的带参构造方法");
	}
}
public class Example13 {
	public static void main(String[] arga) {
		Fason s = new Fason();
		Fason ss = new Fason("林青霞");
	}
}

一个类的初始化过程：
    成员变量的初始化
    默认初始化
    显示初始化
    构造方法初始化
    
    子父类的初始化（分层初始化）
        先进行父类初始化，然后进行子类初始化。

如以下代码：

class father11{
	father22 s = new father22();
	public father11() {
		System.out.println("X");
	}
}

class father22{
	public father22() {
		System.out.println("Y");
	}
}

class father33 extends father11{
	father22 s = new father22();
	public father33() {
		System.out.println("Z");
	}
}
public class Example14 {
	public static void main(String[] args) {
		father33 s = new father33();
	}
}


/**输出：
 * Y
 * X  
 * Y
 * Z
 * */

 

继承中成员方法的关系：
    A：子类中的方法和父类中的方法声明不一样。
    B：子类中的方法和父类中的方法声明一样时：
        通过子类调用方法：
            a：先找子类中，有就使用。
            b：再查看父类中，有就使用。
            c：如果都没有就报错。

如以下代码：

class one{
	public void show() {
		System.out.println("我是卡卡罗特");
	}
}

class two extends one{
	public void method() {
		System.out.println("我是贝吉塔");
	}
	public void show() {
		System.out.println("我是孙悟空");
	}
}

public class Example15 {
	public static void main(String[] args) {
		two s = new two();
		s.method();
		s.show();
	}
}

/**输出：
 * 我是贝吉塔
 * 我是孙悟空
 * */

方法重写的应用：
    方法重写：
        子类中出现了和父类中方法声明一模一样的方法。

    子类对象调用方法时：先找子类本身，再找父类。

    方法重写的应用：
        当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写父类中的方法，即沿袭了父类中的功能，又定义了子类特有的内容（用super实现）

如以下代码：

class one{
	public void show() {
		System.out.println("我是卡卡罗特");
	}
}

class two extends one{
	public void method() {
		System.out.println("我是贝吉塔");
	}
	public void show() {
		super.show();      //继承父类show()中信息
		System.out.println("我是孙悟空");
	}
}

public class Example15 {
	public static void main(String[] args) {
		two s = new two();
		s.method();
		s.show();
	}
}

/**输出：
 * 我是贝吉塔
 * 我是卡卡罗特
 *我是孙悟空
 * */

方法重写的注意事项：
    A：父类中私有方法不能被重写。(父类中的私有方法子类根本无法继承)
    B：子类重写父类方法时，访问权限不能更低。（public为最大访问权限）
    C：父类用静态方法，子类也必须用静态方法进行重写。
    注：子类重写父类方法的时候，最好声明一模一样。

Override(方法重写)和Overload(方法重载)的区别：
    方法重写：在子类中，出现和父类一模一样的方法声明的现象。
    方法重载：同一个类中，出现的方法名相同，参数列表不同的现象。

    方法重载能改变返回值类型，因为它和返回值类型无关。

方法重写会覆盖父类的功能，为了避免此类事情的发生，可以加入关键字：final

    final(最终的意思)：常见的是它可以修饰类，方法，变量。

    final的特点：
        A：可以修饰类，但该类不能够被继承
        B：可以修饰方法，被修饰后不能被重写。（覆盖，复写）
        C：可以修饰变量，不能够被重新赋值，因为这个变量其实就是常量。
        
    final修饰局部变量：
        基本类型：基本类型的值不能发生改变。
        引用类型：引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以        改变的。

如以下代码：

class dad{
	public final int age = 10;
}

class s{
	public int age = 10;
}
public class Example17 {
	public static void main(String[] args) {
		dad s = new dad();
		System.out.println(s.age);
		//s.age = 100;                      //报错
		System.out.println("--------------");
		final s ss = new s();
		System.out.println(ss.age);
		ss.age = 100;                        //此处不报错，输出为10   100
		System.out.println(ss.age);
		
		//ss = new s();                       //报错，不能为ss重新分配地址值
	}
}

final修饰变量的初始化时机：
    A：被final修饰的变量只能赋值一次。
    B：在构造方法完毕前。（非静态的常量）