Java-继承和组合

目录

1. 为什么需要继承

2 .继承概念

3. 继承语法

4. 父类成员访问

5. super关键字

6.子类构造方法

7.super和this

8.再看初始化

9. protected关键字

10. 继承方式

11. final关键字

12.继承和组合


1. 为什么需要继承

             Java中使用类对现实世界中实体来进行描述,类经过实例化之后的产物对象,则可以用来表示现实中的实体,但是现实世界错综复杂,事物之间可能会存在一些关联。例如:动物狗和猫。
        Java-继承和组合_第1张图片Java-继承和组合_第2张图片

         对他们进行描述,可有以下代码

public class Dogs {//狗
    String name;
    int age;
    float weight;
    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }
    public  void sleep(){
        System.out.println(this.name+"正在睡觉");
    }
    public void bark(){
        System.out.println(this.name+"汪汪汪~~~");
    }
}
public class Cats {//猫
    String name;
    int age;
    float weight;
    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }
    public  void sleep(){
        System.out.println(this.name+"正在睡觉");
    }
    public void mew(){
        System.out.println(this.name+"喵喵喵~~~");
    }
}

        Java-继承和组合_第3张图片

                 对于他们共有的代码块,我们是否能提取这些共性呢?面向对象思想中提出了继承的概念,专门用来进行共性抽取,实现代码复用。

2 .继承概念

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

           如上文中的猫和狗我们就可以将他们的共性提取,用继承的思想实现。

Java-继承和组合_第4张图片

          上述图示中,Dog和Cat都继承了Animal类,其中:Animal类称为父类/基类或超类,Dog和Cat可以称为Animal的子类/派生类,继承之后,子类可以复用父类中成员,子类在实现时只需关心自己新增加的成员即可。继承最大的作用就是:实现代码复用,还有就是来实现多态。
 

3. 继承语法

             在Java中如果要表示类之间的继承关系,需要借助extends关键字。

        修饰符 class 子类 extends 父类{

                //....

        }

          对上述代码使用继承方式。

public class Animals {
    String name;
    int age;
    float weight;
    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }
    public  void sleep(){
        System.out.println(this.name+"正在睡觉");
    }
}
public class  Dogs extends Animals{
     public  void bark(){
        System.out.println(this.name+"汪汪汪~~~");
    }
}
public class Cats extends Animals{
    public void mew(){
        System.out.println(this.name+"喵喵喵~~~");
    }
}
public class TextJicheng {
    public static void main(String[] args) {
        Dogs dog=new Dogs();
        //Dogs中没有成员变量,继承父类中的
        System.out.println(dog.name);
        System.out.println(dog.age);
        //Dogs中没有eat和sleep函数,继承父类中的
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

Java-继承和组合_第5张图片

                 注意:子类会将父类中的成员变量或者成员方法继承到子类中;子类继承父类之后,必须要新添加自己特有的成员,体现出与基类的不同,否则就没有必要继承。

4. 父类成员访问

                在继承体系中,子类将父类中的方法和成员变量都继承下来了,那在子类中能否直接访问父类中继承下来的成员呢?

      1.子类中访问父类的成员变量

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

public class  Dogs extends Animals{
     public  void bark(){
        System.out.println(this.name+"汪汪汪~~~");
    }
    public void mathod(){
         name="huahua";
         age=5;
         weight=5.2f;
    }
}

       (2)子类和父类成员变量同名

public class Cats extends Animals{
    String name;
    String color;
    public void mew(){
        System.out.println(this.name+"喵喵喵~~~");
    }
    public void mathod(){
        name="赛虎";//同名
        age=4;      //父类中有
        color="黑白";//父类中没有
    }
}

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

  • 如果访问的成员变量子类中有,优先访问自己的成员变量。
  •  如果访问的成员变量子类中无,则访问父类继承下来的,如果父类也没有定义,则编译报错。
  •  如果访问的成员变量与父类中成员变量同名,则优先访问自己的。

      2. 子类中访问父类的成员方法
             (1)成员方法名不同  

public class  Dogs extends Animals{
     public  void bark(){
        System.out.println(this.name+"汪汪汪~~~");
    }
    public void method(){
         bark();    //访问子类的方法
         eat();     //访问父类的方法
    }
     
    public static void main(String[] args) {
     Dogs dog=new Dogs();
     dog.method();
    }
}

Java-继承和组合_第6张图片

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

                (2)成员方法名相同

public class Cats extends Animals{
    String name;
    String color;
    public void mew(){
        System.out.println(this.name+"喵喵喵~~~");
    }
    
    public void sleep(){
        System.out.println(this.name+"睡醒了");
    }
    public static void main(String[] args) {
        Cats cat=new Cats();
        cat.sleep();
    }
}

Java-继承和组合_第7张图片

         总结:

  • 通过子类对象访问父类与子类中不同名方法时优先在子类中找,找到则访问,否则在父类中找,找到则访问,否则编译报错。
  • 通过字类对象访问父类与子类同名方法时,如果父类和子类同名方法的参数列表不同(重载),根据调用方法适传递的参数选择合适的方法访问,如果没有则报错

如果子类中存在与父类中相同的成员时,那如何在子类中访问父类相同名称的成员呢?

5. super关键字

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

public class Animals {
    String name;
    int age;
    float weight;

    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }
    public  void sleep(){
        System.out.println(this.name+"正在睡觉");
    }
    
}
public class Cats extends Animals{
    String name;
    String color;
    public void mew(){
        System.out.println(this.name+"喵喵喵~~~");
    }
    public void mathod(){
        name="赛虎";//同名成员变量,访问子类
        age=4;      //同名,访问子类
        color="黑白";//父类中没有
        
        super.name="feifei";//访问父类成员变量
        super.age=3;

        sleep();//方法重载
        sleeo(5);
        System.out.println("=====");
        eat();
        super.eat();//通过super访问父类中同名方法
    }
        //方法重载,区分参数列表来访问方法
    public void sleep(int a){
        System.out.println(this.name+"睡醒了");
    }
    
