> 文档中心 > 【JavaSE系列】第八话 —— 继承和它的边角料们

【JavaSE系列】第八话 —— 继承和它的边角料们

☕目录☕

 🍕思维导图

  🍟一、引出继承

  🍔二、继承的概念

  🧇三、继承的语法

  🌭四、父类成员访问

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

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

  🍞五、super 关键字

              🥐🥐5.1 super.成员变量

              🧀🧀5.2 super.成员方法

              🍖🍖5.3 super.构造方法

  🥩六、继承方式

  🍱七、final关键字

  🍰八、继承与组合

 🍚写在最后


思维导图


一、引出继承

       Java中 使用类 对 现实世界中的实体进行描述;

       类经过实例化以后的产物 对象,则可以用来表示现实中的实体;

       但是,在现实生活中,某些实体与实体之间 具有相同的属性;

      

       比如说,上面的小猫和小狗,就具有一个共性:它们都是动物;

       如果用Java语言来描述小猫和小狗,那么就可以这样来设计:

//定义一个Cat类class Cat {    public String name;    public  int age;    public String sex;    public void eat() { System.out.println(this.name+"吃饭");    }    public void mew(){ System.out.println(this.name+"喵喵叫");    }}

//定义一个Dog类class Dog {    public String name;    public  int age;    public String sex;    public void eat() { System.out.println(this.name+"吃饭");    }    public void bark(){ System.out.println(this.name+"汪汪叫");    }}

       很明显,Cat类 和 Dog类 有许多一样的属性;

       那么,能不能将这些共性给抽取出来呢?

       在面向对象的过程中,提出了 继承 的概念;

       专门用来进行 共性抽取,实现 代码复用。


二、继承的概念

继承机制:

       是面向对象程序设计 是代码可以复用的最重要的手段;

       它允许程序员在保持原有类的特性 的基础上 进行扩展,增加新功能,这样产生新的类,称为 派生类;

       继承体现了 面向对象程序设计的层次结构,体现了由简单到复杂的认知过程;

       继承 主要解决的问题是:共性的抽取,实现代码复用。

       例如,上面的小猫和小狗的例子,我们可以把它们的共性抽取出来,然后把这些抽取出来的共性重新放到一个类当中:

 public String name;    public  int age;    public String sex;    public void eat() { System.out.println(this.name+"吃饭");    }

 此时,可以通过 关键字extends 构成一个继承关系:

 

 


三、继承的语法

//修饰符可以省略,也可以不用省略[修饰符] class 子类 extends 父类 { //继承的成员变量或方法}

【注意】

  1. 子类 会将父类中的成员变量或者成员方法 给继承到子类中;
  2. 子类继承父类之后,需要添加自己特有的成员,体现出与父类的不同,否则就没有必要继承了。 

       所以,对上面的例子 可以使用 继承 的方式来设计:

class Animal {    public String name;    public  int age;    public String sex;    public void eat() { System.out.println(this.name+"吃饭");    }    public void sleep(){ System.out.println("睡觉");    }}//Cat类class Cat extends Animal{    public void mew(){ System.out.println(this.name+"喵喵叫");    }}//Dog类class Dog extends Animal{    public void bark(){ System.out.println(this.name+"汪汪叫");    }}public class TestDemo {    public static void main(String[] args) { Cat cat = new Cat(); cat.name = "喵喵"; cat.eat(); cat.mew(); Dog dog = new Dog(); dog.name = "汪汪"; dog.sleep(); dog.bark();    }}


四、父类成员访问

       在继承体系中,子类将父类中的方法和字段继承下来了;

       那在子类中能否直接访问 父类中继承下来的成员呢?

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

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

class Base{    public int a = 1;    public int b = 2;}class Derived extends Base {    public int c = 3;    public int d = 4;    public void test(){ System.out.println(a); System.out.println(b); System.out.println(c); System.out.println(d);    }}public class TestDemo2 {    public static void main(String[] args) { Derived derived = new Derived(); derived.test();    }}

画图示例:

结果示例:

