当我们需要使用Java语言对现实世界的实体进行描述,可以使用类来进行描述一个实体。但是现实世界错综复杂,实体与实体之间会存在一些关联,这就需要“继承”来将他们关联起来
目录
一、 引例
当我们描述一只狗与一只猫,代码如下
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("汪汪叫!");
}
}
class Cat{
String name;
int age;
float weight;
public void eat(){
System.out.println(name + "正在吃饭");
}
public void sleep()
{
System.out.println(name + "正在睡觉");
}
void miao(){
System.out.println(name + "喵喵喵~~~");
}
}
观察这两个类,容易看出他们之间存在很多重复的代码。那么如何将这些共性提取出来,从而减少相同的代码重复书写呢?面向对象的思想中提出了继承的思想,专门对这些共性进行提取,从而实现代码复用。
二、实现继承
继承(inheritance)机制:是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特 性
的基础上进行扩展,增加新功能,这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构, 体现了
由简单到复杂的认知过程。继承主要解决的问题是:共性的抽取,实现代码复用。
猫和狗都是动物,那么就可以将它们的共性提取出来。从而使用继承的思想来达到公用的目的。
通过之前的例子可以看到,猫和狗在属性的名字、年龄、体重,行为的吃和睡这些部分是相同的,那么我们将其抽取出来。
class Animal {
String name;
int age;
float weight;
public void eat(){
System.out.println(name+"在吃饭!");
}
public void sleep() {
System.out.println(name+"在睡觉!");
}
}
class Dog extends Animal {
public void bark() {
System.out.println(name+"汪汪叫!");
}
}
class Cat extends Animal{
public void miao(){
System.out.println(name+"喵喵叫!");
}
}
public class Test {
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.子类继承父类之后,必须要新添加自己特有的成员,体现出与基类的不同,否则就没有必要继承了
3.当子类和父类成员变量同名时,成员变量访问遵循就近原则,自己有优先自己的,如果没有则向父类中找。
①如果访问的成员变量子类中有,优先访问自己的成员变量。
②如果访问的成员变量子类中无,则访问父类继承下来的,如果父类也没有定义,则编译报错。 ③如果访问的成员变量与父类中成员变量同名,则优先访问自己的。
4.通过子类对象访问父类与子类同名方法时,如果父类和子类同名方法的参数列表不同(重载),根据调用方法适传递的参数选择合适的方法访问,如果没有则报错。
那么问题来了,我们子类存在与父类同名的成员,但是却需要在子类中访问父类的成员应该怎么办?
三、super关键字
由于设计不好,或者因场景需要,子类和父类中可能会存在相同名称的成员,如果要在子类方法中访问父类同名成员时,该如何操作?直接访问是无法做到的,Java提供了super关键字,该关键字主要作用:在子类方法中访问父类的成员。
class Base {
int a;
int b;
public void methodA(){
System.out.println("Base中的methodA()");
}
public void methodB(){
System.out.println("Base中的methodB()");
}
}
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()
}
}
注意:
1.在static修饰的类或方法当中不可以使用super。
2.当使用final修饰了一个类之后这个类就不可以被继承了。
四、子类构造方法
父子父子,先有父再有子,即:子类对象构造时,需要先调用基类构造方法,然后执行子类的构造方法。
class Base1 {
public Base1() {
System.out.println("Base()");
}
}
class Derived1 extends Base1 {
public Derived1() {
super();
// 注意子类构造方法中默认会调用基类的无参构造方法:super(),
// 用户没有写时,编译器会自动添加,而且super()必须是子类构造方法中第一条语句,
// 并且只能出现一次
System.out.println("Derived1()");
}
}
public class Test2 {
public static void main(String[] args) {
Derived1 d = new Derived1();
}
}
输出:
在子类构造方法中,并没有写任何关于基类构造的代码,但是在构造子类对象时,先执行基类的构造方法,然后执行子类的构造方法,因为:子类对象中成员是有两部分组成的,基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子,所以在构造子类对象时候 ,先要调用基类的构造方法,将从基类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整 。
总结
以上就是学习继承的总结,望大佬指正!!