覆写

概念

子类和父类有相同的成员方法（方法名，参数，返回值一样）。

为何使用

子类可以继承父类的方法，但想满足更多需求，不想用父类的方法。

覆写条件

覆写出现必须存在继承关系；方法名，参数列表，返回值必须相同；不能有更低的访问权限；不能有更宽泛的异常。

继承最基本的作用：代码重用；

继承最重要的功能：代码覆写；

package day10_test;public class Test {   	public static void main(String[] args) {   		// TODO Auto-generated method stub		Cat cat = new Cat();		cat.move();		Animal a1 = new Cat();		a1.move();		Animal a2 = new Dog();		a2.move();	}}class Animal{   	public void move(){   		System.out.println("动物在移动");	}}class Cat extends Animal{   	@Override	public void move(){   		System.out.println("猫在舞");	}}class Dog extends Animal{   	public void move(){   		System.out.println("狗在跑");	}}

覆写目的

满足当前需求；

错误越来越少；

使用范围越来愈广；

功能越来越强；

final

概念

final是修饰符，表示最终的，不能更改；不能被继承；修饰的成员方法不能被覆写；修饰的变量没有默认值，必须显式赋值，生命周期中不能更改。

常量一般写为public static final，常量命名建议全部大写

final class A{   // 报错 编译时异常 final类不能被继承	}class B extends A{   	}

class A{   	public final void m1(){   }}class B extends A{   	public void m1(){   }// 报错 编译时异常 final方法不能被覆写}

final int a;// 报错 需要显示赋值

易错点

package day10_test;public class Test_03 {   	public static void main(String[] args) {   		// TODO Auto-generated method stub		final User user = new User(22);		user.age = 24;		System.out.println(user.age);//		user = null;会报错，此处改null，就是改变user变量的值	}}class User{   	int age;	public User(int age){   		super();		this.age = age;	}}

final修饰的引用数据类型，以上代码为例，改变的是User，不是age，所以不会报错，改变User和改变User引用的堆内存中的数据不是一个概念。

多态（向上转型）

软件设计六大原则：
单一职责原则：一个方法只负责一件事；
里氏替换原则：能够使用父类的地方就能够使用子类(多态是里氏替换原则的一种体现)；
依赖倒置原则：和父类打交道，不需要管子类，依赖抽象不依赖具体实现；
接口隔离原则：类和类之间应该建立在最小接口上；
迪米特原则：一个对象应该对其他对象尽可能少地了解；
开闭原则：通过扩展实体解决需求变化，不是通过修改已经有的代码完成变化；

概念

同一消息（函数调用的时候），不同类的对象会有不同的行为方式。

package day10_test;public class Test_04 {   	public static void main(String[] args) {   		// TODO Auto-generated method stub		A a = new A();		m1(a);		B b = new B();		m1(b);	}	public static void m1(X x){   		x.m1();	}}class X{   	public void m1(){   }}class A extends X{   	public void m1(){   		System.out.println("A");	}}class B extends X{   	public void m1(){   		System.out.println("B");	}}

多态就是父类引用指向子类对象。

父类引用：使用父类类型创建的引用类型变量；
指向：通过这个引用类型变量，可以找到那个对象；
子类对象：创建的子类对象；
父类变量 = new 子类（）；

Java提供两种多态机制

编译时多态

编译时多态是静态的，主要指方法重载，通过不同参数列表区分不同的方法，编译后会形成不同的两个方法，运行时调用该方法就算多态了，因为调用的是两个方法。

运行时多态

运行时多态是动态的，主要是动态绑定实现，子类实现父类的方法来完成，这就是多态性。

多态的形式

多态丢失了子类特有的属性。

直接变量发生多态
父类变量 = new 子类（）

实参/形参
方法声明的时候，参数列表用父类声明，而调用方法的时候，传递的子类对象

public static void m1(Sup s){   m1(new Sub());}

返回值
返回值类型写的是父类，而具体返回的是子类对象

public Sup m1(){   return new Sub();}

使用多态进行属性调用，父类没有，编译时报错；父类有，子类没有，执行父类；父类有，子类也有，除了成员方法执行子类，其他执行父类。

隐秘多态

this发生多态；this可以调用当前类所有属性，所以一定不是父类类型，因为多态会丢失子类特有属性，所以this一定是当前类类型（this所在类就是当前类）。

通过子类对象调用父类方法的时候，父类的这个方法上下文环境就是多态对象。

向下转型

子类到父类是自动转换，父类到子类是强制转换，又叫向下转型，必须先向上转型才能向下转型。

instanceof判断某个对象是否由某个类实例化而来。

直接类型转换容易导致错误。

package day10_test;public class Test_05 {   	public static void main(String[] args) {   		// TODO Auto-generated method stub		Animal1 an = new Cat1();		an.m1();		Cat1 ca = (Cat1) an; //		ca.m1();		an.m1();		isAB(an);		isAB(ca);		Dog1 do1 = new Dog1();		isAB(do1);	}	public static void isAB(Object o){   		if(o instanceof Animal1){   			System.out.println("Animall");		}else if(o instanceof Cat1){   			System.out.println("Cat");		}else{   			System.out.println("No");		}	}}class Animal1{   	public void m1(){   //		System.out.println("a");	};}class Cat1 extends Animal1{   	public void m1(){   		System.out.println("cat");	}}class Dog1{   	public void m2(){   		System.out.println("Dog");	}}