了解Java语法1.0（面向对象之继承）-优快云博客

本文链接：https://blog.youkuaiyun.com/bxxhcyy/article/details/146399484

继承

什么是继承

允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。通过继承，子类可以复用父类的代码，同时还可以添加新的属性和方法或重写父类的方法以实现多态性。

继承可以实现对代码共性的抽取，达到对代码的复用，这有效的减少了一些重复性的代码量，提高了开发效率、可读性。
代码演示：
public class Test2 {
    
    public String name;
    public int age;
    public String color;

    public void so() {
        System.out.println(name + "hhhh");
    }
   
}

class Test3 {
    
    public String name;
    public int age;
    public String color;

    public void so() {
        System.out.println(name + "hhhh");
    }
    public void dou() {
        System.out.println(name + "呜呜呜呜");
    }
    
}
不难发现在两个类中存在大量的重复性的代码，有没有办法把重复部分的代码整合起来呢，在Java中继承就实现了这一特性。代码示例：
//父类
class Test {

    public String name;
    public int age;
    public String color;

    public void sa() {
        System.out.println(name + "hhhh");
    }
}
//子类----extends java中用来继承的关键字
public class Test2 extends Test{

    public void so() {

        System.out.println(name + "嘎嘎嘎嘎嘎");
    }

}
//子类
class Test3 extends Test{

    public void dou() {

        System.out.println(name + "呜呜呜呜");
    }

}
从代码中可以看出，Test2、Test3两个类继承了Test类，把它们所共有的代码放到父类当中，达到继承中共性的抽取，代码的复用。子类会继承父类中的成员变量和成员方法

父类和子类之间的访问关系

子类访问父类变量

代码示例：
public class Anim {
   public int a;
   public int b;
}
class Aa extends Anim{

   public int c;

   public void sos() {
       a = 10;//父类继承的
       b = 20;//父类继承的
       c = 30;//子类自己的
   }
}
可以看出子类继承了父类的成员变量，可以直接使用父类的成员变量。

当子类与父类成员变量同名时会发生什么呢？
代码示例:
public class Anim {
   public int a;
   public int b;
   public int c = 40;
}
class Aa extends Anim {

    public int c = 30;

    public void sos() {
        a = 10;//父类继承的
        b = 20;//父类继承的
        c = c;//子类自己的
        System.out.println(c);

    }//输出结果30
如果访问的成员变量子类中有，优先访问自己的成员变量
如果访问的成员变量与父类中成员变量同名，优先访问自己的。
如果访问的成员变量子类中没有，则访问父类继承下来的，如果父类也没有定义，则编译报错。

成员方法的访问有什么区别？
代码示例：
 public void das() {
       System.out.println("父类方法hhhh");
   }
}
class Aa extends Anim {
    
    public void saf() {
        System.out.println("子类方法hhhh");
    }
    public static void main(String[] args) {
        Aa aa = new Aa();
        aa.saf();
        aa.das();
    }
}
子类是可以正常访问父类中的方法的
如果子类与父类方法名相同时还可以访问吗
public class Anim {
   public int a;
   public int b;

   public void das() {
       System.out.println("父类方法hhhh");
   }

}
class Aa extends Anim {

    public void das() {
        System.out.println("子类方法eeee");
    }

    public void wer() {
        System.out.println("子类方法eeee");

    }

