Scala中的继承性及其类型介绍

面向对象编程的重要主题之一是继承。继承允许我们用另一个类来定义一个类，这使得我们的代码可以重用。在这里，我将向你介绍Scala中的继承。

什么是Scala中的继承？

它是Scala中的一种工具，通过它，一个类可以获得另一个类的特征（字段和方法）。

继承的关键词是 （extend）。

SYNTAX

class parent_class_name extends child_class_name{

重要术语

超类： 获得其特征的类被称为超类（或基类或父类）。

子类： 继承另一个类的类被称为子类（或推断类、扩展类、或青年类）。

可重用性： 在可重用性中，一旦我们希望制作一个新的类，并且已经有一个类具有我们想要的一些代码，我们将从现有的类中派生出我们的新类，我们要重用现有类的字段和方法。

例子

class Parent{
  var Name: String = "Rahul"
}
class Child extends Parent {
  var Age: Int = 5

  def details() {
    println("Parent Name: " + Name)
    println("Age: " + Age)
  }
}
object Main {
  def main(args: Array[String]) {
    var obj = new Child();
    obj.details();
  }}

继承的类型

在scala中，有5种继承类型

1- Single Inheritance
2 -Multilevel Inheritance
3- Hierarchical Inheritance
4- Multiple Inheritance
5- Hybrid Inheritance

单一继承

单一继承是最省力的一种继承模式。当你有一个具有基本属性的类，而你需要有更多具有每一个基本属性和一些特殊特征的类时，就可以采用这种方式。在单一继承中，确定的类继承了一个基类的亮点。

 class Parent
{
  var ParentName: String = "Rahul"
}
class Child extends Parent
{
  var Age: Int = 24
  def details()
  {
    println("ParentName: " +ParentName)
    println("Age: " +Age);
  }
}

object Main
{
  def main(args: Array[String])
  {

    var obj = new Child()
    obj.details()
  }
}

输出

多级继承

在多级继承中，一个派生类将获得一个基类，就像派生类还能作为另一个类的基类一样。

在上图中，A是派生类B的基类，而B又是派生类C的基类。

class Parents
{
  var Name: String = "Aditya"
}

class ChildNo1 extends Parents
{
  var Age: Int = 24
}
class ChildNo2 extends ChildNo1
{
  def details(){
    println("Name: " +Name)
    println("Age: " +Age)
  }
}
object Main{
  def main(args: Array[String])
  {
    var obj= new ChildNo2()
    obj.details()
  }
}

OUTPUT

分层继承

在分层继承中，一个类作为一个以上的子类的超类（基类）来填充。当一个以上的类继承一个相等的类时，这被称为各种层次继承。例如，类B、C和D扩展了类A。

class Parent
{
  var Name1: String = "Rahul"
  var Name2: String = "Shreya"
}
class ChildNo1 extends Parent
{
  var Age: Int = 24
  def details1()
  {
    println(" Name: " +Name1)
    println(" Age: " +Age)
  }
}
class ChildNo2 extends Parent
{
  var Weight: Int = 70

  def details2()
  {
    println(" Name: " +Name2);
    println(" Weight: " +Weight);
  }
}

object main{

  def main(args: Array[String])
  {

    val object1 = new ChildNo1()
    val object2 = new ChildNo2()
    object1.details1()
    object2.details2()
  }}

输出

多重继承

多重继承。在多重继承中，一个类可以有一个以上的超类，并从所有父类中获取特征。Scala不支持类的多重继承，但是，可以通过traits来完成。

举个例子

trait Ram {
  
    def method1()
  }
trait Shyam{
  
    def method2()
  }

class Parents extends Ram with Shyam{
  
    def method1()
    {
      println("Ram")
    }

    def method2()
    {
      println("Shyam")
    }
  }
  object Main{
    def main(args: Array[String])
    {
      
      var obj = new Parents()
      obj.method1()
      obj.method2()
    }}

OUTPUT

混合继承

混合继承。它是上述至少两种继承的混合体。由于不可能用类来实现。在Scala中，我们可以仅仅通过traits来完成混合继承

举例说明

class A {
  var numA: Int = 0;

  def setA(n: Int) {
    numA = n;
  }

  def printA() {
    printf("numA: %d\n", numA);
  }
}

class B extends A {
  var numB: Int = 0;

  def setB(n: Int) {
    numB = n;
  }

  def printB() {
    printf("numB: %d\n", numB);
  }
}

class C extends B {
  var numC: Int = 0;

  def setC(n: Int) {
    numC = n;
  }

  def printC() {
    printf("numC: %d\n", numC);
  }
}

class D extends A {
  var numD: Int = 0;

  def setD(n: Int) {
    numD = n;
  }

  def printD() {
    printf("numD: %d\n", numD);
  }
}

object Main {
  def main(args: Array[String]) {
    var obj1 = new C();
    var obj2 = new D();

    obj1.setA(10);
    obj1.setB(20);
    obj1.setC(30);

    obj1.printA();
    obj1.printB();
    obj1.printC();

    obj2.setA(40);
    obj2.setD(50);

    obj2.printA();
    obj2.printD();
  }
}

OUTPUT