2.子类和父类 成员变量存在同名情况

class Base3{    public int a = 1;    public int b = 2;}class Derived3 extends Base3 {    public int a = 3;    public int d = 4;    public void test(){ System.out.println("a = "+a); System.out.println("b = "+b); System.out.println("d = "+d);    }}public class TestDemo3 {    public static void main(String[] args) { Derived3 derived3 = new Derived3(); derived3.test();    }}

结果示例:

【结论】

       由图可以看出,父类和子类都有相同的成员变量a,而最终打印的结果是 子类成员变量a 的值;

       这就说明:如果 子类和父类的成员变量重名,那么 优先访问子类的成员变量;

       这也可以理解,继承嘛,当自己的意志和父类的意志有冲突的时候,优先考虑一下自己的意志嘛!

       那么,如果实在想访问父类的成员变量,很简单,使用关键字super;

       这个会在下面详细的介绍。

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

1.子类和父类 成员方法 不存在同名的情况

class Base3{ public void method(){ System.out.println("Base3:method");    }}class Derived3 extends Base3 {    public void method2(){ System.out.println("Derived3:method2");    }    public void test(){ method(); method2();}public class TestDemo3 {    public static void main(String[] args) { Derived3 derived3 = new Derived3(); derived3.test();    }

结果示例:

【总结】成员方法没有同名时,子类优先访问;如果子类没有所需的成员变量和成员方法,而父类也没有,那么程序将会报错。 

2. 子类和父类 成员方法 存在同名的情况

class Base3{    public void method(){ System.out.println("Base3:method");    }}class Derived3 extends Base3 {    public void method(int a){ System.out.println("Derived3:method2 "+a);    }    public void test(){ method(); method(100);    }}public class TestDemo3 {    public static void main(String[] args) { Derived3 derived3 = new Derived3(); derived3.test();    }}

结果示例:

【说明】

  1. 通过子类对象访问父类与子类中 不同名方法时,优先在子类中找,找到则访问;否则在父类中找,找到则访问;否则程序编译报错;
  2. 通过 子类 访问 父类与子类同名方法时,如果父类和子类 同名方法的参数列表不同(重载),根据调用方法 适传递的参数选择合适的方法访问,如果没有则报错;如果父类和子类 同名方法的原型一致(重写-后面会介绍的),这只能访问到子类的,父类的无法通过子类对象直接访问到。 

 


五、super 关键字

       由于设计不好,或者因场景需要,子类和父类 可能会存在相同名称的成员;

       如果要在子类中访问父类同名成员时,那么应该怎么访问呢?

       直接访问是无法做到的;

       Java中提供了super关键字,该关键字的主要作用:在子类方法中访问父类的成员。

5.1 super.成员变量

5.2 super.成员方法

5.3 super.构造方法

 下面请看一段代码:

package Demo1;class Animal {    public String name;    public int age;    public void eat() { System.out.println(this.name + "正在吃饭");    }}class Cat extends Animal {    public String hair;    public void mew() { System.out.println(this.name + "正在叫");    }}public class Test {    public static void main(String[] args) { Cat cat1 = new Cat(); cat1.name = "咪咪"; cat1.mew(); cat1.eat();    }}

代码运行结果: 

       当我们把 name和age的访问权限修改成private以后,子类就不去能访问了(注意是不能访问了,而不是没有被继承):