    public void gea() {
        das();
        wer();
    }
    public static void main(String[] args) {
        Aa aa = new Aa();
        aa.gea();
发现输出的都是子类的方法，访问不到父类的方法，这种情况下想要访问父类要怎么访问呢，这就需要用到Java中的super关键字---继承中用来在子类中访问父类

认识super关键字
public class Anim {
   public int a;
   public int b;

   public void das() {
       System.out.println("父类方法hhhh");
   }

}
class Aa extends Anim {

    public void das() {
        System.out.println("子类方法eeee");
    }

    public void wer() {
        System.out.println("子类方法eeee");

    }

    public void gea() {
        super.das();
        wer();
    }
    public static void main(String[] args) {
        Aa aa = new Aa();
        aa.gea();
super的使用注意事项
只能在非静态方法中使用
在子类方法中，访问父类的成员变量和方法。
总结：

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

通过子类对象访问父类与子类同名方法时，如果父类和子类同名方法时需要使用super关键字来确认调用的时父类还是子类
子类构造方法与父类构造方法的关系

父子，先有父在有子，这一点也表现在Java的继承关系中，在继承关系中，子类需要先帮助父类完成构造方法的构造，否则编译报错。

为什么要先帮助父类构造呢---子类对象中成员是有两部分组成的，父类继承下来的以及子类新增加的部分，不帮助父类构造它就继承不了
若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，帮助父类完成构造，否则编译失败。
在子类构造方法中，super()调用父类构造时，必须是子类构造方法中第一条语句
super()只能在子类构造方法中出现一次，并且不能和this同时出现

super和this有什么区别

如果需要了解this的可以去看了解Java语法1.0（面向对象之this和构造）-优快云博客

相同点：
Java中的关键字
只能在类的非静态方法中使用，用来访问非静态成员方法和字段
在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在
不同点：
this是当前对象的引用，调用实例方法的对象，super是子类对象中父类继承下来部分成员的引用
在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
在构造方法中：this()用于调用本类构造方法，super()用于调用父类构造方法，两种调用不能同时在构造方法中出现
构造方法中一定会存在super()的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

子类与父类之间代码的执行顺序
public class Animal {
    public String name;

    {
        System.out.println("父类实例代码块");//1
    }
    static {
        System.out.println("父类静态代码块");//2
    }
    public Animal(String name) {
        System.out.println("父类构造方法");//3

    }


}
class Dog extends Animal {
    {
        System.out.println("子类实例代码块");//5
    }

    static {
        System.out.println("子类静态代码块");//6
    }

    public Dog(String name) {
        super("小七");

        System.out.println("子类构造方法");//7

    }

}
class T {
    public static void main(String[] args) {
        Dog dog1 = new Dog("小七");
        System.out.println("---------------------------------------------");
        Dog  dog2 = new Dog("小八");

    }

}
输出结果：

通过分析执行结果，得出以下结论：
最早执行父类静态代码块---优先于子类静态代码块执行
父类实例代码块和父类构造方法紧接着执行
子类的实例代码块和子类构造方法紧接着再执行
第二次实例化子类对象时，父类和子类的静态代码块不会再执行

继承的方式

单继承

不同类继承同一个类

多层继承

一个子类只能有一个父类，不能同时有多个父类

final关键字

final的作用：final关键可以用来修饰变量、成员方法以及类。
修饰变量：变量的值不能在被修改的，即常量
public class Test {
   final String str = "hh";
   
    public static void main(String[] args) {
        Test test = new Test();
        test.str = "ww";//报错
        final int a = 10;
        a =20;//报错
    }
}
被final修饰的变量必须赋初始值，否则报错，亦不能修改值。

修饰方法：方法不能被重写

得出结论：不能在继承关系中重写被final修饰方法。

修饰类：不能被继承

继承和组合

组合的概念：组合是一种设计模式，即一个整体中包含了多个部分，组合是一种“拥有”关系。
整体与部分的关系：
整体类（Composite Class）：包含其他类的对象作为其成员变量。
部分类（Component Class）：被整体类包含的对象。

代码示例：
package Test;
        //整体
public class Test {
    public Ste ste;//可以复用set类中的方法和变量
    public Sud sud;//可以复用sud类中的方法和变量
    public Sun sun;//可以复用sun类中的方法和变量
}
        //部分类
   class Sun {

   }
   //部分类
    class Sud {

    }
    //部分类
    class Ste {

    }
组合和继承的区别：
继承：表示“是一种”（is-a）关系，例如 Dog 是一种 Animal。
子类继承父类的方法和属性，子类是父类的扩展
继承是静态的，一旦类被定义，继承关系就固定了。
组合：表示“拥有”（has-a）关系，例如主机拥有 cpu。
整体类通过包含部分类的对象来实现功能，部分类可以独立于整体类存在
组合是动态的，可以在运行时动态地创建和管理部分对象。
组合的优点：
灵活性：组合可以在运行时动态地创建和管理部分对象，而继承是静态的，一旦定义就无法改变。
避免继承层次过深：过多的继承层次会导致代码难以维护和理解，而组合可以避免这种情况。
更好的封装性：组合将部分对象的实现细节封装起来，整体类只需要与部分对象的接口交互。
可复用性更高：部分类可以被多个整体类复用，而继承可能导致代码重复。