继承和多态
1.继承
1.1 继承的概念
继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。
例如：牛和狼都是动物，我们就可以把它们的共性抽取出来单独的写成一个动物类注意就可以减少一些代码的重复。
1.2 继承的语法
在JAVA中一个类想要继承另一个类就想要借助extends 关键字。
具体格式：
修饰符 class 子类 extends 父类 {
//...
}
我们对上边的牛和狼的例子用代码实现一下：
class Animal{
String name;
int age;
public void sleep(){
System.out.println(name + "正在睡觉");
}
}
class Wolf extends Animal {
public void fair() {
System.out.println(name+" 正在捕猎");
}
}
class Cow extends Animal {
public void eat() {
System.out.println(name+" 在吃草");
}
}
public class Text {
public static void main(String[] args) {
Wolf wolf = new Wolf();
// wolf类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
System.out.println(wolf.name);
System.out.println(wolf.age);
// wolf访问的sleep()方法也是从Animal中继承下来的
wolf.sleep();
wolf.fair();
}
}
注意：
- 子类会将父类中的成员变量或者成员方法继承到子类中了
- 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了
1.3 父类成员访问
1.3.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 } } -
子类和父类成员变量同名
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 } }
在子类方法中 或者 通过子类对象访问成员时：
1.如果访问的成员变量子类中有，优先访问自己的成员变量。
2.如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
3.如果访问的成员变量与父类中成员变量同名，则优先访问自己的
成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。
1.3.2 子类中访问父类的成员方法
-
成员方法名字不同
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() } } -
成员方法名字相同
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()，基类的无法访问到 } }
总结
1.通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到
则访问，否则编译报错。
2.通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用
方法适传递的参数选择合适的方法访问，如果没有则报错；
1.4 Super关键字
如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？
Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。
class Father {
int a;
int b;
public void methodA() {
System.out.println("Father中的methodA()");
}
public void methodB() {
System.out.println("Father中的methodB()");
}
}
class Son extends Father {
int a; // 与父类中成员变量同名且类型相同
char b; // 与父类中成员变量同名但类型不同
// 与父类中methodA()构成重载
public void methodA(int a) {
System.out.println("Son中的method()方法");
}
//与基类中methodB()构成重写
public void methodB() {
System.out.println("Son中的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.5 子类构造方法
子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。
public class Base {
public Base(){
System.out.println("Base()");
}
}
public class Derived extends Base{
public Derived(){
// super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
// 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
// 并且只能出现一次
System.out.println("Derived()");
}
}
public class Test {
public static void main(String[] args) {
Derived d = new Derived();
}
}
结果打印：
Base()
Derived
在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执
行子类的构造方法，因为：子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子
肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整
，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整
注意：
- 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构
造方法 - 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的
父类构造方法调用，否则编译失败。 - 在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
- super(…)只能在子类构造方法中出现一次，并且不能和this同时出现
2. 多态
多态的概念：就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。
2.1 多态实现条件
在java中要实现多态，必须要满足如下几个条件，缺一不可：
- 必须在继承体系下
- 子类必须要对父类中方法进行重写
- 通过父类的引用调用重写的方法
多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。
class Animal{
String name;
int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void eat(){
System.out.println(name + "正在吃饭");
}
}
class Wolf extends Animal {
public Wolf() {
}
public Wolf(String name, int age) {
super(name, age);
}
public void eat(){
System.out.println(name + "正在吃肉");
}
}
class Cow extends Animal {
public Cow() {
}
public Cow(String name, int age) {
super(name, age);
}
public void eat(){
System.out.println(name + "正在吃草");
}
}
public class Text {
// 编译器在编译代码时，并不知道要调用Wolf 还是 Cow 中eat的方法
// 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
// 注意：此处的形参类型必须时父类类型才可以
public static void eat(Animal a){
a.eat();
}
public static void main(String[] args) {
Animal animal1 = new Wolf("小灰灰",2);
Animal animal2 = new Cow("老黄",20);
eat(animal1);
eat(animal2);
}
}
运行结果：
当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的a 引用指向的是哪个类型(哪个子类)的实例. 此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为 多态
2.2 多态的优缺点
优点：
- 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
- 可扩展能力更强
缺点：代码的运行效率降低
253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
