Java 面向对象第二部分(继承）

柔情只为你懂 2022-10-20 05:28 197阅读 0赞

Java中的继承

一.概念

继承是Java面向对象中的第二大特征，继承不难理解，就是说当两个事物之间存在一定的关系，就像一个孩子继承自他的父母，孩子和他的父母之间是一种父子关系，孩子有和他父亲一样的遗传基因，还存在一些一样的行为动作，那么换到java中，子类和父类存在一种继承关系，子类可以从父类中继承到一些公有的特征(属性)，和一些行为(方法)，这样子类不仅可以简化类的设计还能获得和父类一样的属性和方法。

二.继承的作用

1.提高代码的复用性，定义在父类中的成员(变量和方法)，可以被子类重复使用。

2.让类与类之间产生了关系，这种关系是一种继承关系，这样就会产生多态，使应用起来更方便。

注意:正因为继承的优点所在，所以在开发中，我们不可以为了方便，只是为了获取某个类的功能或属性，一味的去继承这个类，这是一种错误的做法，必须是类与类之间确实存在所属关系，存在共性，才可以用继承，符合实际原则。

class Person
    {
    String name;
    int age;
    
    }
    class Student extends Person
    {
    //Student类继承Person类，所以也有一个name和age变量，而且是每个人都//有的属性，直接从父类继承就可，不比在定义了。
    //创建一个学生类特有的学习行为
    void study()
    {
    System.out.println("good study");
    }
    }
    
    class Worker extends Person
    {
    //Worker类继承Person类，所以也有一个name和age变量，而且是每个人都//有的属性，直接从父类继承就可，不比在定义了。
    //创建了一个Worker类特有的工作行为。
    void work()
    {
    System.out.println("good work");
    }
    }
    
    
    
    class ExtendsDemo 
    {
    public static void main(String[] args) 
    {
    //创建Student对象,并为其name赋值，然后通过对象名直接调用study方法。
    Student s = new Student();
    s.name = "zhagnsan";
    s.study();
    }
    }

三.继承的特点

1.Java中只支持单继承，不支持多继承，因为多继承容易带来安全隐患，比如现在有一个类继承A类和B类，A类中和B类中有一个同名的方法，但是实现的功能或实现细节不一样，当子类实例化后，去调用这个方法的时候，就会产生问题，不知道去调用哪一个方法了。

2.Java保留这种机制，并用另一种体现形式来完成表示，即接口中的多实现。

3.两个类发生继承关系之后，子类可以拥有父类中非私有的成员属性和方法。

4.两个类发生继承关系之后，子类可以定义和父类一摸一样的方法，但是方法内部的实现功能或细节不一样，这种行为叫做复写，即子类覆盖父类中的方法，在子类对象调用的时候，调用的永远是被子类覆盖的方法。

5.Java支持多层继承，即B继A，C又继承自B，这就是多层继承，这样就成了一个继承体系。

6.子类可以继承父类的所有成员和方法，继承下来不代表可以访问，要访问得看访问控制规则。私有属性也可以继承，不过根据访问控制规则，私有属性虽继承下来却不可以访问的，只有通过public的方法访问继承下来的私有属性。  
举例:

B继承A类，C继承B类。A类中的私有属性，到了C会怎么样，能继承、访问吗？答案是：如果A中的属性有增加setget方法，可以访问的。举例

public class A {
       private int a;
       public int getA(){
           return a;
       }
       public void setA(int a){
           this.a=a;
       }
    }
    public class B extends A{
        private int b;
       public int getB() {
           return b;
       }
       public void setB(int b) {
           this.b = b;
       }
    }
    public class C extends B {
       private int c;
       public int getC() {
           return c;
       }
       public void setC(int c) {
           this.c = c;
       }
    }
    那么当C c1=new C（）时。c1可以使用setA（）getA（）访问控制从A类中继承来的私有属性a
     
     class A
    {
           void show()
           {
                 System.out.println("a");
           }
    }
    class B
    {
           void show()
           {
                 System.out.println("b");
           }
    }
    class Cextends B
    {
    }

四.如何使用一个继承体系中的功能呢？

1.要想使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性的功能。

2.通过了解共性功能，就可以知道该体系中的基本功能，那么这个体系就可以基本使用了

3.那么在具体调用的时候，要创建最子类的对象，为什么呢？

A.一是因为有可能父类不能创建对象，如抽象父类或接口类型的父类。

B.二是创建子类对象可以使用更多的功能，包括基本的，也包括子类特有的。

五.继承关系中类中变量、方法、构造方法的变化和使用

1.子父类中的变量:

A.如果子类中出现和父类同名字的成员变量时，子类访问本类中这个变来那个时候，使用this，如果不使用this，也是默认访问子类中的这个变量。

B.如果子类中出现和父类同名字的成员变量时，子类访问父类中这个变量时候，就要使用super.变量，这样才是方法父类同名字的变量，super关键字代表了对父类的引用。

2.子父亲类中的方法

A.当子类出现和父亲一模一样的方法时，当子类对象调用该方法时，会运行子类的方法，如果父类的方法被字了覆盖，这种情况是方法的另一个特性:重写(覆盖).

B.当子类继承父类，沿袭了父类的功能到子类中，但是子类虽具备该功能，但是功能的内容却和父亲不一样，这时候，没必要定义新功能，而是使用覆盖的方式将自己的内容定义在该方法中，保留父类的功能定义，并重写功能内容。

3.覆盖

定义:子类定义了和父类一模一样的方法，叫做方法重写(覆盖)。  
注意:

A.子类覆盖父类，必须保证子类覆盖后的方法访问权限大于父类权限，才可以覆盖，否则编译失败。

B.静态只能覆盖静态。

class Tel
    {
        void show()
        {
               System.out.println("number");
        }
    }
    class NewTelextends Tel
    {
    //定义了和父类一样的方法，但是实现细节不一样，扩展了自己的新内容。
    void show()
        {
               //System.out.println("number");
               super.show();
               System.out.println("name");
               System.out.println("pic");
        }
    }

4.覆盖和重载的区别

A.重载:发生在同一个类中，同一个类中定义的多个同名的方法，但是重载的方法必须的方法的参数列表个数，或者参数类型不一样，也就是说，重载只看同名的方法的参数列表。

B.覆盖:发生在子类和父类关系中，子类中定义了和父类一模一样的方法，简单说就是子父类方法要一模一样。

5.子父类中的构造函数

1.在对子类对象进行初始化的时候，父类的构造方法也会运行，而且先于子类的构造方法执行。那是因为:子类的构造函数默认第一行有一条隐式语句，super();Super()会访问父类中空参数的构造方法，而且子类中所有的构造方法默认第一行都是super();

2.为什么子类一定要执行父类中的构造方法？

A.因为父类中的数据子类可以直接获取，所以子类对象在建立的时候，需要先查看父类是如何对这些数据进行初始化的。所以子类在初始化的时候要先执行父类中的构造函数，以便能从父类中拿到父类最详细初始化后的数据。

B.如果要访问父类中非空参数的构造函数，可以通过手动定义super语句来指定，而且必须放在第一行。

注意:

A.super语句一定定义在子类构造函数的第一行，

B.构造函数不存在覆盖。

C.子类中构造函数必定有一个会访问到父类中的构造函数。