Escala | Miembros de tipo abstracto

Se dice que un miembro de una clase o rasgo es abstracto si ese miembro en particular no tiene una definición completa en la clase. Estos miembros abstractos siempre se implementan en cualquier subclase de la clase bajo la cual se define. Este tipo de declaración está permitida en muchos lenguajes de programación y es una de las características clave de los lenguajes de programación orientados a objetos. Scala también permite declarar tales métodos como se muestra en el siguiente ejemplo:

abstract class Sample{
  def contents: Array[String]
  def width: Int = a
  def height: Int = b
}

Por lo tanto, en la clase Sample anterior, hemos declarado tres métodos: contenido, ancho y alto. La implementación de los dos últimos métodos ya está definida mientras que en el primer método, contenidos, no se menciona ningún tipo de implementación. Este método es, por lo tanto, un miembro abstracto de la clase Muestra. Es importante tener en cuenta que una clase con miembros abstractos debe declararse abstracta. Esta palabra clave abstracta delante de la clase indica que la clase seguramente tendrá un miembro abstracto sin implementación.
Otro ejemplo de cómo escribir los miembros abstractos dentro de una clase:

abstract class Example{
   type T
   def transform(x: T): T
   val initial: T
   var current: T
}

En el ejemplo anterior, se declara la clase abstracta que define un tipo abstracto T, una transformación de método abstracto, un valor abstracto inicial y un valor abstracto actual.

A continuación se muestra el ejemplo de miembro de tipo abstracto:

Ejemplo :

// Scala program of abstract type member 
  
// Declaring an abstract class
abstract class vehicle (name:String) 
{    
    // This is an abstract member 
    // with undefined implementation 
    val category: String     
      
    // A function that is used to print 
    // the value of the abstract member
    def car_type{ println(category) }  
    override def toString = s" The vehicle type is $category"
}
  
// Now extend the classes bike, car, 
// truck and bus and provide values 
// for the variable type
  
class car (name:String) extends vehicle (name)
{
    // assigning the value of 
    // the abstract member as car
    val category = "car"             
}
class bike (name:String) extends vehicle (name)
{
    // assigning the value of 
    // the abstract member as bike
    val category = "bike"         
}
class bus (name:String) extends vehicle (name)
{
    // assigning the value of 
    // the abstract member as bus
    val category = "bus"             
}
class truck (name:String) extends vehicle (name)
{
    // assigning the value of 
    // the abstract member as truck
    val category = "truck"         
}
  
object AbstractFieldsDemo extends App
{
    // assigning the name as Honda in the abstract
    // class where the category value is car
    val car = new car("Honda") 
      
    // assigning the name as Yamaha in the abstract 
    // class where the category value is bike
    val bike = new bike("Yamaha") 
      
    // assigning the name as Tata in the abstract 
    // class where the category value is bus
    val bus = new bus("Tata")     
      
    // assigning the name as Ashok_Leyland in the
    // abstract class where the category value is truck
    val truck = new truck("Ashok_Leyland") 
      
     // implementing the function 
     // car_type for the object car
    car.car_type
      
    // implementing the function 
    // car_type for the object bus
    bus.car_type
      
    // implementing the function 
    // car_type for the object truck
    truck.car_type     
      
    // implementing the function 
    // car_type for the object bus
    bike.car_type     
    println(car)
    println(bus)
    println(truck)
    println(bike)
}

Producción

car
bus
truck
bike
The vehicle type is car
The vehicle type is bus
The vehicle type is truck
The vehicle type is bike

En el ejemplo anterior, el vehículo de características tiene una categoría de valor abstracta junto con un método concreto simple llamado car_type y una anulación del método toString. Y luego las clases coche , moto , camión y autobús amplían la clase vehículo y proporcionan valores para la categoría de campo .
Vemos en el código anterior cómo se usa la implementación indefinida del miembro abstracto para asignar valores y cambiar los valores asignados para cada objeto de diferente tipo. Como en este ejemplo, almacenamos múltiples valores de categoría para diferentes tipos de vehículos.

Así, para una conclusión, los miembros de datos abstractos son aquellos que tienen una implementación desconocida.