        //与父类的eat()构成重写
     public  void eat(){
         System.out.println(this.name+"不吃了");
     }
    public static void main(String[] args) {
        Cats cat=new Cats();
        cat.mathod();
    }
}

Java-继承和组合_第8张图片

 Java-继承和组合_第9张图片

         在子类方法中,如果要访问父类中同名成员变量或与子类方法构成重写时,需借助super关键字,super只能在非静态方法中使用

6.子类构造方法

        父子父子,先有父再有子,即子类对象构造时,需要先调用父类构造方法,然后执行子类的构造方法。

public class Animals {
    String name;
    int age;
    float weight;
    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }
    public  void sleep(){
        System.out.println(this.name+"正在睡觉");
    }
    public Animals(){        //构造方法
        System.out.println("Animals()");
    }
}
public class  Dogs extends Animals{
     public  void bark(){
        System.out.println(this.name+"汪汪汪~~~");
    }
    public void mathod(){
         name="huahua";
         age=5;
         weight=5.2f;
    }
    public void method(){
         bark();    //访问子类的方法
         eat();     //访问父类的方法
    }
    public Dogs(){        //构造方法
        System.out.println("Dogs()");
    }

    public static void main(String[] args) {
         Dogs dog=new Dogs();
    }
}

Java-继承和组合_第10张图片

         在子类构造方法中,并没有写任何关于父类构造的代码,但是在构造子类对象时,先执行父类的构造方法,然后执行子类的构造方法,因为:子类对象中成员是有两部分组成的,父类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子,所以在构造子类对象时候 ,先要调用父类的构造方法,将从父类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整。

        注意:

        1. 若父类显式定义无参或者默认的构造方法,在子类构造方法第一行默认有隐含的super()调用,即调用基类构造方法。

        2. 如果父类构造方法是带有参数的,此时需要用户为子类显式定义构造方法,并在子类构造方法中选择合适的父类构造方法调用,否则编译失败。

        3. 在子类构造方法中,super(...)调用父类构造时,必须是子类构造函数中第一条语句。

        4. super(...)只能在子类构造方法中出现一次,并且不能和this同时出现

7.super和this

        super和this都可以在成员方法中用来访问:成员变量和调用其他成员函数,都可以作为构造方法的第一条语句,那他们之间有什么区别呢?
        相同点:都是Java中的关键字只能在类的非静态方法中使用,用来访问非静态成员方法和字段在构造方法中调用时,必须是构造方法中的第一条语句,并且不能同时存在

        不同点:this是当前对象的引用,当前对象即调用实例方法的对象,super相当于是子类对象中从父类继承下来部分成员的引用;在非静态成员方法中,this用来访问本类的方法和属性super用来访问父类继承下来的方法和属性;在构造方法中:this(...)用于调用本类构造方法super(...)用于调用父类构造方法,两种调用不能同时在构造方法中出现构造方法中一定会存在super(...)的调用,用户没有写编译器也会增加,但是this(...)用户不写则没有

8.再看初始化

        还记得之前讲过的代码块吗?简单回顾一下几个重要的代码块:实例代码块和静态代码块。在没有继承关系时的执行顺序。

class Persons {
    public String name;
    public int age;
    public Persons(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("构造方法执行");
    }
    {
        System.out.println("实例代码块执行");
    }
    static {
        System.out.println("静态代码块执行");
    }
}
public class Person {
        public static void main(String[] args) {
            Persons person1 = new Persons("zhangsan",10);
            System.out.println("=======");
            Persons person2 = new Persons("lisi",15);
        }
}

