JAVA--＞继承和多态详解(1)

JAVA–>继承和多态详解(1)

1.为什么需要继承?

实体之间具有很多相同的联系,如果通过将共性抽取为一个父类,只要是该实体则就只需要继承父类即可.而不用重复定义多次.

例:动物

//此为两个类
public class Dog{
	string name;
	int age;
	float weight;
	public void eat(){
		System.out.println(name + "正在吃饭");
	}
	public void sleep(){
		System.out.println(name + "正在睡觉");
	}
	void Bark(){
		System.out.println(name + "汪汪汪~~~");
	}
}

public class Cat{
	string name;
	int age;
	float weight;
	public void eat(){
		System.out.println(name + "正在吃饭");
	}
	public void sleep()
	{
		System.out.println(name + "正在睡觉");
	}
	void mew(){
		System.out.println(name + "喵喵喵~~~");
	}
}

通过观察发现猫和狗都具有很多相同的成员属性和成员方法.所以通过对共性的抽取,就出现了继承的概念.从而达到代码的复用.

2.继承的概念

是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

例子:猫 狗共性抽取出定义一个动物类.

3.继承的语法

修饰符 class 子类 extends 父类 {
	// ... 
}

//此为三个类
// Animal.java
public class Animal{
	String name;
	int age;
	public void eat(){
		System.out.println(name + "正在吃饭");
	}
	public void sleep(){
		System.out.println(name + "正在睡觉");
	}
}
public class Dog extends Animal{
	void bark(){
	System.out.println(name + "汪汪汪~~~");
	}
}

	public class Cat extends Animal{
	void mew(){
		System.out.println(name + "喵喵喵~~~");
	}
}

public class TestExtend {
	public static void main(String[] args) {
	Dog dog = new Dog();
	// dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
	System.out.println(dog.name);
	System.out.println(dog.age);
	// dog访问的eat()和sleep()方法也是从Animal中继承下来的
	dog.eat();
	dog.sleep();
	dog.bark();
	}
}

注意:

1. 子类会将父类中的成员变量或者成员方法继承到子类中

2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承

4.父类成员访问

4.1 子类中访问父类的成员变量

1. 子类和父类不存在同名成员变量

public class Base {
		int a;
		int b;
}
public class Derived extends Base{
	int c;
	public void method(){
		a = 10; // 访问从父类中继承下来的a
		b = 20; // 访问从父类中继承下来的b
		c = 30; // 访问子类自己的c
	}
}

2. 子类和父类成员变量同名

public class Base {
	int a;
	int b;
	int c;
}
	
public class Derived extends Base{
	int a; // 与父类中成员a同名，且类型相同
	char b; // 与父类中成员b同名，但类型不同
	public void method(){
		a = 100; // 访问父类继承的a，还是子类自己新增的a？
		b = 101; // 访问父类继承的b，还是子类自己新增的b?
		c = 102; // 子类没有c，访问的肯定是从父类继承下来的c
	// d = 103; // 编译失败，因为父类和子类都没有定义成员变量b
	}
}

说明:

在子类方法中 或者 通过子类对象访问成员时：

如果访问的成员变量子类中有，优先访问自己的成员变量。

如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。

如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

4.2 子类中访问父类的成员方法

1. 成员方法名字不同

public class Base {
	public void methodA(){
		System.out.println("Base中的methodA()");
	}
}

public class Derived extends Base{
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		methodB(); // 访问子类自己的methodB()
		methodA(); // 访问父类继承的methodA()
		// methodD(); // 编译失败，在整个继承体系中没有发现方法methodD()
	}
}

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

2. 成员方法名字相同

public class Base {
	public void methodA(){
		System.out.println("Base中的methodA()");
	}
	public void methodB(){
		System.out.println("Base中的methodB()");
	}
}

public class Derived extends Base{
	public void methodA(int a) {
		System.out.println("Derived中的method(int)方法");
	}
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		methodA(); // 没有传参，访问父类中的methodA()
		methodA(20); // 传递int参数，访问子类中的methodA(int)
		methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
	}
}

【说明】

通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。

通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错.

5.super关键字访问

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员

public class Base {
	int a;
	int b;
	public void methodA(){
		System.out.println("Base中的methodA()");
	}
	public void methodB(){
		System.out.println("Base中的methodB()");
	}
}

public class Derived extends Base {
	int a; // 与父类中成员变量同名且类型相同
	char b; // 与父类中成员变量同名但类型不同
		// 与父类中methodA()构成重载
	public void methodA(int a) {
		System.out.println("Derived中的method()方法");
	}
	// 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		// 对于同名的成员变量，直接访问时，访问的都是子类的
		a = 100; // 等价于： this.a = 100;
		b = 101; // 等价于： this.b = 101;
		// 注意：this是当前对象的引用
		// 访问父类的成员变量时，需要借助super关键字
		// super是获取到子类对象中从基类继承下来的部分
		super.a = 200;
		super.b = 201;
		// 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
		methodA(); // 没有传参，访问父类中的methodA()
		methodA(20); // 传递int参数，访问子类中的methodA(int)
		// 如果在子类中要访问重写的基类方法，则需要借助super关键字
		methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
		super.methodB(); // 访问基类的methodB()
	}
}

说明:

在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可。

【注意事项】

1. 只能在非静态方法中使用

2. 在子类方法中，访问父类的成员变量和方法