上界类型与正常 class 行为的差异

Question

I am studying Generics in Scala and I can't understand the difference between a "normal" class hierarchy and the Upper Bound type.

Looking at the example below: Cage can receive the class Animal, which means that I can pass either the class Animal or the class Dog. The same is valid for the upper bound parameter. What is the practical difference between them? When should I use one or the other?

class Animal
class Dog extends Animal

class Cage(animal: Animal)
val cage = new Cage(new Dog)

class AnotherCage[A <: Animal](animal: A)
val anotherCage = new AnotherCage(new Dog)

Answer 1

One difference is in the static type of animal parameter where in the former case it is typed as Animal whilst in latter case it is typed as Dog because the type parameter A is substituted with concrete type Dog . To see the difference try adding a sound method to Dog like so

class Animal
class Dog extends Animal {
  def sound = "woof"
}

class Cage(val animal: Animal)
val cage = new Cage(new Dog)

class AnotherCage[A <: Animal](val animal: A)
val anotherCage = new AnotherCage(new Dog)

cage.animal.sound         // error
anotherCage.animal.sound  // ok

Note how compiler is not aware of sound method in the first case despite the fact that the runtime class referenced by animal argument is Dog .

Parameterized types can provide stronger type-safety and help avoid the need for type casting with asInstanceOf . For example, let's say we have a Dog and a Cat

class Animal
class Dog extends Animal
class Cat extends Animal

and we define a method that opens only cages containing Dog s

def openDogCage(cage: Cage): Dog =
  if (cage.animal.isInstanceOf[Dog]) cage.animal.asInstanceOf[Dog]
  else throw new IllegalArgumentException

def openAnotherDogCage(cage: AnotherCage[Dog]): Dog = cage.animal

but erroneously provide a cage with a Cat

val dog: Dog = openDogCage(new Cage(new Cat))               // runtime error
val dog: Dog = openAnotherDogCage(new AnotherCage(new Cat)) // compile-time error

then notice how parameterzied types caught the error at compile-time before the program even ran. Also notice how in definition of openDogCage when using just subtyping we had to manually perform a type cast with asInstanceOf to convince the compiler that method returns a Dog .