Java-继承和组合_第11张图片

 Java-继承和组合_第12张图片

         执行顺序:执行静态代码块(只执行一次,在类加载阶段执行)--->执行实例代码块(有对象创建)--->构造方法。

        继承关系上的执行顺序

class Persons {
    public String name;
    public int age;
    public Persons(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("执行构造方法");
    }
    {
        System.out.println("执行实例代码块");
    }
    static {
        System.out.println("执行静态代码块");
    }
}
class Student extends Persons{
        public Student(String name,int age){
            super(name,age);
            System.out.println("执行构造方法");
        }
    {
        System.out.println("执行实例代码块");
    }
    static {
        System.out.println("执行静态代码块");
    }
}
public class Person {
        public static void main(String[] args) {
           Student person1 = new Student("zhangsan",10);
            System.out.println("=======");
            Student person2 = new Student("lisi",15);
        }
}

Java-继承和组合_第13张图片

 Java-继承和组合_第14张图片

 Java-继承和组合_第15张图片

         执行顺序:父类静态代码块--->子类静态代码块--->父类实例代码块--->父类构造方法--->子类实例代码块--->子类构造方法。

9. protected关键字

        在类和对象章节中,为了实现封装特性,Java中引入了访问限定符,主要限定:类或者类中成员能否在类外或者其他包中被访问。
Java-继承和组合_第16张图片

 那父类中不同访问权限的成员,在子类中的可见性又是什么样子的呢?

        //包1中

public class B {
    private int a;
    protected int b;
    public int c;
    int d;
}

        //包1中的子类

public class D extends B{
    public void method(){
        //super.a=10; //编译报错,父类B中private成员在相同包子类中不可见
        super.b=20;  //父类B中protected成员在相同包子类中可以访问
        super.c=10;  //父类B中public成员在相同包子类中可以访问
        super.d=2;  //父类B中defult成员在相同包子类中可以访问
    }
}

        //包2中的子类

public class C extends B {
    public void  method(){
        //super.a;      //编译报错,父类B中private修饰的成员在不同包子类中不可见
        super.b=10;     //父类protected修饰的成员在不同包中可见
        super.c=50;     //父类public修饰的成员在不同包中可见
        //super.d=100;  //编译报错,父类defult修饰的成员在不同包中不可见
    }
}

        //包2中的其他类

public class TextC {
   public static void main(String[] args) {
       C c=new C();
       c.method();
    //System.out.println(c.a);//编译报错父类中private修饰的成员在不同包其他类中不可见
   //System.out.println(c.b);//编译报错父类中protected修饰的成员在不同包其他类中不可见
      System.out.println(c.c);//父类中public修饰的成员在不同包其他类中可以访问
    //System.out.println(c.d);// 编译报错,父类中defult修饰的成员在不同包其他类中不可见
    }
}

        注意:父类中private修饰的成员变量虽然在子类中不能直接访问,但是也继承到子类中。
        什么时候下用哪一种呢?

        我们希望类要尽量做到 "封装", 即隐藏内部实现细节, 只暴露出 必要 的信息给类的调用者,因此我们在使用的时候应该尽可能的使用 比较严格 的访问权限. 例如如果一个方法能用 private, 就尽量不要用 public
 

10. 继承方式

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

Java-继承和组合_第17张图片

         但在Java中支支持以下几种继承方式:

Java-继承和组合_第18张图片

         我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了。如果想从语法上进行限制继承, 就可以使用 final 关键字。

11. final关键字

        final关键可以用来修饰变量、成员方法以及类。

        (1)修饰变量或字段,表示常量(即不能修改)

                final int a = 10;
                a = 20; // 编译出错

        (2)修饰类:表示此类不能被继承

                final public class Animal {
                        ...
                }
                public class Bird extends Animal {
                        ...
                } // 编译报错,A不能再被继承

            (3)修饰方法:表示该方法不能被重写(后序介绍)
 

12.继承和组合

        和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段继承表示对象之间是is-a的关系,比如:狗是动物,猫是动物,组合表示对象之间是has-a的关系,比如:汽车。

Java-继承和组合_第19张图片Java-继承和组合_第20张图片
        汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合,因为汽车是有这些部件组成的。 

// 轮胎类
class Tire{
        // ...
}

// 发动机类
class Engine{
        // ...
}

// 车载系统类
class VehicleSystem{
        // ...
}
class Car{

        private Tire tire;         // 可以复用轮胎中的属性和方法
        private Engine engine;         // 可以复用发动机中的属性和方法
        private VehicleSystem vs;         // 可以复用车载系统中的属性和方法

        //...

}

//奔驰是汽车
class Benz extend Car{
        // 将汽车中包含的:轮胎、发送机、车载系统全部继承下来
}

         组合和继承都可以实现代码复用,应该使用继承还是组合,需要根据应用场景来选择,一般建议能用组合尽量用组合

        

你可能感兴趣的:(java,开发语言)