斯卡拉 |性状

特征就像Java中的接口。但它们比Java中的接口更强大，因为在特征中您可以实现成员。特征可以有方法（抽象的和非抽象的）和字段作为它的成员。

关于 Scala Traits 的一些要点。

特征是使用特征关键字创建的。
句法：

trait Trait_Name{
// Fields..
// Methods..
}

例子：

// Scala program to illustrate how to 
// create traits
  
// Trait 
trait MyTrait
{
    def pet 
    def pet_color
}
  
// MyClass inherits trait
class MyClass extends MyTrait
{
      
    // Implementation of methods of MyTrait
    def pet()
    {
        println("Pet: Dog")
    }
      
    def pet_color()
    {
        println("Pet_color: White")
    }
      
    // Class method
    def pet_name()
    {
        println("Pet_name: Dollar")
    }
} 
  
object Main 
{
      
    // Main method
    def main(args: Array[String]) 
    {
        val obj = new MyClass();
        obj.pet();
        obj.pet_color();
        obj.pet_name();
    }
}

输出：

Pet: Dog
Pet_color: White
Pet_name: Dollar

在 Scala 中，我们可以在特征中实现方法（仅限抽象方法）。如果一个 trait 包含方法实现，那么扩展这个 trait 的类不需要实现已经在一个 trait 中实现的方法。如下例所示。
例子：

// Scala program to illustrate the concept of
// abstract and non-abstract method in Traits
  
// Trait with abstract and non-abstract methods
trait MyTrait
{
    // Abstract method 
    def greeting
  
    // Non-abstract method
    def tutorial
    {
        println("This is a tutorial" + 
                "of Traits in Scala")
    }
}
  
  
// MyClass inherits trait
class MyClass extends MyTrait
{
      
    // Implementation of abstract method
    // No need to implement a non-abstract 
    // method because it already implemented
    def greeting()
    {
        println("Welcome to GeeksfoGeeks")
    }
} 
  
object Main
{
      
    // Main method
    def main(args: Array[String]) 
    {
        val obj = new MyClass();
        obj.greeting
        obj.tutorial
    }
}

输出：

Welcome to GeeksfoGeeks
This is a tutorial of Traits in Scala

Traits 不包含构造函数参数。
当一个类继承一个 trait 时，使用extends关键字。
句法：
```
class Class_Name extends Trait_Name{
// Code..
}
```

当一个类继承多个特征时，在第一个特征之前使用extends关键字，然后在其他特征之前使用with关键字。如下例所示。
句法：

class Class_Name extends Trait_Name1 with Trait_Name2 with Trait_Name3{
// Code..
}

例子：

// Scala program to illustrate how
// a class inherits multiple traits
  
// Trait 1
trait MyTrait1
{
      
    // Abstract method 
    def greeting
  
}
  
//Trait 2
trait MyTrait2
{
      
    // Non-abstract method
    def tutorial
    {
        println("This is a tutorial" + 
               "of Traits in Scala")
    }
}
  
// MyClass inherits multiple traits
class MyClass extends MyTrait1 with MyTrait2
{
      
    // Implementation of abstract method
    def greeting()
    {
        println("Welcome to GeeksfoGeeks")
    }
} 
  
object Main 
{
      
    // Main method
    def main(args: Array[String]) 
    {
        val obj = new MyClass();
        obj.greeting
        obj.tutorial
    }
}

输出：

Welcome to GeeksfoGeeks
This is a tutorial of Traits in Scala

抽象类也可以通过使用extends关键字来继承特征。
句法：
```
abstract class Class_name extends Trait_Name{
// code..
}
```
在 Scala 中，一个 trait 可以通过使用extends关键字来继承另一个 trait。
句法：
```
trait Trait_Name1 extends Trait_Name2{
// Code..
}
```
特征支持多重继承。
在 Scala 中，一个类可以通过在类名前使用extends关键字和在 trait 名称前使用关键字来继承普通类或抽象类和特征。
句法：
```
class Class_Name1 extends Class_Name2 with Trait_Name{
// Code..
} 
```

在 Traits 中，抽象字段是包含初始值的字段，具体字段是包含初始值的字段。我们可以在扩展 trait 的类中覆盖它们。如果一个字段是使用var关键字声明的，那么我们在覆盖它们时就不需要写override关键字。如果一个字段是使用val关键字声明的，那么当我们覆盖它们时，您必须编写override关键字。
例子：

// Scala program to illustrate 
// concrete and abstract fields in traits
  
trait MyTrait
{
      
    // Abstract field
    var value: Int 
      
    // Concrete field
    var Height = 10
    val Width = 30
}
  
class MyClass extends MyTrait
{
      
    // Overriding MyTrait's fields
    var value = 12
    Height = 40
    override val Width = 10
      
    // Method to display the fields
    def Display()
    {
        printf("Value:%d", value);
        printf("\nHeight:%d" ,Height);
        printf("\nWidth:%d", Width);
    }
}
  
object Main
{
      
    // Main method
    def main(args: Array[String])
    {
        val obj = new MyClass();
        obj.Display();
    }
}

输出：

Value:12
Height:40
Width:10

我们还可以向对象实例添加特征。或者换句话说，我们可以直接在类的对象中添加一个 trait，而不需要将该 trait 继承到类中。我们可以使用with关键字在对象实例中添加特征。
句法：

val object_name = new Class_name with Trait_Name;

例子：

// Scala program to illustrate how 
// to add a trait to an object instance 
  
class MyClass{}
trait MyTrait
{
    println("Welcome to MyTrait");
}
object Main 
{
      
    // Main method
    def main(args: Array[String])
    {
          
        // Here MyTrait is added to the 
        // object instance of MyClass
        val obj = new MyClass with MyTrait;
    }
}

输出：

Welcome to MyTrait