[{"data":1,"prerenderedAt":1013},["ShallowReactive",2],{"page-\u002Fjava\u002Fheritage-et-interfaces":3,"pieces-java":970,"autour-\u002Fjava\u002Fheritage-et-interfaces":995,"prerequis-\u002Fjava\u002Fheritage-et-interfaces":1000,"plan-java":1002},{"id":4,"title":5,"body":6,"description":938,"extension":939,"ligne":54,"meta":940,"motsCles":941,"navigation":95,"niveau":945,"path":946,"prerequis":947,"ressources":949,"seo":961,"sources":962,"stem":968,"__hash__":969},"docs\u002Fjava\u002F05.heritage-et-interfaces.md","Héritage, interfaces et polymorphisme",{"type":7,"value":8,"toc":928},"minimark",[9,14,35,39,48,181,266,293,299,305,309,319,378,389,392,396,402,476,486,586,595,655,659,666,765,777,785,788,795,799,810,845,852,868,872,887,893,897,924],[10,11,13],"h2",{"id":12},"ce-que-tu-vas-apprendre","Ce que tu vas apprendre",[15,16,17,26,32],"ul",{},[18,19,20,21,25],"li",{},"Créer une classe qui hérite d'une autre avec ",[22,23,24],"code",{},"extends",".",[18,27,28,29,25],{},"Définir un contrat avec une ",[22,30,31],{},"interface",[18,33,34],{},"Utiliser le polymorphisme pour traiter des objets différents de la même façon.",[10,36,38],{"id":37},"lhéritage","L'héritage",[40,41,42,43,47],"p",{},"Sur le site de recettes, il existe des plats et des desserts. Un dessert est un plat avec un détail en plus. L'",[44,45,46],"strong",{},"héritage"," permet de reprendre une classe existante et de l'enrichir.",[49,50,56],"pre",{"className":51,"code":52,"filename":53,"language":54,"meta":55,"style":55},"language-java shiki shiki-themes github-light-default github-dark-default github-dark-default","public class Plat {\n    protected String nom;\n\n    public Plat(String nom) {\n        this.nom = nom;\n    }\n\n    public String decrire() {\n        return \"Plat : \" + nom;\n    }\n}\n","Plat.java","java","",[22,57,58,78,90,97,115,130,136,141,155,170,175],{"__ignoreMap":55},[59,60,63,67,70,74],"span",{"class":61,"line":62},"line",1,[59,64,66],{"class":65},"sOnC1","public",[59,68,69],{"class":65}," class",[59,71,73],{"class":72},"sIXEE"," Plat",[59,75,77],{"class":76},"scfrF"," {\n",[59,79,81,84,87],{"class":61,"line":80},2,[59,82,83],{"class":65},"    protected",[59,85,86],{"class":76}," String",[59,88,89],{"class":76}," nom;\n",[59,91,93],{"class":61,"line":92},3,[59,94,96],{"emptyLinePlaceholder":95},true,"\n",[59,98,100,103,106,109,112],{"class":61,"line":99},4,[59,101,102],{"class":65},"    public",[59,104,73],{"class":105},"syCW7",[59,107,108],{"class":76},"(String ",[59,110,111],{"class":72},"nom",[59,113,114],{"class":76},") {\n",[59,116,118,122,125,128],{"class":61,"line":117},5,[59,119,121],{"class":120},"s5iOY","        this",[59,123,124],{"class":76},".nom ",[59,126,127],{"class":65},"=",[59,129,89],{"class":76},[59,131,133],{"class":61,"line":132},6,[59,134,135],{"class":76},"    }\n",[59,137,139],{"class":61,"line":138},7,[59,140,96],{"emptyLinePlaceholder":95},[59,142,144,146,149,152],{"class":61,"line":143},8,[59,145,102],{"class":65},[59,147,148],{"class":76}," String ",[59,150,151],{"class":105},"decrire",[59,153,154],{"class":76},"() {\n",[59,156,158,161,165,168],{"class":61,"line":157},9,[59,159,160],{"class":65},"        return",[59,162,164],{"class":163},"shWOn"," \"Plat : \"",[59,166,167],{"class":65}," +",[59,169,89],{"class":76},[59,171,173],{"class":61,"line":172},10,[59,174,135],{"class":76},[59,176,178],{"class":61,"line":177},11,[59,179,180],{"class":76},"}\n",[49,182,185],{"className":51,"code":183,"filename":184,"language":54,"meta":55,"style":55},"public class Dessert extends Plat {\n    private int sucreEnGrammes;\n\n    public Dessert(String nom, int sucreEnGrammes) {\n        super(nom);\n        this.sucreEnGrammes = sucreEnGrammes;\n    }\n}\n","Dessert.java",[22,186,187,203,214,218,239,247,258,262],{"__ignoreMap":55},[59,188,189,191,193,196,199,201],{"class":61,"line":62},[59,190,66],{"class":65},[59,192,69],{"class":65},[59,194,195],{"class":72}," Dessert",[59,197,198],{"class":65}," extends",[59,200,73],{"class":120},[59,202,77],{"class":76},[59,204,205,208,211],{"class":61,"line":80},[59,206,207],{"class":65},"    private",[59,209,210],{"class":65}," int",[59,212,213],{"class":76}," sucreEnGrammes;\n",[59,215,216],{"class":61,"line":92},[59,217,96],{"emptyLinePlaceholder":95},[59,219,220,222,224,226,228,231,234,237],{"class":61,"line":99},[59,221,102],{"class":65},[59,223,195],{"class":105},[59,225,108],{"class":76},[59,227,111],{"class":72},[59,229,230],{"class":76},", ",[59,232,233],{"class":65},"int",[59,235,236],{"class":72}," sucreEnGrammes",[59,238,114],{"class":76},[59,240,241,244],{"class":61,"line":117},[59,242,243],{"class":120},"        super",[59,245,246],{"class":76},"(nom);\n",[59,248,249,251,254,256],{"class":61,"line":132},[59,250,121],{"class":120},[59,252,253],{"class":76},".sucreEnGrammes ",[59,255,127],{"class":65},[59,257,213],{"class":76},[59,259,260],{"class":61,"line":138},[59,261,135],{"class":76},[59,263,264],{"class":61,"line":143},[59,265,180],{"class":76},[40,267,268,271,272,275,276,279,280,283,284,286,287,283,290,292],{},[22,269,270],{},"extends Plat"," signifie que ",[22,273,274],{},"Dessert"," récupère les champs et méthodes de ",[22,277,278],{},"Plat",". On parle de ",[44,281,282],{},"classe mère"," (",[22,285,278],{},") et de ",[44,288,289],{},"classe fille",[22,291,274],{},").",[40,294,295,298],{},[22,296,297],{},"super(nom)"," appelle le constructeur de la classe mère. Il doit être la première instruction du constructeur.",[40,300,301,304],{},[22,302,303],{},"protected"," rend un champ visible dans la classe et dans ses classes filles, mais pas ailleurs.",[10,306,308],{"id":307},"redéfinir-une-méthode","Redéfinir une méthode",[40,310,311,312,283,315,292],{},"La classe fille peut remplacer une méthode héritée. On parle de ",[44,313,314],{},"redéfinition",[316,317,318],"em",{},"override",[49,320,322],{"className":51,"code":321,"filename":184,"language":54,"meta":55,"style":55},"@Override\npublic String decrire() {\n    return \"Dessert : \" + nom + \" (\" + sucreEnGrammes + \" g de sucre)\";\n}\n",[22,323,324,332,342,374],{"__ignoreMap":55},[59,325,326,329],{"class":61,"line":62},[59,327,328],{"class":76},"@",[59,330,331],{"class":65},"Override\n",[59,333,334,336,338,340],{"class":61,"line":80},[59,335,66],{"class":65},[59,337,148],{"class":76},[59,339,151],{"class":105},[59,341,154],{"class":76},[59,343,344,347,350,352,355,358,361,363,366,368,371],{"class":61,"line":92},[59,345,346],{"class":65},"    return",[59,348,349],{"class":163}," \"Dessert : \"",[59,351,167],{"class":65},[59,353,354],{"class":76}," nom ",[59,356,357],{"class":65},"+",[59,359,360],{"class":163}," \" (\"",[59,362,167],{"class":65},[59,364,365],{"class":76}," sucreEnGrammes ",[59,367,357],{"class":65},[59,369,370],{"class":163}," \" g de sucre)\"",[59,372,373],{"class":76},";\n",[59,375,376],{"class":61,"line":99},[59,377,180],{"class":76},[40,379,380,381,384,385,388],{},"L'",[44,382,383],{},"annotation"," ",[22,386,387],{},"@Override"," demande au compilateur de vérifier que la méthode existe bien dans la classe mère. En cas de faute de frappe dans le nom, il signale l'erreur.",[40,390,391],{},"Une classe ne peut hériter que d'une seule classe mère. L'héritage sert quand la relation se dit « est un » : un dessert est un plat.",[10,393,395],{"id":394},"les-interfaces","Les interfaces",[40,397,398,399,401],{},"Une ",[44,400,31],{}," décrit ce qu'un objet sait faire, sans dire comment. C'est un contrat.",[49,403,406],{"className":51,"code":404,"filename":405,"language":54,"meta":55,"style":55},"public interface Notable {\n    int note();\n\n    default String etoiles() {\n        return \"*\".repeat(note());\n    }\n}\n","Notable.java",[22,407,408,420,431,435,447,468,472],{"__ignoreMap":55},[59,409,410,412,415,418],{"class":61,"line":62},[59,411,66],{"class":65},[59,413,414],{"class":65}," interface",[59,416,417],{"class":72}," Notable",[59,419,77],{"class":76},[59,421,422,425,428],{"class":61,"line":80},[59,423,424],{"class":65},"    int",[59,426,427],{"class":105}," note",[59,429,430],{"class":76},"();\n",[59,432,433],{"class":61,"line":92},[59,434,96],{"emptyLinePlaceholder":95},[59,436,437,440,442,445],{"class":61,"line":99},[59,438,439],{"class":65},"    default",[59,441,148],{"class":76},[59,443,444],{"class":105},"etoiles",[59,446,154],{"class":76},[59,448,449,451,454,456,459,462,465],{"class":61,"line":117},[59,450,160],{"class":65},[59,452,453],{"class":163}," \"*\"",[59,455,25],{"class":76},[59,457,458],{"class":105},"repeat",[59,460,461],{"class":76},"(",[59,463,464],{"class":105},"note",[59,466,467],{"class":76},"());\n",[59,469,470],{"class":61,"line":132},[59,471,135],{"class":76},[59,473,474],{"class":61,"line":138},[59,475,180],{"class":76},[40,477,478,481,482,485],{},[22,479,480],{},"note()"," n'a pas de corps : toute classe qui promet cette interface doit l'écrire. Une méthode ",[22,483,484],{},"default"," fournit au contraire un comportement déjà prêt.",[49,487,490],{"className":51,"code":488,"filename":489,"language":54,"meta":55,"style":55},"public class Recette implements Notable {\n    private int note;\n\n    public Recette(int note) {\n        this.note = note;\n    }\n\n    @Override\n    public int note() {\n        return note;\n    }\n}\n","Recette.java",[22,491,492,508,517,521,535,546,550,554,561,571,577,581],{"__ignoreMap":55},[59,493,494,496,498,501,504,506],{"class":61,"line":62},[59,495,66],{"class":65},[59,497,69],{"class":65},[59,499,500],{"class":72}," Recette",[59,502,503],{"class":65}," implements",[59,505,417],{"class":120},[59,507,77],{"class":76},[59,509,510,512,514],{"class":61,"line":80},[59,511,207],{"class":65},[59,513,210],{"class":65},[59,515,516],{"class":76}," note;\n",[59,518,519],{"class":61,"line":92},[59,520,96],{"emptyLinePlaceholder":95},[59,522,523,525,527,529,531,533],{"class":61,"line":99},[59,524,102],{"class":65},[59,526,500],{"class":105},[59,528,461],{"class":76},[59,530,233],{"class":65},[59,532,427],{"class":72},[59,534,114],{"class":76},[59,536,537,539,542,544],{"class":61,"line":117},[59,538,121],{"class":120},[59,540,541],{"class":76},".note ",[59,543,127],{"class":65},[59,545,516],{"class":76},[59,547,548],{"class":61,"line":132},[59,549,135],{"class":76},[59,551,552],{"class":61,"line":138},[59,553,96],{"emptyLinePlaceholder":95},[59,555,556,559],{"class":61,"line":143},[59,557,558],{"class":76},"    @",[59,560,331],{"class":65},[59,562,563,565,567,569],{"class":61,"line":157},[59,564,102],{"class":65},[59,566,210],{"class":65},[59,568,427],{"class":105},[59,570,154],{"class":76},[59,572,573,575],{"class":61,"line":172},[59,574,160],{"class":65},[59,576,516],{"class":76},[59,578,579],{"class":61,"line":177},[59,580,135],{"class":76},[59,582,584],{"class":61,"line":583},12,[59,585,180],{"class":76},[40,587,588,591,592,594],{},[22,589,590],{},"implements"," indique que la classe respecte le contrat. Contrairement à ",[22,593,24],{},", une classe peut implémenter autant d'interfaces qu'elle veut.",[596,597,598,618],"table",{},[599,600,601],"thead",{},[602,603,604,607,613],"tr",{},[605,606],"th",{},[605,608,609,610,612],{},"Classe mère (",[22,611,24],{},")",[605,614,615,616,612],{},"Interface (",[22,617,590],{},[619,620,621,633,644],"tbody",{},[602,622,623,627,630],{},[624,625,626],"td",{},"Nombre par classe",[624,628,629],{},"une seule",[624,631,632],{},"autant que nécessaire",[602,634,635,638,641],{},[624,636,637],{},"Peut porter des champs",[624,639,640],{},"oui",[624,642,643],{},"non, seulement des constantes",[602,645,646,649,652],{},[624,647,648],{},"Sens",[624,650,651],{},"« est un »",[624,653,654],{},"« sait faire »",[10,656,658],{"id":657},"le-polymorphisme","Le polymorphisme",[40,660,661,662,665],{},"Le ",[44,663,664],{},"polymorphisme"," (« plusieurs formes ») permet d'utiliser un objet à travers son type parent. La bonne version de la méthode est choisie à l'exécution.",[49,667,669],{"className":51,"code":668,"language":54,"meta":55,"style":55},"Plat[] menu = {\n    new Plat(\"Gratin\"),\n    new Dessert(\"Tarte\", 40)\n};\n\nfor (Plat p : menu) {\n    System.out.println(p.decrire());\n}\n",[22,670,671,686,701,720,725,729,746,761],{"__ignoreMap":55},[59,672,673,675,678,681,684],{"class":61,"line":62},[59,674,278],{"class":65},[59,676,677],{"class":72},"[] ",[59,679,680],{"class":76},"menu",[59,682,683],{"class":65}," =",[59,685,77],{"class":76},[59,687,688,691,693,695,698],{"class":61,"line":80},[59,689,690],{"class":65},"    new",[59,692,73],{"class":105},[59,694,461],{"class":76},[59,696,697],{"class":163},"\"Gratin\"",[59,699,700],{"class":76},"),\n",[59,702,703,705,707,709,712,714,717],{"class":61,"line":92},[59,704,690],{"class":65},[59,706,195],{"class":105},[59,708,461],{"class":76},[59,710,711],{"class":163},"\"Tarte\"",[59,713,230],{"class":76},[59,715,716],{"class":120},"40",[59,718,719],{"class":76},")\n",[59,721,722],{"class":61,"line":99},[59,723,724],{"class":76},"};\n",[59,726,727],{"class":61,"line":117},[59,728,96],{"emptyLinePlaceholder":95},[59,730,731,734,737,740,743],{"class":61,"line":132},[59,732,733],{"class":65},"for",[59,735,736],{"class":76}," (Plat",[59,738,739],{"class":76}," p",[59,741,742],{"class":65}," :",[59,744,745],{"class":76}," menu) {\n",[59,747,748,751,754,757,759],{"class":61,"line":138},[59,749,750],{"class":76},"    System.out.",[59,752,753],{"class":105},"println",[59,755,756],{"class":76},"(p.",[59,758,151],{"class":105},[59,760,467],{"class":76},[59,762,763],{"class":61,"line":143},[59,764,180],{"class":76},[40,766,767,768,770,771,773,774,776],{},"Le tableau contient des ",[22,769,278],{},", mais il peut y ranger un ",[22,772,274],{},". Pour chaque élément, Java appelle la méthode ",[22,775,151],{}," de la vraie classe de l'objet :",[49,778,783],{"className":779,"code":781,"language":782},[780],"language-text","Plat : Gratin\nDessert : Tarte (40 g de sucre)\n","text",[22,784,781],{"__ignoreMap":55},[40,786,787],{},"Le code qui parcourt le menu n'a pas besoin de savoir quelle sorte de plat il traite. Ajouter un nouveau type de plat ne demande pas de modifier cette boucle.",[40,789,790,791,794],{},"Le même principe marche avec les interfaces : une méthode qui prend un ",[22,792,793],{},"Notable"," accepte n'importe quelle classe qui l'implémente.",[10,796,798],{"id":797},"classes-abstraites","Classes abstraites",[40,800,801,802,805,806,809],{},"Une classe ",[44,803,804],{},"abstraite"," ne peut pas être instanciée avec ",[22,807,808],{},"new",". Elle sert de base à d'autres classes et peut contenir des méthodes sans corps.",[49,811,813],{"className":51,"code":812,"language":54,"meta":55,"style":55},"public abstract class Plat {\n    public abstract int calories();\n}\n",[22,814,815,828,841],{"__ignoreMap":55},[59,816,817,819,822,824,826],{"class":61,"line":62},[59,818,66],{"class":65},[59,820,821],{"class":65}," abstract",[59,823,69],{"class":65},[59,825,73],{"class":72},[59,827,77],{"class":76},[59,829,830,832,834,836,839],{"class":61,"line":80},[59,831,102],{"class":65},[59,833,821],{"class":65},[59,835,210],{"class":65},[59,837,838],{"class":105}," calories",[59,840,430],{"class":76},[59,842,843],{"class":61,"line":92},[59,844,180],{"class":76},[40,846,847,848,851],{},"Toute classe fille non abstraite doit alors écrire ",[22,849,850],{},"calories()",". Choisis une interface pour un simple contrat, une classe abstraite quand les classes partagent aussi des champs et du code.",[464,853,854],{},[40,855,856,859,860,863,864,867],{},[22,857,858],{},"final"," devant une classe interdit d'en hériter. Avec ",[22,861,862],{},"sealed ... permits ...",", tu listes même précisément les classes autorisées à hériter. Cela sert surtout pour le ",[22,865,866],{},"switch"," expliqué dans le cours 06.",[10,869,871],{"id":870},"héritage-ou-composition","Héritage ou composition",[40,873,874,875,878,879,882,883,886],{},"L'héritage lie fortement la classe fille à sa mère : modifier l'une peut casser l'autre. Beaucoup de développeurs préfèrent la ",[44,876,877],{},"composition"," : une ",[22,880,881],{},"Recette"," possède une liste d'",[22,884,885],{},"Ingredient"," au lieu d'en hériter.",[888,889,890],"tip",{},[40,891,892],{},"Teste la relation à voix haute. « Un dessert est un plat » : héritage possible. « Une recette a des ingrédients » : composition, donc un champ.",[10,894,896],{"id":895},"à-retenir","À retenir",[15,898,899,908,913,918,921],{},[18,900,901,903,904,907],{},[22,902,24],{}," fait hériter une classe d'une seule classe mère ; ",[22,905,906],{},"super(...)"," appelle son constructeur.",[18,909,910,912],{},[22,911,387],{}," marque une méthode redéfinie et fait vérifier le nom par le compilateur.",[18,914,915,916,25],{},"Une interface est un contrat ; une classe peut en implémenter plusieurs avec ",[22,917,590],{},[18,919,920],{},"Le polymorphisme choisit à l'exécution la méthode de la vraie classe de l'objet.",[18,922,923],{},"Quand la relation n'est pas « est un », préfère la composition à l'héritage.",[925,926,927],"style",{},"html pre.shiki code .sOnC1, html code.shiki .sOnC1{--shiki-light:#CF222E;--shiki-default:#FF7B72;--shiki-dark:#FF7B72}html pre.shiki code .sIXEE, html code.shiki .sIXEE{--shiki-light:#953800;--shiki-default:#FFA657;--shiki-dark:#FFA657}html pre.shiki code .scfrF, html code.shiki .scfrF{--shiki-light:#1F2328;--shiki-default:#E6EDF3;--shiki-dark:#E6EDF3}html pre.shiki code .syCW7, html code.shiki .syCW7{--shiki-light:#8250DF;--shiki-default:#D2A8FF;--shiki-dark:#D2A8FF}html pre.shiki code .s5iOY, html code.shiki .s5iOY{--shiki-light:#0550AE;--shiki-default:#79C0FF;--shiki-dark:#79C0FF}html pre.shiki code .shWOn, html code.shiki .shWOn{--shiki-light:#0A3069;--shiki-default:#A5D6FF;--shiki-dark:#A5D6FF}html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"title":55,"searchDepth":80,"depth":92,"links":929},[930,931,932,933,934,935,936,937],{"id":12,"depth":80,"text":13},{"id":37,"depth":80,"text":38},{"id":307,"depth":80,"text":308},{"id":394,"depth":80,"text":395},{"id":657,"depth":80,"text":658},{"id":797,"depth":80,"text":798},{"id":870,"depth":80,"text":871},{"id":895,"depth":80,"text":896},"Réutiliser une classe avec l'héritage, définir un contrat avec une interface, et traiter des objets différents de la même façon.","md",{},[24,46,942,318,943,31,590,664,944],"super","abstract","sealed","intermediaire","\u002Fjava\u002Fheritage-et-interfaces",[948],"\u002Fjava\u002Ftableaux-classes-et-records",[950,954,957],{"nom":951,"url":952,"type":953},"OpenClassrooms, Apprenez à programmer en Java","https:\u002F\u002Fopenclassrooms.com\u002Ffr\u002Fcourses\u002F6173501-apprenez-a-programmer-en-java","cours",{"nom":955,"url":956,"type":953},"Développons en Java (Jean-Michel Doudoux)","https:\u002F\u002Fwww.jmdoudoux.fr\u002Fjava\u002Fdej\u002Findex.htm",{"nom":958,"url":959,"type":960,"anglais":95},"Héritage (dev.java, en anglais)","https:\u002F\u002Fdev.java\u002Flearn\u002Finheritance\u002F","doc",{"title":5,"description":938},[963,965],{"nom":964,"url":959},"Héritage, dev.java (en anglais)",{"nom":966,"url":967},"Interfaces, dev.java (en anglais)","https:\u002F\u002Fdev.java\u002Flearn\u002Finterfaces\u002F","java\u002F05.heritage-et-interfaces","4hfaRzUUv_emkFzkaeUDdOk4DOErN80YwAT5rNqU8Co",[971,975,979,983,986,987,991],{"path":972,"title":973,"stem":974},"\u002Fjava\u002Fjvm-et-premier-programme","La JVM et ton premier programme","java\u002F01.jvm-et-premier-programme",{"path":976,"title":977,"stem":978},"\u002Fjava\u002Fvariables-et-types","Variables, types et String","java\u002F02.variables-et-types",{"path":980,"title":981,"stem":982},"\u002Fjava\u002Fconditions-boucles-methodes","Conditions, boucles et méthodes","java\u002F03.conditions-boucles-methodes",{"path":948,"title":984,"stem":985},"Tableaux, classes et records","java\u002F04.tableaux-classes-et-records",{"path":946,"title":5,"stem":968},{"path":988,"title":989,"stem":990},"\u002Fjava\u002Fcollections-generiques-exceptions","Collections, génériques et exceptions","java\u002F06.collections-generiques-exceptions",{"path":992,"title":993,"stem":994},"\u002Fjava","Java","java\u002Findex",[996,998],{"title":984,"path":948,"stem":985,"description":997,"children":-1},"Stocker plusieurs valeurs dans un tableau, puis modéliser une recette avec une classe, un constructeur, l'encapsulation et un record.",{"title":989,"path":988,"stem":990,"description":999,"children":-1},"Manipuler des List et des Map, écrire du code générique, gérer les erreurs avec les exceptions et modéliser des cas avec sealed et switch.",[1001],{"path":948,"title":984,"ligne":54},[1003,1005,1006,1007,1008,1009,1011],{"path":972,"title":973,"niveau":1004,"stem":974},"debutant",{"path":976,"title":977,"niveau":1004,"stem":978},{"path":980,"title":981,"niveau":1004,"stem":982},{"path":948,"title":984,"niveau":945,"stem":985},{"path":946,"title":5,"niveau":945,"stem":968},{"path":988,"title":989,"niveau":1010,"stem":990},"avance",{"path":992,"title":993,"niveau":1012,"stem":994},"memo",1794583453600]