方法覆写、Final、多态

1. 方法覆写

1.1. 方法覆写的概念

Override : 方法覆写 , 子类覆写父类的方法 , 对父类的方法进行扩展

1 方法名相同 , 参数列表相同 , 返回值相同

2 不能比原方法有更低的访问权限 , 权限控制必须大于等于原方法

3 不能比原方法有更多的异常 , 不能恶化原方法 , 导致效果减弱

覆写的前提条件 : 必须有继承关系

Overload 方法重载 : 方法名相同参数列表不同,列表可以是个数不同或类型不同

当父类功能无法满足子类需求的时候 , 需要对父类的功能进行覆写

1.2. 方法覆写的用法

1.3. @Override

@Override : 是一种注解 , 是对源码的注解 , 编译之后就没有了

可写可不写 , 是一种提醒机制 , 防止代码因为操作失误而写错 , 导致该方法没有产生覆写

加上注解后如果不符合覆写条件 , 则会提醒报错

2. Final

2.1. Final的概念

final : 是修饰符 , 表示最终的 , 不能被修改

2.2. final的作用

final修饰的类 不能被继承

final 修饰的成员方法不能被覆写

final 修饰的变量 不能被二次调用 , 没有默认值 , 必须赋值

一般吧final修饰的静态变量叫做常量 , 也就是public Static final 数据类型 变量名 = 值;

2.3. final用法

public class Final_01 {
	final int a = 1;
	final static int b = 11;
	public static void main(String[] args) {
		final int i = 22;
	}
}
class Father2{
	public void m1() {
		
	}
}
final class son{
	public void m1() {
		
	}
}

2.4. 修饰引用类型

final修饰的引用类型变量, 变量值不能修改,但是变量指向的对象中的值,如果没有fianl修饰,是可以修改的

public class Final_02 {
	public static void main(String[] args) {
		final int age = 11;
		final User user = new User(16);
		user.age = 22;
	}
}
class User{
	int age;
	public User(int age) {
		super();
		this.age = age;
	}
}

3. 多态

3.1. 多态的概念

多态 polymorphic : 多种形态,相同功能,不同的对象有不同的状态

多态 : 父类引用指向子类对象

父类 : 长辈,直接父类,或者间接父类(爷爷、爷爷的爷爷....Object)

引用 : 指的引用数据类型

指向 : 就是可以找到谁

子类对象 : 创建了一个子类的实例化对象 new

使用父类类型创建的引用类型变量,可以找到子类对象

父类 变量名 = new 子类();

多态又叫向上转型 , 由子类 到父类 是向上 类似于自动类型转换

向下转型 , 由父类 到子类,类似于强制类型转换,但是 必须先发生向上转型之后,才能发生向下转型

3.2. 相关知识

里氏替换原则 : 能使用父类的地方,就一定可以使用子类

软件设计六大原则 : https://blog.csdn.net/u014681799/article/details/113888079

3.3. 应用场景

只要是一种情况对应多种不同实现的时候,一定要使用多态

3.4. 优点

降低耦合度,扩展性、替换性、维护性、灵活性增强

3.5. 缺点

丢失子类特有的属性

* 使用多态进行属性调用 :

*

* 1 子类特有的,调用不了,因为多态的缺点就是丢失子类特有的属性

*

* 2 成员方法 : 如果子类覆写了父类的成员方法,则调用子类的成员方法

*

* 3 非成员方法 : 调用父类的

3.6. 使用语法

public class Ploy_02 {
	public static void main(String[] args) {
		Father fa = new Son();
		//父类
		System.out.println(fa.age);
		//子类 , 因为子类被覆写
		fa.m1();
		//父类 , 因为子类没有进行覆写
		fa.m2();
		//调用不了 , 因为父类没有
//		fa.m3();
		Son son = (Son)fa;
		son.m3();
	}
}
class Father  {
	int age = 11;
	public void m1() {
		System.out.println("父类m1");
	}
	public void m2() {
		System.out.println("父类m2");
	}
}
class Son extends Father{
	int age = 22;
	public void m1() {
		System.out.println("子类m1");
	}
	public void m3() {
		System.out.println("子类m3");
	}
}

3.7. Instanceof

java.lang.ClassCastException: _07_Poly.Sup cannot be cast to _07_Poly.Sub

类型转换异常

* Instanceof : 判断 某个对象是否由每个类实例化而来

*

* 防止向下转型出现错误

public static void main(String[] args) {
    Sup sup = new Sub();
    // Sup sup = new Sup();
    Sub sub = null;
    System.out.println(sup instanceof Sub);
    if (sup instanceof Sub) {
        sub = (Sub) sup;
    }
    System.out.println(sub);
}

3.8. 多态的几种形式

//1 直接进行多态的写法

Father father = new Son();

//2 实参形参多态(方法的参数列表使用父类声明的局部变量 , 调用时传入子类对象)

m1(new Son());

//3 返回值多态 , 返回值类型使用父类声明 , return子类对象

Father father1 = m2();

public class Poly_04 {
	public static void main(String[] args) {
		//1 直接进行多态的写法
		Father father = new Son();
		//2 实参形参多态(方法的参数列表使用父类声明的局部变量 , 调用时传入子类对象)
		m1(new Son());
		//3 返回值多态 , 返回值类型使用父类声明 , return子类对象
		Father father1 = m2();
	}
	public static void m1(Father father) {
		//father是多态
	}
	public static Father m2() {
		return new Son();
	}
}

3.9. 隐式多态

通过子类对象,调用继承父类的成员方法时,此时上下文环境为多态环境

this : 是对象中第一个成员变量,保存当前对象的内存地址

this既然保存当前对象内存地址,那么this的类型 可以是当前类类型,可以是父类类型

this写在哪个类中,哪个类就是当前类 所以 当前类 是Father1 父类 是 Object

因为this能调用当前类中所有的属性,并没有丢失,所以this是Father1 当前类类型

this : 哪个对象调用这个成员方法,this就指向谁

public class Poly_05 {
	public static void main(String[] args) {
		Father1 father = new Father1();
		father.m1();
	}
}
class Father1{
	int age = 11;
	public void m1() {
		//
		System.out.println(this);
		System.out.println(this.age);
		System.out.println(age);
		m2();
		//因为隐藏多态 所以无法调用子类m3
//		m3();
		
	}
	public void m2() {
		System.out.println("父类m2");
	}
}
class Son1 extends Father1{
	int age = 22;
	public void m2() {
		System.out.println("子类m2");
	}
	public void m3() {
		System.out.println("子类m3");
	}
}