1 - Cedric/CNAM
publicité
Sûreté de la programmation orientée objets La programmation orientée objets n’est pas intrinsèquement sûre. Toutefois, la plupart des langages orienté objets modernes reprenent plusieurs principes qui garantissent plus de sûreté : • le typage statique (Java, Scala, Swift, C#/F#) et l’inférence de types (Scala, Swift, C#/F#) • l’encapsulation des données privées (Java, Scala, Swift, C#/F#) − classes et inferfaces • la factorisation du code (Java, Scala, Swift, C#/F#) − classes abstraites − héritage − généricité (Java 5) • le paradigme fonctionnel-objet (Java 8, Scala, Swift, C#/F#) − collections immutables (Scala, Swift, C#) Paradigmes de programmation Collections Style mutables immutables impératif idéal ok impératif concurrent ko ok fonctionnel / idéal fonctionnel concurrent / idéal Style impératif : variables (mutables), procédures et instructions (sequence, boucles, ...) Style fonctionnel : constantes, fonctions et expressions Les langages fonctionnels • Ils n’ont pas de procédures, uniquement des fonctions. • Ils n’ont pas d’instructions, uniquement des expressions. Applications • Ils sont bien adaptés au prototypage d’applications, à l’écriture de compilateurs et au traitement symbolique. Le code est en général plus concis et plus facile à certifier. Variantes • Certains ont un typage statique (comme ML ou Scala) vérifié à la compilation, d’autres utilisent un typage dynamique (comme LISP/Scheme). • Certains sont purs (comme Haskell), les autres contiennent des traits impératifs (comme ML, Scala ou LISP/Scheme). → références, tableaux, exceptions... • Certains sont paresseux (comme Haskell). Ils calculent uniquement ce qui est nécéssaire. Le langage Scala From http://www.scala-lang.org “Object-Oriented Meets Functional Have the best of both worlds. Construct elegant class hierarchies for maximum code reuse and extensibility, implement their behavior using higher-order functions. Or anything in-between.” Scala in a Nutshell • SEAMLESS JAVA INTEROP • TYPE INFERENCE • CONCURRENCY & DISTRIBUTION • TRAITS • PATTERN MATCHING • HIGHER-ORDER FUNCTIONS Bibliographie A Scala Tutorial for Java Programmers http://www.scala-lang.org/docu/files/ScalaTutorial.pdf http://docs.scala-lang.org/tutorials/scala-for-java-programmers.html Autre tutoriels http://www.scala-lang.org/documentation • Brief Scala Tutorial: a 20 page introduction to scala and some of the basic concepts and a good place to start. You will find more code examples here. • Scala By Example: takes you through the Scala features with many examples. Existe aussi en français : http://www.scala-lang.org/docu/files/ScalaByExample-fr_FR.pdf • Scala Overview: this is a paper summarizing the features of the Scala Language in a formal and concise way. An excellent reference for language researchers or advanced programmers. Livres http://www.scala-lang.org/documentation/books.html Programming in Scala, 2nd ed. by Martin Odersky, Lex Spoon, and Bill Venners First edition available for free online reading: http://www.artima.com/pins1ed Types simples • Toutes les expressions Scala ont un type. • Les types de bases de Scala sont Int, Char, String, Boolean et Double. • A partir de valeurs de ces types de bases, il est possible de construire des expressions complexes en utilisant les couples (triplets...) et les listes. • Les listes sont homogènes : tous leurs éléments ont le même type. Exemples Produits (2,"Andrew") : (Int, String) (true,42,’x’) : (Boolean, Int, Char) ((4,2),(7,3)) : ((Int, Int), (Int, Int)) Listes List(1,2,3) : List[Int] List("Andrew","Ben") : List[String] List((2,3),(2,2),(9,1)) : List[(Int, Int)] List(Nil,List(1),List(1,2)) : List[List[Int]] Déclaration de constantes (mot clé val) Déclaration d’une constante scala> val a = 12; a: Int = 12 Déclaration d’un couple de constantes scala> val (d,e) = (2,"two"); d: Int = 2 e: String = two Inférence des types Le système infère lui-même le type des expressions, mais vous pouvez aussi les préciser (ils sont alors vérifié). scala> val a : Int = 65; a: Int = 65 scala> val a : String = 65; <console>:10: error: type mismatch; found : Int(65) required: String val a : String = 65; Fonctions (mot clé fun) scala> def double(x: Int) = 2 * x; double: (x: Int)Int scala> def inc(x: Int) = x + 1; inc: (x: Int)Int scala> def adda(s: String) = s ++ "a"; adda: (s: String)String Remarque. De même, le système infère le type des fonctions. Le typage est inféré et/ou vérifié à la compilation. Ce n’est pas du typage dynamique ! Fonctions et couples scala> def add(x: Int, y: Int) = x + y; add: (x: Int, y: Int)Int scala> def double0(x: Int) = (2 * x, 0) double0: (x: Int)(Int, Int) scala> def ab(x: String, y: String) = (x == "a", y == "b") ab: (x: String, y: String)(Boolean, Boolean) Utilisation scala> val (x,y) = double0(3); x: Int = 6 y: Int = 0 Pour ignorer une partie du résultat scala> val (k,_) = double0(3); k: Int = 6 Les listes • La liste vide peut s’écrire Nil ou List() • l’opérateur infixe :: ajoute un élément en tête de la liste. 1 Exemples Les expressions suivantes ont la même valeur à gauche et à droite : Nil List() 1::Nil List(1) 2::(1::Nil) List(2,1) 3::(2::(1::Nil)) List(3,2,1) 4::List(3,2,1) List(4,3,2,1) List(5,4,3) ++ List(2,1) List(5,4,3,2,1) Fonctions et listes scala> def f(x: Char, l: List[Char]) = (x::l); f: (x: Char, l: List[Char])List[Char] scala> def g(l1: List[Int], l2: List[Int]) = l1 ++ l2; g: (l1: List[Int], l2: List[Int])List[Int]
