Programmation. fonctionnelle, impérative, logique et orientée objet
|
|
- Martin Chevalier
- il y a 8 ans
- Total affichages :
Transcription
1 Programmation fonctionnelle, impérative, logique et orientée objet
2 Introduction Les langages de programmation permettent de décrire des calculs de façon plus abstraite qu'un programme machine. Les programmes dans ces langages sont Compilés (transformés en code machine par un compilateur) Ou interprétés (exécutés par un autre programme appelé interpréteur) Un compilateur génère un programme machine pour un processeur donné, dont la sémantique est donnée par le programme source. Un interpréteur lit un programme source et «calcule» sa sémantique directement pour une entrée donnée
3 Compilation (C, Caml, Fortran...) Programme Compilateur (gcc, ocamlopt) Programme machine Le programme compilé est très efficace Entrées Processeur Programme machine Sorties Processeur Interprétation (Lisp) peu efficace Programme + entrées Interpréteur Processeur Sorties
4 Exemple de compilation : factorielle Bytecode Java int k = 1, l = 1; while (k <= i) { l = l * k; k++; } return l; 0: iconst_1 1: istore_2 2: iconst_1 3: istore_3 4: iload_2 5: iload_0 6: if_icmpgt 19 9: iload_3 10: iload_2 11: imul 12: istore_3 13: iinc 2, 1 16: goto 4 19: iload_3 20: ireturn
5 Compilation pour une machine virtuelle (Java, Caml,.Net) Programme Compilateur Processeur Programme bytecode Le programme est portable et moyennement efficace Programme bytecode + entrées Programme bytecode + entrées Machine virtuelle X Processeur X Machine virtuelle Y Sorties Sorties Processeur Y
6 Machine virtuelle Une machine virtuelle est un programme (compilé) qui exécute des programmes (appelés bytecode). En ce sens, c'est un interpréteur. Le langage d'entrée est proche d'un langage machine (d'où le nom de machine virtuelle). Les programmes à exécuter sont obtenus par compilation à partir d'un langage de haut niveau. Il y a autant de versions de la machine virtuelle (compilée) que de machines réelles différentes.
7 Conclusion (de l'introduction) Les compilateurs, interpréteurs, machines virtuelles se chargent : De l'interface avec une machine simple (processeur réel) des performances (en partie) de la portabilité (exécution sur différentes machines) Les langages de programmation offrent : une meilleure expressivité (moyens de structurer les programmes, de raisonner de façon plus abstraite) une spécialisation plus ou moins grande pour des types de problèmes (cas extrême : les langages dédiés) certaines garanties de correction, de sécurité, grâce à des concepts sémantiques forts (typage...)
8 Plan du cours Programmation fonctionnelle Exemples, ordre d'évaluation, exécution par interprétation, Programmation impérative Exemples, portée des identificateurs, gestion de la mémoire, compilation Typage et gestion de la mémoire typage statique (lambda calcul simplement typé), ramasse miettes Programmation orientée objet Exemples, modularité, héritage, liaison dynamique. Programmation logique Exemples, sémantique déclarative et opérationnelle
9 Portée des identificateurs La portée d'une définition (d'un identificateur) dans une expression est la partie de l'expression dans laquelle cette définition est active. En lambda calcul, c'est une notion purement syntaxique (donc pas liée à l'exécution). Dans ( x.e) e', x est lié à e' dans e, mais uniquement pour les occurrences libres de x dans e. De même pour let x = e' in e (les deux expressions sont d'ailleurs équivalentes) La portée est illustrée par la propriété suivante de la relation d'alphaéquivalence : si e ~ e' et e e'' alors il existe e''' tel que e'' ~ e''' et e' e''' Cela signifie qu'on peut voir considérer les lambda termes à alphaéquivalence près.
10 Extensions du lambda calcul On peut enrichir le lambda calcul avec Des entiers et des opérateurs : 0, 1,..., +, en étendant la bêtaréduction : (+ 2) 3 5 Des paires et des destructeurs : (.,.), fst, snd Des constructeurs, pour représenter les types sommes Des définitions de constantes locales : let x = e in e La condition : if e then e else e La récursivité : let rec f x =...f... Tous ces ajouts sont représentables en lambda calcul pur (cependant pour la récursivité, la terminaison dépend de l'ordre de réduction)
11 Programmation fonctionnelle
12 La programmation fonctionnelle pure se contente du lambdacalcul plus ou moins étendu (exemple : le langage Haskell). Les lambda termes clos représentent des fonctions au sens mathématique. Le résultat ne change pas d'un appel à l'autre, il ne dépend pas d'un quelconque «état» ou «contexte» autre que les arguments. Propriété de transparence référentielle : On peut toujours remplacer une expression par sa valeur. En particulier, une application de fonction peut être remplacée par son résultat, ou (par transitivité) par l'appel d'une autre fonction «équivalente» à la première. Intuitivement, seul le résultat compte (pas d'effets de bord).
13 Les fonctions sont des valeurs comme les autres : au cours de l'exécution on peut les créer, les appliquer, les retourner en résultat, les passer en argument d'autres fonctions. Les données ont le plus souvent une structure récursive (listes, arbres) ainsi que les fonctions qui les manipulent.
14 Bêta réduction et ordre de réduction Bêta réduction : réduction non déterministe la substitution e[e ' / x ]est licite x.e e' e [e' / x] e e' x.e x.e' e e' e e' ' e' e' ' e e' e ' ' e e' ' e' Caml : les arguments d'abord (non spécifié officiellement) x.e e' e[e ' / x] x.e est une forme normale e e' e e' ' e' e' ' e e' e ' ' e e' ' e' prioritaire par rapport aux deux autres règles Évaluation paresseuse (Haskell) : x.e e' e[e ' / x] remplacement sans recopie! x.e est une forme normale e e' e e' ' e' e' '
15 Ordre de réduction L'ordre d'évaluation n'a d'importance que pour : La terminaison (c'est au programmeur d'écrire des programmes qui terminent pour l'ordre considéré, mais cet ordre importe rarement) L'efficacité (certains chemins sont moins coûteux que d'autres) Les programmes impératifs (références, tableaux, entrées sorties). Évaluation en caml : opérandes d'abord Toute lambda abstraction est une valeur (ou forme normale) et n'est donc pas réduite (pensez aux effets de bord, ex : fun x > y := 0) Pour réduire (e e'), on réduit e' jusqu'à obtenir une lambdaabstraction, puis on réduit e, puis l'expression globale. Cette réduction est plus faible que la bêta réduction, (on ne réduit pas sous les lambda ) mais plus naturelle s'il y a des effets de bord. Évaluation paresseuse (en Haskell par exemple) : on ne réduit que les expressions indispensables, et au maximum une fois.
16 En caml : ( x. y.(+ x x)) (+ 1 1) (+ 2 2) ( x. y.(+ x x)) (+ 1 1) 4 ( x. y.(+ x x)) 2 4 ( y.(+ 2 2)) Évaluation paresseuse : (appel par nom) ( x. y.(+ x x)) (+ 1 1) (+ 2 2) ( y.+ ((+ 1 1) (+ 1 1))) (+ 2 2) on ne duplique pas réellement (+ 1 1) (+ 1 1) n'est jamais évalué
17 Un interpréteur simplissime Cette fonction évalue un terme clos (c'est à dire sans variable libre). let rec eval = function e e' let e'r = eval e' in let x.e'' = eval e in (* Sinon, on est bloqué *) eval e''[e'r / x] e e (* c'est une valeur *)
18 Pour éviter de faire des remplacements coûteux, on préfère évaluer un terme dans un contexte, qui associe des termes à des identificateurs : let rec eval c = function e e' let e'r = eval c e' in x c(x) e e let x.e'' = eval c e in eval [e'r / x] :: c e'' où [e'r / x] :: c est le contexte c enrichi par l'association de x e'r. Tout identificateur x déjà défini dans c est masqué temporairement (liaison statique). Remarque historique : si au lieu de masquer x, on le remplace, on obtient ce qui s'appelle la liaison dynamique (présente en Lisp). Ce principe contreintuitif remet en cause les bonnes propriétés du lambda calcul (confluence, renommage, etc.) et n'est plus utilisé (sauf pour les méthodes dans les langages à objets, dans un cadre bien défini).
19 Programmation impérative
20 L'impératif arrive avec les variables (pointeurs) et les effets de bord type 'a ref, val ref,!, := Les structures de contrôle permettent de structurer le flot d'exécution de façon intuitive. e ; e' while e do e done for x = e to e do e done En fait, on pourrait les programmer de façon récursive, connaissant l'ordre d'évaluation de Caml Les types de données associés à la programmation impérative sont les tableaux et les structures modifiables en place (à champs mutables). Les fonctions ne sont pas des données dans un langage impératif. Certaines fonctions ne retournent rien et ne sont utiles que par leurs effets de bord. On les appelle des procédures.
21 Structures de contrôle Le contrôle bas niveau de l'exécution (goto, jump_if_zero), n'est plus utilisé pour programmer (sauf dans certaines applications très spécifiques (code optimisé pour des pilotes...) et aussi par certains vieux physiciens... En revanche, les return, break, continue de Java peuvent simplifier certains algorithmes. Les exceptions permettent également de remonter brutalement dans la structure de contrôle, mais elles permettent de plus de fournir une valeur exceptionnelle, qu'on peut utiliser ensuite.
22 Portée En caml, les références et les tableaux sont des constantes comme les autres (sauf que l'opération! ne renvoie pas toujours le même résultat). La portée est donc toujours définie syntaxiquement comme l'expression sous le lambda ou le let... in... En C (et dans les autres langages impératifs), on a un tout petit peu moins de liberté : la portée peut être globale (tout le programme) locale à une fonction, à une boucle ou à un bloc (l'équivalent du let... in... : {int x ;...}) le masquage d'une déclaration par une autre est restreint. Du point de vue de la programmation, il convient de toujours donner aux déclarations la plus petite portée possible.
23 Compilation des langages impératifs En simplifiant à l'extrême (on oublie les données et les optimisations) la compilation consiste à transformer les structures de contrôle de haut niveau en branchements élémentaires compréhensibles par le processeur : While condition do corps i0 : condition... : condition i1 : jump_if_zero i2 i1+1 : corps... : corps i2 1 : goto i1 i2 : suite Les tableaux sont représentés par des adresses contiguës et on calcule l'adresse d'une case en ajoutant son indice à l'adresse du tableau. De même pour les types structures.
24 Typage et gestion de la mémoire
25 Lambda calcul simplement typé (présentation informelle) Les types : types de base (int, bool) ou variables de types types flèches : si t, t' sont des types, on forme t t' Les lambda termes typés : variables (x, y) applications : e e' où e, e' sont des lambda termes typés abstraction : x:t.e où t est un type et e un lambda terme typé Jugements de type : Г e : t où e est un terme, t un type et Г un contexte. (voir règles au tableau)
26 Sémantique Typage : les règles suivantes définissent le jugement x : t (x est de type t). x :t x :t, x :t e :t ' x : t.e: t t ' e :t t ' e ': t ee ': t ' Réduction : On choisi les mêmes règles que la bêta réduction, ou bien une stratégie d'évaluation particulière. la substitution e[e ' / x ]est licite x : t.e e' e[e ' / x ] e e' x : t.e x : t. e' e e' e e' ' e' e' ' e e' e ' ' e e' ' e' Aucun programme bien typé ne se bloque
27 Well typed programs never go wrong Les types assurent une certaine cohérence aux programmes. Dans un lambda calcul enrichi, cela se traduit par un théorème sur la réduction : Un programme bien typé ne peut se réduire qu'en un programme bien typé (préservation). Un programme bien typé ne peut être bloqué (progrès). Par exemple, les programmes (1 2), (plus true 0) et (1 := 2) sont bloqués. Dans la réalité, le bloquage se transforme en des opérations absurdes consistant confondre des entiers et des adresses en mémoire, et inventer des adresses qui ne correspondent à rien. Le typage peut aussi servir à prévenir les accès non autorisés à un système. La libération explicite de la mémoire (free) si elle est faite trop tôt, et la conversion de type (cast) cassent le système de types (formellement, la préservation). D'où une interdépendance avec le garbage collector.
28 D'après la propriété de préservation, il suffit de vérifier le typage avant exécution, et on peut l'oublier ensuite : le typage est statique. Parfois, dans les vrais langages, le typage n'est pas entièrement statique : on doit mettre des contraintes explicites qui sont vérifiées à l'exécution (ce qui est coûteux car il faut garder et manipuler des types à l'exécution). C'est le cas en Java (à nuancer avec Java 1.5 et ses classes génériques) : LinkedList s = new LinkedList(); s.add(new Element()); Element e = (Element) (s.getfirst()); Une alternative : les types génériques pour les fonctions et les structures de données. Ces types sont beaucoup plus compliqués à vérifier, surtout si on veut faire de l'inférence. type 'a list = Nil Cons of 'a * 'a list List.map : 'a 'b ('a > 'b) > 'a list > 'b list
29 Systèmes de types De nombreux langages possèdent : Des types de base : int, char, string, bool Des types pointeurs, tableaux, fonctions La possibilité de définir de nouveaux types produits (structures) Un système de types est le plus utile lorsqu'il est inviolable. Le langage C au contraire possède un système de types non sûr (pour de raisons de performances et de simplicité). Java, Caml, Haskell ont des systèmes de types sûrs. Lisp est un langage non typé.
30 Gestion de la mémoire Reprenons l'interpréteur avec contexte du lambda calcul : let rec eval c = function... x eval c (assoc c x)... Lorsqu'on doit évaluer x dans un environnement c, on ne va pas recopier la valeur associée à x dans le c : on se contente de retourner la même zone mémoire, en espérant qu'elle ne sera pas effacée... En effet, dans (( a.a)( b.b))(( c.c)( d.d)), il faut garder la valeur de c, à savoir ( d.d), même après l'avoir dépilée du contexte. En revanche, à la fin, la valeur de a n'a plus d'intérêt.
31 Le ramasse miettes La durée de vie d'un objet peut donc dépasser la portée des identificateur auxquels il peut être associé (il peut y en avoir plusieurs) lors de l'exécution. De plus, on ne peut pas décider statiquement si à tel point de programme un objet peut être libéré ou non (conséquence du théorème de Rice). On utilise donc un garbage collector : un programme qui, de temps en temps au cours de l'exécution du programme principal, regarde quels objets sont devenus inaccessibles, et les supprime pour récupérer de la mémoire. On sait que dans un langage muni d'un système de types sûr (propriété de préservation définie plus haut), un objet inaccessible l'est définitivement.
32 Programmation orientée objet
33 Objectif : associer données et traitements Les objets sont des valeurs qui contiennent à la fois un état (des données mutables) des méthodes qui font référence à l'état (de cet objet). On veut cacher les détails du fonctionnement interne (encapsulation) class Counter { private int i; public Counter {i = 0;} public int get() {return i;} public void incr() {i++;} } Une classe définit à la fois Un type d'objets Des moyens de construire des objets de ce type Leur comportement, de façon générique, au travers des méthodes.
34 Les éléments d'un langage objet Objets et classes : représentation de types de données abstraits Les objets : des super «records» Les classes : des modèles d'objets Héritage d'interfaces d'implémentation La liaison dynamique et la généricité et l'héritage
35 Composition d'un objet Des attributs d'instance (comme les champs d'un enregistrement) int n = 10 bool b = true,... Object x =... De méthodes d'instance (qui peuvent accéder aux attributs) void changenumero(int m) {n = m} (affectation) bool pair() {return (n mod 2 == 0);} bool greater(object o) {return (n >= o.n);} bool equals(object o) {return (greater(o) && o.equals(this));} int factorielle(int i) {if (i == 0) return 1; else return i*factorielle(i 1);} L'idée est de rapprocher les données et leurs opérations associées.
36 Composition d'une classe Une classe est un type (comme un type enregistrement) types des attributs d'instance : int n, bool b, Object o,... signatures des méthodes void changenumero(int), bool pair(),... Une classe est un modèle initialisation des attributs par un constructeur MaClasse(n, b, o) {this.n = n, this.b = this.b, this.o = o} corps des méthodes (les attributs sont différents pour chaque objet) void changenumero(int m) {n = m;}
37 Définition En Java Utilisation class Counter = { } int x; // un attribut Counter(x) {this.x = x;} // un constructeur Counter() {x = 0;} // un autre constructeur int value() {return x;} // une méthode void incr(int i) {x = x + i;} // une autre Counter c1, c2; c1 = new Counter(3); c2 = new Counter(4); c1.incr(2); int v; v = c2.value();... Remarques : Les méthodes sont implicitement mutuellement récursives this désigne l'objet «courant» surcharge : dans une même classe, deux méthodes peuvent avoir le même nom, à condition d'être distinguables par les types de leurs arguments. En Java, tout objet est construit à partir d'une classe, qui est aussi son type.
38 Champs et méthodes d'instance et de classe Les attributs et méthodes «ordinaires» sont dits d'instance class C {... int x;...} : un attribut x par objet de classe C class C {... int m();...} : une méthode m par objet de classe C Les attributs et méthodes de classe (appelés statiques en Java) existent en un seul exemplaire pour toute la classe. class C {... static int x;...} : un seul x pour toute la classe class C {... static int m();...} : une seule méthode m
39 Objets et modules sont bien adaptés à la description de types de données abstraits (ADT) : piles, arbres, tables, etc.. Dans la version orientée objet, toutefois, une version modifiable est plus souvent utilisée, pour correspondre au caractère impératif des langages à objets en général. module List = struct type 'a t val nil : 'a t val cons : 'a > 'a t > 'a t val head : 'a t > 'a } module List = struct type 'a t val empty : unit > 'a t val add : 'a > 'a t > unit val head : 'a t > 'a } modules class List { public static nil =... public List cons(object o) {...} public Object head() {...} } fonctionnel objets class List { impératif public List () {...} public void add(object o) {...} public Object head() {...} }
40 Liaison dynamique Que se passe t il lorsqu'on redéfinit une méthode qui était utilisée par une autre? class Counter { int x; void incr(int i) {x = x + i;} void incr1() {incr(1);} } class CounterModulo extends Counter { void incr(int i) {x = x + i % 2;} } Counter c = new CounterModulo(); c.incr1() ; c.incr1(); La liaison est dynamique : on ne connaît la méthode incr à appeler qu'au moment de l'exécution : c'est celle qui est définie dans la classe de l'objet c, c'est à dire CounterModulo. Autre exemple : Counter [] counters = {new Counter(), new CounterModulo()}; for (i = 0 ; i < 2 ; i++) counters[i].incr(); Il est impossible en général (indécidable), de savoir quelle méthode sera appelée effectivement.
41 Compatibilité et liaison dynamique Des objets qui partagent un certain nombre de méthodes (même nom, même signature) ont une certaine compatibilité : class List {... public void add(object o) {...} } class Set {... public void add(object o) {...} } L'intérêt des objets est qu'on peut appeler la méthode add d'un objet sans connaître son type exact (ce serait impossible avec des données simples et des fonctions add associées). Il s'agit d'une liaison dynamique (contrôlée).
42 Héritage Une interface en regroupe des signatures de méthodes qu'un objet doit posséder pour implémenter cette interface : c'est la notion de type pour les objets. L'héritage d'interface (sous typage) est un moyen d'étendre une interface en ajoutant des méthodes ; les objets qui implémentent une sous interface sont alors compatibles avec la super interface : interface Collection { public void add(object o); public bool isempty(); } interface List extends Collection { public Object get(int Index); }
43 Héritage L'héritage d'implémentation (simple) permet d'étendre une classe en une autre en lui ajoutant des attributs et des méthodes. Il permet le partage de méthodes entre différentes classes : class Counter { int x; void incr(int i) {x = x + i;} } class RazCounter extends Counter { void raz() {x = 0;} } class ProgramCounter extends Counter { Instruction [] prog; Instruction next() {return prog[x];} } Une classe peut utiliser les méthodes et attributs de sa super classe class UnCounter extends Counter { void decr(int i) {incr( i);} } Une classe peut redéfinir les méthodes de sa super classe class CounterModulo extends Counter { void incr(int i) {x = x + i % 2;} }
44 Héritage et liaison dynamique L'héritage d'implémentation est un bon moyen de réutiliser du code : une méthode héritée est partagée avec la super classe (La liaison dynamique joue un rôle important). class Collection { public abstract void add(object o); public void addall(collection c) { for(...) add(...); } } class List extends Collection { public void add(object o) {...} } class Set extends Collection { public void add(object o) {...} }
45 Compilation et exécution Contrairement au cas des langages impératifs, un appel de méthode dans un langage à objets ne peut pas toujours être résolu à la compilation (exemple de add). Il faut donc, à l'exécution, chercher la bonne méthode, qui peut se trouver dans la classe de l'objet, ou dans une super classe. On peut considérer du point de vue du langage que chaque objet possède ses propres méthodes (celles ci sont donc dupliquées autant de fois qu'il y a d'objets différents). Dans une implémentation efficace néanmoins, on ne crée qu'une seule fonction pour une classe et une méthode données, et l'objet this devient un argument supplémentaire.
46 Programmation logique
47 Programmation logique
48 Programmes logiques Une clause de Horn est une disjonction de formules atomiques dont au plus une est positive : p(f(x)) q r(f(x), g(x, f(x))) Une telle formule est logiquement équivalente à : p(f(x)) q r(f(x), g(x, f(x))) Et on la note en Prolog : p(f(x)) :- q, r(f(x),g(x, f(x))) Un programme logique est un ensemble fini de clauses de Horn.
49 Exemples est_triee(cons(x, cons(y, L))) : inf(x, Y), est_triee(cons(y, L)). est_triee(nil). est_triee(cons(x, nil)). Pair(0). impair(s(x)) : pair(x). pair(s(x)) : impair(x). plus(x, 0, X). plus(x, s(y), s(z)) : plus(x, Y, Z).
50 La négation Il n'y a pas de vraie négation en prolog (impossible à définir avec des clauses de Horn). On peut cependant y parvenir en essayant de prouver un but et en vérifiant qu'il n'y a pas de solution. C'est la négation par l'échec. Évidemment, le prédicat de départ doit être fait pour terminer même s'il n'y a pas de solution.
51 Exécution Pour exécuter un programme Prolog, on se donne un but, qui est une conjonction de formules atomiques (non closes) : plus(s(0), s(s(0)), X) Ou encore pair(x) L'interpréteur retourne alors une (ou des) substitution(s) qui rend(ent) ce but prouvable (s'il en existe). X = s(s(s(0))) X = 0, X = 2, X = 4,...
52 Sémantique déclarative Un programme logique définit une théorie (l'ensemble des conséquences des formules du programme). Pour un but donné, un programme logique peut boucler, ou bien s'arrêter. Dans les deux cas, il peut rendre zéro ou plusieurs substitutions. Toute substitution rendue par le programme (même s'il boucle après) fait du but une conséquence de la théorie. Si le programme termine, alors toutes les conséquences qui ont la forme du but ont été énumérées.
53 Sémantique opérationnelle Prolog procède par résolution linéaire directe pour les clauses de Horn. C'est une méthode de preuve correcte et complète, d'où les deux propriétés de la sémantique déclarative. Principe : On commence par chercher la première clause du programme dont la tête s'unifie avec le but courant. On applique alors la substitution obtenue à la queue de la clause On cherche alors à prouver (de gauche à droite) les prémices de cette clause (qui deviennent tour à tour le but courant). Lorsqu'on est bloqué dans une impasse, on revient en arrière, pour essayer une autre clause. Ce faisant, on construit (par les unifications successives) une substitution qui rend le but prouvable.
54 Intérêt et défauts Prolog est un langage adapté à la recherche de solutions (Sudoku?), pour faire de l'inférence de type, etc. Les prédicats du programme jouent le rôle de fonctions, qu'on peut appeler de différentes façons : plus peut servir pour l'addition et la soustraction, selon l'instanciation des paramètres. L'impératif s'intègre plutôt mal (car l'ordre d'évaluation est difficile à prévoir), ce qui peut poser problème pour les entréessorties et l'interface avec d'autres langages. L'absence de déclaration préalable des symboles de fonctions et de prédicats est une source importante d'erreurs (Il existe des versions typées de Prolog cependant).
55 Conclusion : les défis de la programmation aujourd'hui La programmation parallèle, qu'on n'a pas abordée, est souvent très délicate et suscite également à elle seule de nombreux paradigmes de programmation (passage de messages ou partage de données, etc.). Les besoins sont croissants (grappes de processeurs, processeurs à plusieurs coeurs).
56 Conclusion : les défis de la programmation aujourd'hui Le génie logiciel : programming in the large. Écrire de gros programmes pose depuis des décennies des problèmes fondamentalement différents : organisation, évolution (maintenance), réutilisation La maîtrise de la programmation orientée objet, générique, par composants, par aspects... aide à résoudre ces problèmes.
57 Conclusion : les défis de la programmation aujourd'hui La sûreté de fonctionnement des logiciels est loin d'être une question résolue. Des techniques élaborées de test, d'analyse automatique, voire de preuve formelle avec un assistant, sont autant de domaines de recherches. Bien entendu, les paradigmes, et mêmes les langages de programmation utilisés influencent beaucoup les possibilités.
58 Un peu de lambda calcul
59 Syntaxe du lambda calcul (on ajoutera des parenthèses quand c'est nécessaire pour lever les ambiguïtés) e = x (identificateur) x.e (lambda abstraction) ee (application) Exemple : x. y.(xy) (en caml : fun x > fun y > x y)
60 Occurrences libres Dans ( x.x) x, le second x est une occurrence liée de l'identificateur x ; le troisième est une occurrence libre. Remplacement On note e[e' / x] le terme obtenu en remplaçant simultanément toutes les occurrences libres de x par e' dans e Exemple : ( x.x)x [( y.yy) / x] = ( x.x)( y.yy) Une substitution est licite si aucune variable libre du terme e' n'est capturée par un lambda de e Exemple : ( x.y) [x / y] n'est pas licite.
61 Alpha équivalence (renommage) si y n'a pas d'occurrence libre dans e alors x.e ~ y.e[y / x] si e ~ e' alors x.e ~ x.e' si f ~ f' et e ~ e' alors f e ~ f' e' on prend la fermeture symétrique réflexive transitive L'alpha équivalence permet de renommer un identificateur, en évitant le phénomène de capture : x. y.xy est équivalent à x. z.xz, mais pas à x. x.xx (car x a une occurrence libre dans xy)
62 Bêta réduction Exemple : si la substitution e[e' / x] est licite alors ( x.e) e' e[e' / x] si e e' alors x.e x.e' si e e' alors e e'' e' e'' et e'' e e'' e' (( x. y.xy) ( x.x)) t ( y.( x.x)y) t ( x.x)t t ou bien ( y.( x.x)y) t ( y.y)t t Confluence : L'ordre de réduction ne change pas le résultat : il ne peut y avoir qu'une seule forme irréductible d'un lambda terme (mais parfois certains chemins peuvent terminer et d'autres non). Le lambda terme suivant se réduit indéfiniment. ( x.xx)( x.xx) ( x.xx)( x.xx)...
Pour signifier qu'une classe fille hérite d'une classe mère, on utilise le mot clé extends class fille extends mère
L'héritage et le polymorphisme en Java Pour signifier qu'une classe fille hérite d'une classe mère, on utilise le mot clé extends class fille extends mère En java, toutes les classes sont dérivée de la
Plus en détailTP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile
TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile Dans ce TP, vous apprendrez à définir le type abstrait Pile, à le programmer en Java à l aide d une interface
Plus en détailÉvaluation et implémentation des langages
Évaluation et implémentation des langages Les langages de programmation et le processus de programmation Critères de conception et d évaluation des langages de programmation Les fondations de l implémentation
Plus en détailCours 1 : La compilation
/38 Interprétation des programmes Cours 1 : La compilation Yann Régis-Gianas yrg@pps.univ-paris-diderot.fr PPS - Université Denis Diderot Paris 7 2/38 Qu est-ce que la compilation? Vous avez tous déjà
Plus en détailGénéralités sur le Langage Java et éléments syntaxiques.
Généralités sur le Langage Java et éléments syntaxiques. Généralités sur le Langage Java et éléments syntaxiques....1 Introduction...1 Genéralité sur le langage Java....1 Syntaxe de base du Langage...
Plus en détailChapitre 2. Classes et objets
Chapitre 2: Classes et Objets 1/10 Chapitre 2 Classes et objets Chapitre 2: Classes et Objets 2/10 Approche Orientée Objet Idée de base de A.O.O. repose sur l'observation de la façon dont nous procédons
Plus en détailHéritage presque multiple en Java (1/2)
Héritage presque multiple en Java (1/2) Utiliser deux classes ou plus dans la définition d'une nouvelle classe peut se faire par composition. class Etudiant{ int numero; Diplome d; float passeexamen(examen
Plus en détailChapitre VI- La validation de la composition.
Chapitre VI- La validation de la composition. Objectifs du chapitre : Expliquer les conséquences de l utilisation de règles de typage souples dans SEP. Présenter le mécanisme de validation des connexions
Plus en détailINITIATION AU LANGAGE C SUR PIC DE MICROSHIP
COURS PROGRAMMATION INITIATION AU LANGAGE C SUR MICROCONTROLEUR PIC page 1 / 7 INITIATION AU LANGAGE C SUR PIC DE MICROSHIP I. Historique du langage C 1972 : naissance du C dans les laboratoires BELL par
Plus en détailCours intensif Java. 1er cours: de C à Java. Enrica DUCHI LIAFA, Paris 7. Septembre 2009. Enrica.Duchi@liafa.jussieu.fr
. Cours intensif Java 1er cours: de C à Java Septembre 2009 Enrica DUCHI LIAFA, Paris 7 Enrica.Duchi@liafa.jussieu.fr LANGAGES DE PROGRAMMATION Pour exécuter un algorithme sur un ordinateur il faut le
Plus en détailRappel. Analyse de Données Structurées - Cours 12. Un langage avec des déclaration locales. Exemple d'un programme
Rappel Ralf Treinen Université Paris Diderot UFR Informatique Laboratoire Preuves, Programmes et Systèmes treinen@pps.univ-paris-diderot.fr 6 mai 2015 Jusqu'à maintenant : un petit langage de programmation
Plus en détailInitiation à JAVA et à la programmation objet. raphael.bolze@ens-lyon.fr
Initiation à JAVA et à la programmation objet raphael.bolze@ens-lyon.fr O b j e c t i f s Découvrir un langage de programmation objet. Découvrir l'environnement java Découvrir les concepts de la programmation
Plus en détailUne introduction à Java
Une introduction à Java IFT 287 (Semaine 1) UNIVERSITÉ DE SHERBROOKE 1 Java - Historique Développé par Sun Microsystems en 1994 Inventeur James Gosling (canadien!) Objectif langage sûr (fortement typé)
Plus en détailVérification formelle de la plate-forme Java Card
Vérification formelle de la plate-forme Java Card Thèse de doctorat Guillaume Dufay INRIA Sophia Antipolis Cartes à puce intelligentes Java Card : Environnement de programmation dédié. Dernières générations
Plus en détailRecherche dans un tableau
Chapitre 3 Recherche dans un tableau 3.1 Introduction 3.1.1 Tranche On appelle tranche de tableau, la donnée d'un tableau t et de deux indices a et b. On note cette tranche t.(a..b). Exemple 3.1 : 3 6
Plus en détailCours 1 : Introduction. Langages objets. but du module. contrôle des connaissances. Pourquoi Java? présentation du module. Présentation de Java
Langages objets Introduction M2 Pro CCI, Informatique Emmanuel Waller, LRI, Orsay présentation du module logistique 12 blocs de 4h + 1 bloc 2h = 50h 1h15 cours, 45mn exercices table, 2h TD machine page
Plus en détailINTRODUCTION A JAVA. Fichier en langage machine Exécutable
INTRODUCTION A JAVA JAVA est un langage orienté-objet pur. Il ressemble beaucoup à C++ au niveau de la syntaxe. En revanche, ces deux langages sont très différents dans leur structure (organisation du
Plus en détailClasses et Objets en Ocaml.
Classes et Objets en Ocaml. Didier Rémy 2001-2002 http://cristal.inria.fr/ remy/mot/2/ http://www.enseignement.polytechnique.fr/profs/informatique/didier.remy/mot/2/ Cours Exercices Slide 1 1. Objets 2.
Plus en détaillength : A N add : Z Z Z (n 1, n 2 ) n 1 + n 2
1 Univ. Lille1 - Licence info 3ème année 2013-2014 Expression Logique et Fonctionnelle... Évidemment Cours n o 1 : Introduction à la programmation fonctionnelle 1 Introduction La programmation fonctionnelle
Plus en détailTraduction des Langages : Le Compilateur Micro Java
BARABZAN Jean-René OUAHAB Karim TUCITO David 2A IMA Traduction des Langages : Le Compilateur Micro Java µ Page 1 Introduction Le but de ce projet est d écrire en JAVA un compilateur Micro-Java générant
Plus en détailProgrammer en JAVA. par Tama (tama@via.ecp.fr( tama@via.ecp.fr)
Programmer en JAVA par Tama (tama@via.ecp.fr( tama@via.ecp.fr) Plan 1. Présentation de Java 2. Les bases du langage 3. Concepts avancés 4. Documentation 5. Index des mots-clés 6. Les erreurs fréquentes
Plus en détailGrandes lignes ASTRÉE. Logiciels critiques. Outils de certification classiques. Inspection manuelle. Definition. Test
Grandes lignes Analyseur Statique de logiciels Temps RÉel Embarqués École Polytechnique École Normale Supérieure Mercredi 18 juillet 2005 1 Présentation d 2 Cadre théorique de l interprétation abstraite
Plus en détailC++ COURS N 2 : CLASSES, DONNÉES ET FONCTIONS MEMBRES Classes et objets en C++ Membres d'une classe Spécification d'une classe Codage du comportement
C++ COURS N 2 : CLASSES, DONNÉES ET FONCTIONS MEMBRES Classes et objets en C++ Membres d'une classe Spécification d'une classe Codage du comportement des objets d'une classe Utilisation d'une classe Droit
Plus en détailInstitut Supérieure Aux Etudes Technologiques De Nabeul. Département Informatique
Institut Supérieure Aux Etudes Technologiques De Nabeul Département Informatique Support de Programmation Java Préparé par Mlle Imene Sghaier 2006-2007 Chapitre 1 Introduction au langage de programmation
Plus en détailCours No 3 : Identificateurs, Fonctions, Premières Structures de contrôle.
Université Montpellier-II UFR des Sciences - Département Informatique - Licence Informatique UE GLIN302 - Programmation Applicative et Récursive Cours No 3 : Identificateurs, Fonctions, Premières Structures
Plus en détailCours de Programmation 2
Cours de Programmation 2 Programmation à moyenne et large échelle 1. Programmation modulaire 2. Programmation orientée objet 3. Programmation concurrente, distribuée 4. Programmation monadique 5. Les programmes
Plus en détailPrénom : Matricule : Sigle et titre du cours Groupe Trimestre INF1101 Algorithmes et structures de données Tous H2004. Loc Jeudi 29/4/2004
Questionnaire d'examen final INF1101 Sigle du cours Nom : Signature : Prénom : Matricule : Sigle et titre du cours Groupe Trimestre INF1101 Algorithmes et structures de données Tous H2004 Professeur(s)
Plus en détailAlgorithmique et Programmation, IMA
Algorithmique et Programmation, IMA Cours 2 : C Premier Niveau / Algorithmique Université Lille 1 - Polytech Lille Notations, identificateurs Variables et Types de base Expressions Constantes Instructions
Plus en détailAnalyse de sécurité de logiciels système par typage statique
Contexte Modélisation Expérimentation Conclusion Analyse de sécurité de logiciels système par typage statique Application au noyau Linux Étienne Millon UPMC/LIP6 Airbus Group Innovations Sous la direction
Plus en détailLMI 2. Programmation Orientée Objet POO - Cours 9. Said Jabbour. jabbour@cril.univ-artois.fr www.cril.univ-artois.fr/~jabbour
LMI 2 Programmation Orientée Objet POO - Cours 9 Said Jabbour jabbour@cril.univ-artois.fr www.cril.univ-artois.fr/~jabbour CRIL UMR CNRS 8188 Faculté des Sciences - Univ. Artois Février 2011 Les collections
Plus en détailPlan. Exemple: Application bancaire. Introduction. OCL Object Constraint Language Le langage de contraintes d'uml
OCL Object Constraint Language Le langage de contraintes d'uml Plan 1. Introduction 2. Les principaux concepts d'ocl Object Constraint Language 1 Object Constraint Language 2 Exemple: une application bancaire
Plus en détailJava Licence Professionnelle CISII, 2009-10
Java Licence Professionnelle CISII, 2009-10 Cours 4 : Programmation structurée (c) http://www.loria.fr/~tabbone/cours.html 1 Principe - Les méthodes sont structurées en blocs par les structures de la programmation
Plus en détailConception des systèmes répartis
Conception des systèmes répartis Principes et concepts Gérard Padiou Département Informatique et Mathématiques appliquées ENSEEIHT Octobre 2012 Gérard Padiou Conception des systèmes répartis 1 / 37 plan
Plus en détailI. Introduction aux fonctions : les fonctions standards
Chapitre 3 : Les fonctions en C++ I. Introduction aux fonctions : les fonctions standards A. Notion de Fonction Imaginons que dans un programme, vous ayez besoin de calculer une racine carrée. Rappelons
Plus en détailEncapsulation. L'encapsulation consiste à rendre les membres d'un objet plus ou moins visibles pour les autres objets.
Encapsulation L'encapsulation consiste à rendre les membres d'un objet plus ou moins visibles pour les autres objets. La visibilité dépend des membres : certains membres peuvent être visibles et d'autres
Plus en détailPolymorphisme, la classe Object, les package et la visibilité en Java... 1
Polymorphisme, la classe Object, les package et la visibilité en Java. Polymorphisme, la classe Object, les package et la visibilité en Java.... 1 Polymorphisme.... 1 Le DownCast... 4 La Classe Object....
Plus en détailP r ob lé m a t iq u e d e la g é n é r icit é. Pr in cip e d e la g é n é r icit é e n Ja v a ( 1 /3 )
P r ob lé m a t iq u e d e la g é n é r icit é les versions de Java antérieures à 1.5 permettaient de créer des classes de structures contenant n'importe quels types d'objet : les collections (classes
Plus en détailIntroduction à Java. Matthieu Herrb CNRS-LAAS. Mars 2014. http://homepages.laas.fr/matthieu/cours/java/java.pdf
Introduction à Java Matthieu Herrb CNRS-LAAS http://homepages.laas.fr/matthieu/cours/java/java.pdf Mars 2014 Plan 1 Concepts 2 Éléments du langage 3 Classes et objets 4 Packages 2/28 Histoire et motivations
Plus en détailStructure d un programme et Compilation Notions de classe et d objet Syntaxe
Cours1 Structure d un programme et Compilation Notions de classe et d objet Syntaxe POO 1 Programmation Orientée Objet Un ensemble d objet qui communiquent Pourquoi POO Conception abstraction sur les types
Plus en détailLambda! Rémi Forax Univ Paris-Est Marne-la-Vallée
Lambda! Rémi Forax Univ Paris-Est Marne-la-Vallée forax at univ-mlv dot fr - ParisJUG Java.next() - Mars 2012 What Else? Lambda == Inner class? Java a des lambdas depuis la version 1.1 Exemple utilisant
Plus en détailLicence Bio Informatique Année 2004-2005. Premiers pas. Exercice 1 Hello World parce qu il faut bien commencer par quelque chose...
Université Paris 7 Programmation Objet Licence Bio Informatique Année 2004-2005 TD n 1 - Correction Premiers pas Exercice 1 Hello World parce qu il faut bien commencer par quelque chose... 1. Enregistrez
Plus en détailPlan du cours. Historique du langage http://www.oracle.com/technetwork/java/index.html. Nouveautés de Java 7
Université Lumière Lyon 2 Faculté de Sciences Economiques et Gestion KHARKIV National University of Economic Introduction au Langage Java Master Informatique 1 ère année Julien Velcin http://mediamining.univ-lyon2.fr/velcin
Plus en détailConventions d écriture et outils de mise au point
Logiciel de base Première année par alternance Responsable : Christophe Rippert Christophe.Rippert@Grenoble-INP.fr Introduction Conventions d écriture et outils de mise au point On va utiliser dans cette
Plus en détailIN 102 - Cours 1. 1 Informatique, calculateurs. 2 Un premier programme en C
IN 102 - Cours 1 Qu on le veuille ou non, les systèmes informatisés sont désormais omniprésents. Même si ne vous destinez pas à l informatique, vous avez de très grandes chances d y être confrontés en
Plus en détailJava 1.5 : principales nouveautés
Cours 6 - TEP - UPMC - 2008/2009 p. 1/34 Java 1.5 : principales nouveautés classes paramétrées : generics encapsulation des valeurs de types primitifs : auto[un]boxing itération sur les boucles types énumérés
Plus en détailClasse ClInfoCGI. Fonctions membres principales. Gestion des erreurs
Utilisation des classes de PourCGI par Michel Michaud, version 2002-11-23 Les fichiers PourCGI.h et PourCGI.cpp rendent disponibles deux classes et une fonction libre qui permettent de faire facilement
Plus en détailINITIATION AU LANGAGE JAVA
INITIATION AU LANGAGE JAVA I. Présentation 1.1 Historique : Au début des années 90, Sun travaillait sur un projet visant à concevoir des logiciels simples et performants exécutés dans des PDA (Personnal
Plus en détailMachines virtuelles fonctionnelles (suite) Compilation ML Java
Machines virtuelles fonctionnelles (suite) Compilation ML Java Cours de Compilation Avancée (MI190) Benjamin Canou Université Pierre et Maire Curie Année 2011/2012 Semaine 3 Machines virtuelles fonctionnelles
Plus en détailObjets et Programmation. origine des langages orientés-objet
Objets et Programmation origine des langages orientés-objet modularité, encapsulation objets, classes, messages exemples en Java héritage, liaison dynamique G. Falquet, Th. Estier CUI Université de Genève
Plus en détailUtilisation d objets : String et ArrayList
Chapitre 6 Utilisation d objets : String et ArrayList Dans ce chapitre, nous allons aborder l utilisation d objets de deux classes prédéfinies de Java d usage très courant. La première, nous l utilisons
Plus en détailTP1 : Initiation à Java et Eclipse
TP1 : Initiation à Java et Eclipse 1 TP1 : Initiation à Java et Eclipse Systèmes d Exploitation Avancés I. Objectifs du TP Ce TP est une introduction au langage Java. Il vous permettra de comprendre les
Plus en détailLangage Java. Classe de première SI
Langage Java Table des matières 1. Premiers pas...2 1.1. Introduction...2 1.2. Mon premier programme...2 1.3. Les commentaires...2 2. Les variables et les opérateurs...2 3. La classe Scanner...3 4. Les
Plus en détailTravaux pratiques. Compression en codage de Huffman. 1.3. Organisation d un projet de programmation
Université de Savoie Module ETRS711 Travaux pratiques Compression en codage de Huffman 1. Organisation du projet 1.1. Objectifs Le but de ce projet est d'écrire un programme permettant de compresser des
Plus en détailFacultés Universitaires Notre-Dame de la Paix. Conception et Programmation Orientées- Object
Facultés Universitaires Notre-Dame de la Paix Conception et Programmation Orientées- Object 2008-2009 RÉSUMÉ PRATIQUE... 4 CLASSE OBJET... 4 NOTION D HÉRITAGE... 4 LE POLYMORPHISME... 5 LES CLASSES ABSTRAITES...
Plus en détailProgrammation par les Objets en Java
Programmation par les Objets en Java Najib TOUNSI Les classes en Java (TD 3) I. Notion de classe I.1 Classe, champs, méthodes, instanciation, this, private vs. public. Créer une classe Point (coordonnée
Plus en détailBases de programmation. Cours 5. Structurer les données
Bases de programmation. Cours 5. Structurer les données Pierre Boudes 1 er décembre 2014 This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License. Types char et
Plus en détailPlan du cours : Zippers. Des fonctions sur les listes avec position. Des fonctions sur les listes avec position
Plan du cours : Le problème : naviguer efficacement une structure de données Ce qui ne marche pas Ce qui marche : les de Huet Exemples Comment dériver des pour tout type de données Pour en savoir plus
Plus en détailInfo0101 Intro. à l'algorithmique et à la programmation. Cours 3. Le langage Java
Info0101 Intro. à l'algorithmique et à la programmation Cours 3 Le langage Java Pierre Delisle, Cyril Rabat et Christophe Jaillet Université de Reims Champagne-Ardenne Département de Mathématiques et Informatique
Plus en détailGénie Logiciel avec Ada. 4 février 2013
Génie Logiciel 4 février 2013 Plan I. Généralités II. Structures linéaires III. Exceptions IV. Structures arborescentes V. Dictionnaires I. Principes II. Notions propres à la POO I. Principes Chapitre
Plus en détailChapitre 1 : Introduction aux bases de données
Chapitre 1 : Introduction aux bases de données Les Bases de Données occupent aujourd'hui une place de plus en plus importante dans les systèmes informatiques. Les Systèmes de Gestion de Bases de Données
Plus en détailCours d Algorithmique-Programmation 2 e partie (IAP2): programmation 24 octobre 2007impérative 1 / 44 et. structures de données simples
Cours d Algorithmique-Programmation 2 e partie (IAP2): programmation impérative et structures de données simples Introduction au langage C Sandrine Blazy - 1ère année 24 octobre 2007 Cours d Algorithmique-Programmation
Plus en détailTp 1 correction. Structures de données (IF2)
Tp 1 correction Structures de données (IF2) Remarque générale : compilez et exécutez le code au-fur-et-à mesure de son écriture. Il est plus facile de corriger une petite portion de code délimitée que
Plus en détailas Architecture des Systèmes d Information
Plan Plan Programmation - Introduction - Nicolas Malandain March 14, 2005 Introduction à Java 1 Introduction Présentation Caractéristiques Le langage Java 2 Types et Variables Types simples Types complexes
Plus en détailMachines Virtuelles. et bazard autour. Rémi Forax
Machines Virtuelles et bazard autour Rémi Forax Avant propos Quelle est la complexité du code ci-dessous? Avec un processeur à 1Ghz, combien de temps le calcul prendra t'il? public static void main(string[]
Plus en détailC++ Programmer. en langage. 8 e édition. Avec une intro aux design patterns et une annexe sur la norme C++11. Claude Delannoy
Claude Delannoy Programmer en langage C++ 8 e édition Avec une intro aux design patterns et une annexe sur la norme C++11 Groupe Eyrolles, 1993-2011. Groupe Eyrolles, 2014, pour la nouvelle présentation,
Plus en détailDiagramme de classes
Diagramme de classes Un diagramme de classes décrit les classes et leurs relations (associations, généralisation/spécialisation, ). classe association méthodes attributs héritage Diagramme de classes :
Plus en détailProgrammation Objet Java Correction
INSA - 4 AE 2007 2008 Durée : 1H00 Contrôle Programmation Objet Java Correction Consignes Tous les documents sont autorisés, mais ils seront peu utiles. Indiquez vos nom et prénom sur chaque feuille. Le
Plus en détailSHERLOCK 7. Version 1.2.0 du 01/09/09 JAVASCRIPT 1.5
SHERLOCK 7 Version 1.2.0 du 01/09/09 JAVASCRIPT 1.5 Cette note montre comment intégrer un script Java dans une investigation Sherlock et les différents aspects de Java script. S T E M M E R I M A G I N
Plus en détailJava Licence Professionnelle 2009-2010. Cours 7 : Classes et méthodes abstraites
Java Licence Professionnelle 2009-2010 Cours 7 : Classes et méthodes abstraites 1 Java Classes et méthodes abstraites - Le mécanisme des classes abstraites permet de définir des comportements (méthodes)
Plus en détailMachines virtuelles Cours 1 : Introduction
Machines virtuelles Cours 1 : Introduction Pierre Letouzey 1 pierre.letouzey@inria.fr PPS - Université Denis Diderot Paris 7 janvier 2012 1. Merci à Y. Régis-Gianas pour les transparents Qu est-ce qu une
Plus en détail4. Groupement d objets
Conception objet en Java avec BlueJ une approche interactive 4. Groupement d objets Collections et itérateurs David J. Barnes, Michael Kölling version française: Patrice Moreaux Rédigé avec 1.0 Principaux
Plus en détailCours d Algorithmique et de Langage C 2005 - v 3.0
Cours d Algorithmique et de Langage C 2005 - v 3.0 Bob CORDEAU cordeau@onera.fr Mesures Physiques IUT d Orsay 15 mai 2006 Avant-propos Avant-propos Ce cours en libre accès repose sur trois partis pris
Plus en détailCours de Génie Logiciel
Cours de Génie Logiciel Sciences-U Lyon Diagrammes UML (2) http://www.rzo.free.fr Pierre PARREND 1 Avril 2005 Sommaire Les Diagrammes UML Diagrammes de Collaboration Diagrammes d'etats-transitions Diagrammes
Plus en détailConception de circuits numériques et architecture des ordinateurs
Conception de circuits numériques et architecture des ordinateurs Frédéric Pétrot Année universitaire 2014-2015 Structure du cours C1 C2 C3 C4 C5 C6 C7 C8 C9 C10 C11 Codage des nombres en base 2, logique
Plus en détailIntroduction à la programmation orientée objet, illustrée par le langage C++ Patrick Cégielski cegielski@u-pec.fr
Introduction à la programmation orientée objet, illustrée par le langage C++ Patrick Cégielski cegielski@u-pec.fr Mars 2002 Pour Irène et Marie Legal Notice Copyright c 2002 Patrick Cégielski Université
Plus en détailInitiation à la programmation en Python
I-Conventions Initiation à la programmation en Python Nom : Prénom : Une commande Python sera écrite en caractère gras. Exemples : print 'Bonjour' max=input("nombre maximum autorisé :") Le résultat de
Plus en détailRMI le langage Java XII-1 JMF
Remote Method Invocation (RMI) XII-1 Introduction RMI est un ensemble de classes permettant de manipuler des objets sur des machines distantes (objets distants) de manière similaire aux objets sur la machine
Plus en détailSuivant les langages de programmation, modules plus avancés : modules imbriqués modules paramétrés par des modules (foncteurs)
Modularité Extensions Suivant les langages de programmation, modules plus avancés : modules imbriqués modules paramétrés par des modules (foncteurs) généricité modules de première classe : peuvent être
Plus en détailLicence ST Université Claude Bernard Lyon I LIF1 : Algorithmique et Programmation C Bases du langage C 1 Conclusion de la dernière fois Introduction de l algorithmique générale pour permettre de traiter
Plus en détailPremiers Pas en Programmation Objet : les Classes et les Objets
Chapitre 2 Premiers Pas en Programmation Objet : les Classes et les Objets Dans la première partie de ce cours, nous avons appris à manipuler des objets de type simple : entiers, doubles, caractères, booléens.
Plus en détailSeance 2: En respectant la méthode de programmation par contrat, implémentez les autres fonctions de jeu.
Seance 2: Complétion du code de jeu. (durée max: 2h) Mot clé const et pointeurs: En respectant la méthode de programmation par contrat, implémentez les autres fonctions de jeu. Implémentez jeu_recupere_piece
Plus en détailPackage Java.util Classe générique
Package Java.util Classe générique 1 Classe Vector La taille est dynamique: dès qu un tableau vectoriel est plein, sa taille est doublée, triplée, etc. automatiquement Les cases sont de type Object add(object
Plus en détailRAPPELS SUR LES METHODES HERITEES DE LA CLASSE RACINE Object ET LEUR SPECIALISATION (i.e. REDEFINITION)
CLASSE RACINE Object ancêtre de toutes les classes RAPPELS SUR LES METHODES HERITEES DE LA CLASSE RACINE Object ET LEUR SPECIALISATION (i.e. REDEFINITION) définit donc des méthodes héritées par toutes
Plus en détailUniversité de Bangui. Modélisons en UML
Université de Bangui CRM Modélisons en UML Ce cours a été possible grâce à l initiative d Apollinaire MOLAYE qui m a contacté pour vous faire bénéficier de mes connaissances en nouvelles technologies et
Plus en détailCentre CPGE TSI - Safi 2010/2011. Algorithmique et programmation :
Algorithmique et programmation : STRUCTURES DE DONNÉES A. Structure et enregistrement 1) Définition et rôle des structures de données en programmation 1.1) Définition : En informatique, une structure de
Plus en détailMachines virtuelles. Brique ASC. Samuel Tardieu sam@rfc1149.net. Samuel Tardieu (ENST) Machines virtuelles 1 / 40
Machines virtuelles Brique ASC Samuel Tardieu sam@rfc1149.net École Nationale Supérieure des Télécommunications Samuel Tardieu (ENST) Machines virtuelles 1 / 40 Machines virtuelles La compilation peut
Plus en détailQuelques patterns pour la persistance des objets avec DAO DAO. Principe de base. Utilité des DTOs. Le modèle de conception DTO (Data Transfer Object)
Quelques patterns pour la persistance des objets avec DAO Ce cours présente des modèles de conception utilisés pour effectuer la persistance des objets Université de Nice Sophia-Antipolis Version 1.4 30/8/07
Plus en détailProgrammation C++ (débutant)/instructions for, while et do...while
Programmation C++ (débutant)/instructions for, while et do...while 1 Programmation C++ (débutant)/instructions for, while et do...while Le cours du chapitre 4 : le for, while et do...while La notion de
Plus en détailACTIVITÉ DE PROGRAMMATION
ACTIVITÉ DE PROGRAMMATION The purpose of the Implementation Process is to realize a specified system element. ISO/IEC 12207 Sébastien Adam Une introduction 2 Introduction Ø Contenu Utilité de l ordinateur,
Plus en détailCours de C++ François Laroussinie. 2 novembre 2005. Dept. d Informatique, ENS de Cachan
Cours de C++ François Laroussinie Dept. d Informatique, ENS de Cachan 2 novembre 2005 Première partie I Introduction Introduction Introduction Algorithme et programmation Algorithme: méthode pour résoudre
Plus en détailChapitre I Notions de base et outils de travail
Chapitre I Notions de base et outils de travail Objectifs Connaître les principes fondateurs et l historique du langage Java S informer des principales caractéristiques du langage Java Connaître l environnement
Plus en détailClasse Interne, Anonyme & Enumération
Java Avancé Classe Interne, Anonyme & Enumération Rémi Forax forax@univ-mlv.fr 1 Rappel Nous nous intéressons aujourd'hui à deux formes de type abstrait en Java Les interfaces Les classes abstraites Les
Plus en détailJava Licence Professionnelle CISII, 2009-2010
Licence Professionnelle CISII, 2009-2010 Cours 1 : Introduction à Java A. Belaïd abelaid@loria.fr Cours disponible sur le site : http://www.loria.fr/~abelaid puis Teaching 1 Fonctionnement 12 séances :
Plus en détailJava Licence Professionnelle CISII, 2009-2010. Cours 2 : Classes et Objets
Licence Professionnelle CISII, 2009-2010 Cours 2 : Classes et Objets 1 Classes et Objets Objectifs des LOO : - Manipuler des objets - Découper les programmes suivant les types des objets manipulés - Regrouper
Plus en détailExpression des contraintes. OCL : Object C o n t r a i n t L a n g u a g e
P r o b l é m a t i q u e OCL : O b j e c t C o n s t r a i n t L a n g u a g e Le langage de contraintes d UML Les différents diagrammes d UML permettent d exprimer certaines contraintes graphiquement
Plus en détailJava - la plateforme
Java - la plateforme Java la plateforme Java? VM GC JIT Java Aujourd'hui 3 environnements d'exécutions différents Java ME (Micro Edition) pour PDA, téléphone Android (Java SE moins certain paquetages)
Plus en détailExclusion Mutuelle. Arnaud Labourel Courriel : arnaud.labourel@lif.univ-mrs.fr. Université de Provence. 9 février 2011
Arnaud Labourel Courriel : arnaud.labourel@lif.univ-mrs.fr Université de Provence 9 février 2011 Arnaud Labourel (Université de Provence) Exclusion Mutuelle 9 février 2011 1 / 53 Contexte Epistémologique
Plus en détailBTS S.I.O. 2012-2013 PHP OBJET. Module SLAM4. Nom du fichier : PHPRévisionObjetV2.odt Auteur : Pierre Barais
BTS S.I.O. 2012-2013 PHP OBJET Module SLAM4 Nom du fichier : PHPRévisionObjetV2.odt Auteur : Pierre Barais Table des matières 1 But... 3 2 Les bases :... 3 3 Utilisation d'une classe : Instanciation...3
Plus en détailOCL - Object Constraint Language
OCL - Object Constraint Language Laëtitia Matignon laetitia.matignon@univ-lyon1.fr Département Informatique - Polytech Lyon Université Claude Bernard Lyon 1 2012-2013 Laëtitia Matignon SIMA - OCL - Object
Plus en détailPrésentation du langage et premières fonctions
1 Présentation de l interface logicielle Si les langages de haut niveau sont nombreux, nous allons travaillé cette année avec le langage Python, un langage de programmation très en vue sur internet en
Plus en détail