JavaSE06继承和多态

1.继承的好处

a、提高代码的维护性

b、有利于代码的管理

c、让类与类产生一种关系（多态的前提）

2.继承的初始化特点

* 子类继承父类，让父类先进行初始化，然后子类进行初始化(分层初始化)

* 构造方法的作用：给对象进行初始化

* 子类的有参构造和无参构造都要默认访问父类的无参构造，如果没有父类的无参构造，那么子类的构造方法会报错。

报错怎么解决？

a、提供一个无参构造 

b、通过super关键字访问父类的有参构造 super(" ") 

c、间接通过this()关键字

3.overload和override的区别：

overload（方法重载）：方法名相同，参数不同（参数个数不同   参数数据类型不同），与返回值没有任何关系

override：子类出现和父类一样的方法声明（权限修饰符 返回值类型 方法名）

4.继承的成员访问特点

成员变量：当子类继承父类，如果父类中的成员变量名称和父类中的成员变量名称不一致，就分别输出；如果名称一致：首先在子类的局部位置中找，如果找到，就输出；没有找到，就在子类的成员位置找，找到就输出，如果没有就去父类的成员位置找，有就输出。

成员方法：子类中的方法名和父类的方法名不同，分别调用；如果子类的方法名和父类的方法名一致，由于存在方法重写，执行子类的成员方法；子类没有这个方法，才会在父类中找，有就输出。

5.final  fianlly （异常类）finalize（常用类）三者的区别

final表示最终的，不可修改的（终态的）

final修饰类：该类不可被继承

final修饰成员方法：该方法不能被重写

final修饰局部变量：

 基本数据类型：如果局部变量是一个基本数据类型，那么被final修饰，基本数据类型的值不能再改变。

int num = 10  num = 100 ; //编译通过
final int num = 10; num = 100 ; // 编译不通过，报错

引用数据类型：如果final修饰引用数据类型的变量，那么它不能再重新分配堆内存空间，但是可以改变成员变量的值。

final Student  ss = new Student();//开辟栈内存，分配堆内存
ss.age = 10; //为成员赋值
System.out.println(ss.age);  //输出10
ss.age= 60; //为成员重新赋值
System.out.println(ss.age);  //输出60

ss = new Student();//编译会报错，因为不能重新分配堆内存空间

 6.多态

多态的概念：一个事物在不同时刻体现出来的不同状态

Animal a = new Cat();    <猫是动物>

多态的三个前提条件（缺一不可）：

a、必须有继承关系，如果没有继承关系就谈不上多态。

b、必须有方法重写（子类出现了和父类一样的方法声明）。

c、有父类引用指向子类对象：向上转型（使用父类对象）

7.多态的成员访问特点：

成员变量：编译看左，执行看左。

成员方法(非静态方法)：编译看左，运行看右（由于存在方法重写，所以就运行最终的就是子类的成员方法）

成员方法(静态方法)：算不上方法重写，静态直接跟类有关系，编译看左，执行看左。

构造方法：还是对对象进行初始化，由于是继承关系，还是分层初始化。

多态的好处：

a、提高代码的维护性（由继承保证）

b、提高代码的扩展性（由多态保证）

多态的弊端：不能访问子类特有功能

package org.zst.duotai;

	class Father{
		public void action(){
			System.out.println("父下围棋");
		}
	}
	class Son extends Father{
		public void action(){
			System.out.println("子下围棋");
		}
		public void show(){
			System.out.println("子周末上奥数班");
		}
	}
	public class DuoTaiDemo {
	public  static void main(String [] args){
		Father a = new Father();
		a.action();
		Father b = new Son();
		b.action();
		b.show();    //这行编译器会报错，多态不可以访问子类特有功能
		
	}
	

}

package org.zst.duotai;
	class Father{
		public void action(){
			System.out.println("父下围棋");
		}
	}
	class Son extends Father{
		public void action(){
			System.out.println("子下围棋");
		}
		public void show(){
			System.out.println("子周末上奥数班");
		}
	}
	public class DuoTaiDemo {
	public  static void main(String [] args){
		//Father a = new Father();
		//a.action();
		Father b = new Son();     //向上转型
		b.action();
		//b.show();	
		Son c = (Son)b;    //向下转型 ，向下转型必须依赖向上转型
		c.show();
	}
}

如何解决？

i:创建子类具体对象来访问自己的特有功能。虽然可以解决多态的弊端，但是从内存角度考虑，需要创建子类对象，那么必须在堆内存开辟空间。耗费内存，浪费空间。

package org.zst.duotai;
	class Father{
		public void action(){
			System.out.println("父下围棋");
		}
	}
	class Son extends Father{
		public void action(){
			System.out.println("子下围棋");
		}
		public void show(){
			System.out.println("子周末上奥数班");
		}
	}
	public class DuoTaiDemo {
	public  static void main(String [] args){
		Father a = new Father();
		a.action();
		Father b = new Son();
		b.action();
		//b.show();	
		//Son c = (Son)a;
		Son d = new Son();  //创建子类对象，但是耗费内存浪费空间
		d.show();
	}
}

ii:既然多态的第三个前提条件父类可以引用指向子类对象，那么子类的引用也可以指向父类对象，也就是向下转型。将父类的引用强制转化为子类的引用，前提是父类引用必须存在，向下转型必须依赖向上转型。（一般情况下，向下转型使用不当会造成一个异常：转化类异常，ClassCastException）。

package org.zst.duotai;
	class Father{
		public void action(){
			System.out.println("父下围棋");
		}
	}
	class Son extends Father{
		public void action(){
			System.out.println("子下围棋");
		}
		public void show(){
			System.out.println("子周末上奥数班");
		}
	}
	public class DuoTaiDemo {
	public  static void main(String [] args){
		Father a = new Father();
		a.action();
		Father b = new Son();
		b.action();
		//b.show();	
		Son c = (Son)a;
		c.show();
	}
}