       那么,此时可以去提供 getter和setter方法,再对代码进行修修改改:

package Demo1;class Animal {//    public String name;    private String name;//    public int age;    private int age;    public String getName() { return name;    }    public void setName(String name) { this.name = name;    }    public int getAge() { return age;    }    public void setAge(int age) { this.age = age;    }    public void eat() { System.out.println(this.name + "正在吃饭");    }}class Cat extends Animal {    public String hair;    public void mew() { //System.out.println(this.name + "正在叫"); //System.out.println(this.getAge());    }}public class Test {    public static void main(String[] args) { Cat cat1 = new Cat(); //cat1.name = "咪咪"; cat1.setName("咪咪"); cat1.mew(); cat1.eat();    }}

       于是,这些成员就被赋初值了:

       当然,我们曾经介绍过,赋初值的方法 除了setter和getter方法以外,还可以使用构造方法:

可是,当我们就直接加上构造方法的时候,代码就会报错啦:

       这是为什么呢?

       ——原来,当构造子类的时候,一定要先帮助父类构造,再帮助子类构造。

       所以说,还需要创建子类的构造方法,同时,要想先帮助父类构造,那可以用super关键字来进行调用:

 【注意】

  1. 在调用构造方法的时候,和this一样,super必须放在第一行;
  2. 父子父子,先有父再有子,在子类当中可以通过super关键字来调用父类的构造方法;
  3. super不能在 静态方法中使用:

当然,我们也可以这样来写代码:

package Demo1;class Animal {    private String name;    private int age;    public String getName() { return name;    }    public void setName(String name) { this.name = name;    }    public int getAge() { return age;    }    public void setAge(int age) { this.age = age;    }    public void eat() { System.out.println(this.name + "正在吃饭");    }    public Animal() {    }    public Animal(String name, int age) { this.name = name; this.age = age;    }}class Cat extends Animal {    public String hair;    public void mew() { System.out.println(this.getName() + "正在叫");    }    public Cat() { super();    }    public Cat(String name,int age,String hair){ super(name, age); this.hair = hair;    }}public class Test {    public static void main(String[] args) { Cat cat1 = new Cat("咪咪",8,"black"); cat1.mew(); cat1.eat();    }}

 代码编译结果:


六、继承方式

       在现实生活中,事物之间的关系是非常复杂、灵活多样的,比如:

       但是,在Java中,只存在以下几种继承方式:

 

【注意】Java是不支持多继承的,即:不支持 一个子类有多个父类。

       从上面来看,父类一层一层的被继承下去;

       但是,如果不想被继承了,那到底该怎么做呢?

       很简单,这就需要又引出了final关键字......


七、final关键字

当一个类被final关键字修饰以后,这个类就不能继承了:

【注意】

       被final修饰的类,我们把它叫做密封类(说明 当前的类不能被继承);

       以前也介绍过,被final修饰的成员不能被修改(变成了常量);

       当然,final还可以修饰方法...... 

 


八、继承与组合

       和继承类似,组合也是一种表达类之间关系的方式,也是可以达到代码复用的效果;

       组合并没有涉及到特殊的语法(比如说 extends 这样的关键字),仅仅是将一个类的实例 作为另外一个类的字段;

       继承 表示对象之间是 is-a 的关系,比如:小狗是动物,小猫是动物;

       组合 表示对象之间是 has-a 的关系,比如:汽车;

       汽车和其轮胎、发动机、方向盘、车载系统 等的关系就应该是组合,因为汽车就是由这些零部件组成的。

// 轮胎类class Tire{    // ...}// 发动机类class Engine{    // ...}// 车载系统类class VehicleSystem{    // ...}class Car{    private Tire tire; // 可以复用轮胎中的属性和方法    private Engine engine; // 可以复用发动机中的属性和方法    private VehicleSystem vs; // 可以复用车载系统中的属性和方法 // ...}// 奔驰是汽车class Benz extend Car{    // 将汽车中包含的:轮胎、发送机、车载系统全部继承下来 }

       组合和继承都可以实现代码复用;

       应该使用继承还是组合,需要根据应用场景来选择;

       一般建议:能用组合尽量用组合。 

       如果大家对这个有很大兴趣的话,可以点击这个传送门:

深入理解Java中的组合和继承-传送门时刻准备中......

写在最后

       那么,现在 Java的第二个特性——继承 也到此告一段落了;

       由于博主水平有限,可能会出现一些表达不清楚,或者出现一些其他的情况,

       欢迎各位铁汁们指出来,让博主一起改正,

       一起努力,共同进步;

       好了,如果这篇博客对铁汁们有帮助的话,可以送一个免费的 赞 嘛;

       当然,顺手点个关注是再好不过的了......