Download to read offline
: A = xs(0)
• Subtype polymorphism
• def plus[A](a1: A, a2: A): A = ???
• trait Plus[A] {
def plus(a2: A): A
}
• def plus[A <: Plus[A]](a1: A, a2: A): A = a1.plus(a2)
• Ad-hoc polymorphism
• trait Plus[A] {
def plus(a1: A, a2: A): A
}
• def plus[A: Plus](a1: A, a2: A): A = implicitly[Plus[A]].plus(a1, a2)
Read more here: http://blog.jaceklaskowski.pl/2015/05/15/ad-hoc-polymorphism-in-scala-with-type-classes.html](https://image.slidesharecdn.com/cd72288c-c1c0-44f8-8abb-a7f228230ff7-151211115313/75/OOP-in-Scala-7-2048.jpg)
![Variance
• Variance annotations allow you to express the following relationships
between class hierarchies & polymorphic types:
Meaning Scala
notation
C# (only for
interfaces)
covariant C[T’] is a subclass of C[T] [+T] <outT>
contravariant C[T] is a subclass of C[T'] [-T] <inT>
invariant C[T] and C[T’] are not related [T] <T>](https://image.slidesharecdn.com/cd72288c-c1c0-44f8-8abb-a7f228230ff7-151211115313/75/OOP-in-Scala-8-2048.jpg)
Uploaded byRoman Melnyk
OOP in Scala
This document compares object-oriented programming concepts like encapsulation, inheritance, polymorphism, and variance in Scala and C#. Both languages support concepts like classes, interfaces, inheritance, and generics, but Scala allows traits like interfaces that can have concrete members, represents polymorphism through parametric, subtype, and ad-hoc polymorphism, and uses variance annotations to define relationships between type parameters. The document provides code examples to illustrate how these concepts are implemented in each language.
OOP in Scala
- 1. OOP in Scala Encapsulation,Inheritance, Polymorphism, abstractions and variances in comparison to C#
- 2. Agenda • Intro toScala as programming language • Encapsulation • Abstractions • Inheritance • Polymorphism • Variance • References
- 3. Short intro toScala vs C# Scala • Compiles to JavaByteCode (but Scala.js compiles to JavaScript) • Hybrid programming language (strong typing, imperative, declarative, functional, generic, object-oriented) C# • Compiles to MSIL • Hybrid programming language (strong typing, imperative, declarative, functional, generic, object- oriented)
- 4. Encapsulation • On Scala: classEncapsulation(hidden: Any, val readable: Any, var settable: Any) • Actually it transforms to next Java: public class Encapsulation { public java.lang.Object readable(); public java.lang.Object settable(); public void settable_$eq(java.lang.Object); public Encapsulation(java.lang.Object, java.lang.Object, java.lang.Object) } • On C#: class Emcapsulation{ object hidden; object readable; public Emcapsulation(object hidden, object readable, object settable) { hidden = hidden; readable = readable; Settable = settable; } public object Readable { get { return readable; } } public object Settable {get; set;} }
- 5. Abstractions • Class isan extensible program-code-template for creating objects, providing initial values for state (member variables) and implementations of behavior. • Object in Scala it's simply singleton. A class that can have only one instance. • Traits in Scala are best described as “interfaces that can provide concrete members.”
- 6. Inheritance Scala • One baseclass (incl. abstract) and many traits abstract class Window { // abstract def draw() } class SimpleWindow extends Window { def draw() { println("in SimpleWindow") // draw a basic window } C# • One base class (incl. abstract) and many Interfaces abstract class Window { // abstract public abstract void draw(); } class SimpleWindow: Window { public override void draw() { Console.WriteLine("in SimpleWindow"); // draw a basic window } }
- 7. Polymorphism • Parametric polymorphism(like Generics in C#) • def head[A](xs: List[A]): A = xs(0) • Subtype polymorphism • def plus[A](a1: A, a2: A): A = ??? • trait Plus[A] { def plus(a2: A): A } • def plus[A <: Plus[A]](a1: A, a2: A): A = a1.plus(a2) • Ad-hoc polymorphism • trait Plus[A] { def plus(a1: A, a2: A): A } • def plus[A: Plus](a1: A, a2: A): A = implicitly[Plus[A]].plus(a1, a2) Read more here: http://blog.jaceklaskowski.pl/2015/05/15/ad-hoc-polymorphism-in-scala-with-type-classes.html
- 8. Variance • Variance annotationsallow you to express the following relationships between class hierarchies & polymorphic types: Meaning Scala notation C# (only for interfaces) covariant C[T’] is a subclass of C[T] [+T] <outT> contravariant C[T] is a subclass of C[T'] [-T] <inT> invariant C[T] and C[T’] are not related [T] <T>
- 9. References • http://docs.scala-lang.org • https://twitter.github.io/scala_school/ •http://blog.jaceklaskowski.pl/2015/05/15/ad-hoc-polymorphism-in-scala- with-type-classes.html • http://www.scala-js.org
Editor's Notes
- #5 Getters and setters (or accessor/mutator methods) are used to encapsulate data, which is commonly considered one of the tenets of OOP. They exist so that the underlying implementation of an object can change without compromising client code, as long as the interface contract remains unchanged. This is a principle aiming to simplify maintenance and evolution of the codebase. Even Scala has encapsulation, but it supports the Uniform Access Principle by avoiding explicit use of get/set (a JavaBean convention) by automatically creating accessor/mutator methods that mimics the attribute name (e.g. for a public val name attribute a corresponding def name public accessor is generated and for a var name you also have the def name_= mutator method).
- #6 Scala is more object-oriented than Java because in Scala we cannot have static members. Instead, Scala has singleton objects. A singleton is a class that can have only one instance, i.e., object. You create singleton using the keyword object instead of class keyword. A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each class must inherit from just one superclass, a class can mix in any number of traits. Traits are used to define object types by specifying the signature of the supported methods. Scala also allows traits to be partially implemented but traits may not have constructor parameters.
- #8 In programming languages and type theory, polymorphism is the provision of a single interface to entities of different types. The difference between subtyping and parametric polymorphism and ad hoc polymorphism is that the type hierarchy is expressed explicitly using extends keyword in Scala (for subtyping) or type parameters (for parametric polymorphism) while ad hoc polymorphism bases itself on implicit classes to mixin the behaviour (using traits). And that’s pretty much all, technically. Parametric polymorphism refers to when the type of a value contains one or more (unconstrained) type variables, so that the value may adopt any type that results from substituting those variables with concrete types. ad hoc polymorphism is a kind of polymorphism in which polymorphic functions can be applied to arguments of different types, because a polymorphic function can denote a number of distinct and potentially heterogeneous implementations depending on the type of argument(s) to which it is applied.
- #9 Scala’s type system has to account for class hierarchies together with polymorphism. Class hierarchies allow the expression of subtype relationships. A central question that comes up when mixing OO with polymorphism is: if T’ is a subclass of T, is Container[T’] considered a subclass of Container[T]?