Java中的继承性特性

时间:2021-12-01 16:05:26

  继承性是java中的第二特性之一。而继承性最为关键的地方为:代码重用性的问题,利用继承性可以从已有的类中继续派生出新的子类,也可以利用子类扩展出更多的操作功能。

  继承性的实现代码为:class 子类  extends  父类{ }

  有以下3点说明:

  1、对于extends而言,需要不断的开展开来,但是为了理解上的方便,这些统一称之为:继承;

  2、子类又称之为派生类;

  3、父类又称之为超类(Super class);

以下代码为子类继承父类的属性及方法

class Person{
  private String name;
  private int age;

  public Person() {}
  public Person(String name,int age){
    this.name = name;
    this.age = age;
  }

  public void setName(String name){
    this.name = name;
  }
  public void setAge(int age){
    this.age = age;
  }

  public String getName(){
    return this.name;
  }
  public int getAge(){
    return this.age;
  }
  }
}
  class Student extends Person {
   private String school;
   public void setSchool(String school){
    this.school = school;
  }
  public String getSchool(){
    return this.school;
  }
}

  public class School{
  public static void main(String args[]){
    Student stu = new Student();
    stu.setName("zhangsan");
    stu.setAge(123);
    stu.setSchool("大学");
    System.out.println("名字" + stu.getName() + ",年龄" + stu.getAge()+ stu.getSchool());
  }
}

从这中间可以得到以个结论:

  子类在实际中的运用中,是将父类定义得更加具体化的一种手段。

在继承的使用中,有三大限制,这些在实际的运用及编写代码的时候需要多加注意:

一、继承不可以多重继承,但是可以多层继承。

子类与父类的使用如下:

class A{
  public void fun(){
    System.out.println("这就是A");
  }
}
class B extends A{
  public void fun(){
    System.out.println("这就是B");
  }
}
class C extends A{
  public void fun(){
    System.out.println("这就是C");
  }
}
class New1{
  public static void main(String args[]){
    B b1 = new B();
    b1.fun();
    C c1 = new C();
    c1.fun();
  }
}

二、在子类在继承父类时,严格来说会继承中,但是在父类多有的私有操作属于中称之为隐形继承。所有的非私有操作属于显示属性。

class A {

private String msg;

public void setMsg(String msg) {

this.msg = msg;

}

public String getMsg() {

return this.msg;

}

}

class B extends A {                                                                // 继承自A类

}

public class Demo {

public static void main(String args[]) {

B b = new B();

b.setMsg("Hello");                                         // 设置msg属性,属性通过A类继承

System.out.println(b.getMsg());   // 通过子类对象取得msg属性

  }

}

三、在子类构造前一定会默认调用父类的构造(默认使用无参构造),以保证父类的对象先实例化,子类对象后实例化。

观察实例化对象操作:
class A {
  public A() { // 父类提供的无参构造方法
    System.out.println("A、A类的构造方法!");
  }
}
class B extends A { // B是子类继承父类A
  public B() { // 定义子类的构造方法
    System.out.println("B、B类的构造方法!");
  }
}
public class Demo {
  public static void main(String args[]) {
    new B(); // 实例化子类对象
  }
}

子类隐含语句:
class B extends A { // B是子类继承父类A
  public B() { // 定义子类的构造方法
  super() ; // 父类中有无参构造时加与不加无区别,如果编写则必须出现在首行
  System.out.println("B、B类的构造方法!");
}

父类不提供无参构造方法:
class A {
  public A(String title) { // 父类提供的有参构造方法
    System.out.println("A、A类的构造方法,title = " + title);
  }
}
class B extends A { // 定义子类B
  public B(String title) { // 子类提供有参构造
    super(title); // 明确调用父类构造,否则将出现编译错误
    System.out.println("B、B类的构造方法!");
  }
}
public class Demo {
  public static void main(String args[]) {
    new B("Hello"); // 实例化子类对象
  }
}

方法覆写:

特产主要特征:子类可以根据父类已有的功能进行功能的扩展,但是在子类定义属性或方法时,可以出现定义的属性或方法与父类同名的情况,这样的操作成为覆写。

class A {

public void fun() {          // 在父类中定义的方法

System.out.println("A类中的fun()方法。") ;

}

}

class B extends A {                           // 定义子类,此时没有覆写任何方法

public void fun() {          // 此处为覆写

System.out.println("B类中的fun()方法。") ;

}

}

class C extends A {

public void fun() {          // 此处为覆写

System.out.println("C类中的fun()方法。") ;

}

}

public class TestDemo {

public static void main(String args[]) {

B b = new B() ;              // 实例化子类对象

b.fun() ;                         // 调用fun()方法,此时方法被覆写,所以调用被覆写过的方法

C c = new C() ;              // 实例化子类对象

c.fun() ;                          // 调用fun()方法,此时方法被覆写所以调用被覆写过的方法

}

}

方法重载与重写的区别

区别     重载          覆写

英文单词  Overloading         Override

发生    发生在一个类里面   发生在继承关系中

定义    方法名称相同、参数  方法名称相同、参数类型、个数相同、方法返回值相同

       的类型及个数不同

极限    没有权限的限制    被覆写的方法不能拥有比父类更为严格的访问控制限制

区别    this                        super

功能    调用本类构造,本类方法,本类属性        子类调用父类构造,父类方法,父类属性

形式    先查找本类中是否存在有指定的调用结构,     不查找子类,直接调用父类操作

特殊    表示本类的当前对象               空