From 73127a3e61864067b1a46f345060b69c97e760c8 Mon Sep 17 00:00:00 2001 From: framery Date: Wed, 10 Dec 2025 10:19:06 +0100 Subject: [PATCH] update du travail rendu --- TP2/TP2.png | Bin 17650 -> 17650 bytes TP3/TP3-1.png | Bin 14499 -> 14500 bytes TP3/TP3-2.png | Bin 16871 -> 16872 bytes TP4/stub/0Bad/Base.class | Bin 0 -> 820 bytes TP4/stub/0Bad/Base.java | 4 + TP4/stub/0Bad/Exemple.class | Bin 0 -> 1209 bytes TP4/stub/0Bad/Exemple.java | 31 +++++++ TP4/stub/0Bad/MonBrin.class | Bin 0 -> 327 bytes TP4/stub/0Bad/MonBrin.java | 32 +++++++ TP4/stub/0Bad/MonMaillon.class | Bin 0 -> 527 bytes TP4/stub/0Bad/MonMaillon.java | 33 +++++++ TP4/stub/1Iterable/Base.java | 4 + TP4/stub/1Iterable/Exemple.java | 34 +++++++ TP4/stub/1Iterable/MonBrin.java | 42 +++++++++ TP4/stub/1Iterable/MonMaillon.java | 28 ++++++ TP4/stub/2Iterator/Base.java | 4 + TP4/stub/2Iterator/Exemple.java | 35 ++++++++ TP4/stub/2Iterator/MonBrin.java | 37 ++++++++ TP4/stub/2Iterator/MonBrinIterator.java | 32 +++++++ TP4/stub/2Iterator/MonMaillon.java | 29 ++++++ .../Base.java | 4 + .../Exemple.java | 58 ++++++++++++ .../MonBrin.java | 83 ++++++++++++++++++ .../MonBrinIterator.java | 33 +++++++ TP4/stub/explication.txt | 20 +++++ TP5/stub/exo3/Chef.java | 48 ++++++++++ TP5/stub/exo3/Exemple.java | 36 ++++++++ TP5/stub/exo3/Exemple2.java | 33 +++++++ TP5/stub/exo3/Exemple3.java | 43 +++++++++ TP5/stub/exo3/Person.java | 44 ++++++++++ TP5/stub/exo3/Travailleur.java | 31 +++++++ TP5/stub/exo4/Chef.java | 48 ++++++++++ TP5/stub/exo4/Exemple.java | 36 ++++++++ TP5/stub/exo4/Exemple2.java | 33 +++++++ TP5/stub/exo4/Exemple3.java | 43 +++++++++ TP5/stub/exo4/Person.java | 44 ++++++++++ TP5/stub/exo4/Travailleur.java | 31 +++++++ TP5/stub/exo5/Chef.java | 48 ++++++++++ TP5/stub/exo5/Exemple.java | 36 ++++++++ TP5/stub/exo5/Exemple2.java | 33 +++++++ TP5/stub/exo5/Exemple3.java | 43 +++++++++ TP5/stub/exo5/Person.java | 44 ++++++++++ TP5/stub/exo5/Travailleur.java | 31 +++++++ 43 files changed, 1248 insertions(+) create mode 100644 TP4/stub/0Bad/Base.class create mode 100644 TP4/stub/0Bad/Base.java create mode 100644 TP4/stub/0Bad/Exemple.class create mode 100644 TP4/stub/0Bad/Exemple.java create mode 100644 TP4/stub/0Bad/MonBrin.class create mode 100644 TP4/stub/0Bad/MonBrin.java create mode 100644 TP4/stub/0Bad/MonMaillon.class create mode 100644 TP4/stub/0Bad/MonMaillon.java create mode 100644 TP4/stub/1Iterable/Base.java create mode 100644 TP4/stub/1Iterable/Exemple.java create mode 100644 TP4/stub/1Iterable/MonBrin.java create mode 100644 TP4/stub/1Iterable/MonMaillon.java create mode 100644 TP4/stub/2Iterator/Base.java create mode 100644 TP4/stub/2Iterator/Exemple.java create mode 100644 TP4/stub/2Iterator/MonBrin.java create mode 100644 TP4/stub/2Iterator/MonBrinIterator.java create mode 100644 TP4/stub/2Iterator/MonMaillon.java create mode 100644 TP4/stub/3IteratorDifferentInnerStructure/Base.java create mode 100644 TP4/stub/3IteratorDifferentInnerStructure/Exemple.java create mode 100644 TP4/stub/3IteratorDifferentInnerStructure/MonBrin.java create mode 100644 TP4/stub/3IteratorDifferentInnerStructure/MonBrinIterator.java create mode 100644 TP4/stub/explication.txt create mode 100644 TP5/stub/exo3/Chef.java create mode 100644 TP5/stub/exo3/Exemple.java create mode 100644 TP5/stub/exo3/Exemple2.java create mode 100644 TP5/stub/exo3/Exemple3.java create mode 100644 TP5/stub/exo3/Person.java create mode 100644 TP5/stub/exo3/Travailleur.java create mode 100644 TP5/stub/exo4/Chef.java create mode 100644 TP5/stub/exo4/Exemple.java create mode 100644 TP5/stub/exo4/Exemple2.java create mode 100644 TP5/stub/exo4/Exemple3.java create mode 100644 TP5/stub/exo4/Person.java create mode 100644 TP5/stub/exo4/Travailleur.java create mode 100644 TP5/stub/exo5/Chef.java create mode 100644 TP5/stub/exo5/Exemple.java create mode 100644 TP5/stub/exo5/Exemple2.java create mode 100644 TP5/stub/exo5/Exemple3.java create mode 100644 TP5/stub/exo5/Person.java create mode 100644 TP5/stub/exo5/Travailleur.java diff --git a/TP2/TP2.png b/TP2/TP2.png index 97188d7228fc6c69dc0c764c4066335c99beba2e..287477c2e4a1bf1d6b47e95b3651548631355a10 100644 GIT binary patch delta 457 zcmey=$@r<0aYHy`{oTCT1`=)OYenZ<%xF>)Xq%E|H)GY-vrBXW7hf!T*K|ClapNE1 zwbQ4(KGFO3biiqcS=)r8x5@8+|NH0jV^(={-bXFkIDP7s7)uVmnEC!CM;ClaI_;|) z%5dip_uM3_#DWLQgmSg(n5||qmhhbsy<|DzTtg0DigAJ|dsy&+Pt&f~HywOelT~AG z@K)#8&m~I_S-s`)=B!*OP(J#dk9eN7xX>go+z~2*lfP34-V}1s{ z_bqcIBOcysnttij^DrF~-up{mXndXD*SexA)L-Xvee|-$sa;<6D+>=tYd3LPzTi!f z?3*W9bHKad6vsOk*$L7MU!CSwZm$>P|DCzNd9gv*H?E91YA-|o6mC53sA!^+z2N#A zt@N8xdGEX3cdTho`S^4L^X+OMzO7r%ok)Klpr8_6_vFJ_ZFTECkJxpue0%r$Hp`vW zi%s^vYAH&Ie&?c{}vv+ggf;;?HPX)Remlg^wzkYho1Gd9+LwH5jU+d(%-yZT$ z-KtW<&8k0BE?scmYksM~BK3X6_pMCUSN*ZzZC-xdcZ-_!I;r#0J(?mr-x@BeJi4{% U50k=0aiNKuy<|4?F+Xtx0FuJoJOBUy delta 457 zcmey=$@r<0aYHy`y>H%a1A*4>Hb))04>c(|E(tY%x`<=e5!RU9hFb2`ZnIYLqbO{6obPY)Jisc3JJwsY z(cpv2@`(9`H#lPxZ$HXkaGt55&0)m>rv}yoN-ScG6WSf@SbH*Dd+TM)o(DhXW4_F0 zcy4)|*8Sz225u*WTc1qM=XqBAK)^Jkd*9SDF?W~6rBRL{ZuJR&nBq1}y^_}S^-J$( zW%lN8rWKmKH93XXF8}cD>I?e+G9uyX%BrN3|8h^dc|V)_@6uzhEo_T9Eno1aNcPX; zu6VA`sMUKYNp@m($k(T>6JuZ3^Z!oV-KdI0d!rLXi)5HMRNwb-k|+d3}5RdhUYdeL>}~ z8ct0r-6`9cI`KRf>|;Z)uJ!+FQGs?V!F%P)WUVMDxXc#3k!W0%LtiO diff --git a/TP3/TP3-1.png b/TP3/TP3-1.png index cfdc9021449e33de5a90868969813c7501d23b5f..a190d3b7adeb5dee6a211be45722ac73edd0d980 100644 GIT binary patch delta 438 zcmZ2nxTJ6c4|Dz8%#etZf}F&>lG5B921W)3hKf0@lYH}UIS919|E>LO#)?g;!Cu1J z?OR&HiWD6;9bDX>Gszd~Sbv+V^Y5R(!r|3trw#JQ{HI zg{{wxz$>rBcz+kKeXt>J{$WeY{N97SD{X(Il{7#6{?P20ZrCjA`og;T<;&j%Sbe%y zda^H5_vqh;`xd0fw$7Sj=Hn;QWPR&e#KTW4)A)MtM;-tF_{o&2ul(lqi&k7;&VGN^ z*Bb}#7J6-Py1(qz$Lk;N*1V5c=l6!Q_wiw)|B5BQUq}9Tcwu|6&~mxu^F7mxywkS+ z=E#aWz1aTjvI|`+);5~RsWj^s*3XKW()i%swh26ndrz@>n(b-(xTIxn-AcW>bITv( z7Hs-3b=v)f(;Jr_SbA!sYXwhRsk5X_&dDd``>hy+FK4CuI=6-Hn<2~WcKF5aG>sFT zq7i4lm5NnIOD@TrbEJ9wd^ay4nN4QW8gVwklMjYSOMYKy;nx4CM5Mm&Lg@L-DW}vl zuSsN0dp0%JGmXvvY5xl^--|g-ZlG5B921W)3hKf0@lMd$HHsEP{U&SRCEn@a)OQ~^k zdtRp50pDv0e#PlBYN83=Z7!0!8`|YBAL*T(d&BonUC3#TBpm*cJpknpG+n3r~fL(UFz0zcJ-20Q|CI!Y$`f!hgBnY`!VxtANN~WF1`2n@bmb?+vJwoMp6KoN-TYdxNBt;M*{`L$e%Q@#+J5ll zq3cm~?QyKrxb;H&bPt_Rh`2uGV6d}VeZ?CFAD`88O-&`keioJac;qiyKWphyVeJib z-oB4~mzz34<)eb!z1XE*Tr!)?qBZW>1kXJfA}#rSrA6BE!b!)j3-0=)+9`DNhz6VU x(Mx-_WUoB)pz@=x)Jn}+xf5zr9Nc=>MwH|)5`AUP6DV|uB|g=3^Cp&0#sC~%({=y= diff --git a/TP3/TP3-2.png b/TP3/TP3-2.png index 5820d26aa59c737305cee0761ae93dbc9dae7084..2ca488a3f04df7c0ce0b6ea49b7d38b303729590 100644 GIT binary patch delta 445 zcmaFf%=n_2af3V){)V4I7oD1ReWA(LRa#tpft)59YInk&^c<&$*d-O zfr6J`jMqnErKg8Tqfj=5IB6 zcsHPtEmVGU-aUur&neOJ4SDGgX9rYXso^X!GVEeMnk#bL-XJN^yykP#7vlvwR`*z9 zCdSCTV_arB{ac~YG2Kk%DK67eGQX)NzPwp~M(|%yv`_U3z0W#ltM3;S7$0V~Z{K|T zr9^MhE~OZbdZ9-rBjX>)xYeBgc+m6pdd=g%c~1rwUbp(-me(3q!J z6E~{7UHYI#=+&9#H8PUkmsEcL+R1O{Sgid-==9!=Th0~gEV+HK_NUlg{|Nh?9Xr>B z>7>=|Jg;%*>NWHAR}Q5=`(Yt{Y`VcW?UI_8sgqh7KM8%kw^`^PQw}@-+duKQIX6FG HX14RfQtrQGB-ukEg-V}`sQ7dn({3!hW$obesnLX>wZd4sV&b8>>nbwI;YhSOs>{egV ze(#Hw+{C8-JzL!~R@v>C@F?bM%w%ibT@h=~dTF<2+-|9@;G1&5kM;2M`*Y@h`8B`P z=;rK&OuVb^rT^X2$oBl^wtI|!&mA&vRJ&5g`8w6MHG~3(Rt}gj;(ei=c+a(vXx=(F9S@cb6 zLhYmbOBPRSTXLXC?3GUQ8ktEdaz|dCJ>C=8B8`)| IAv3!j0L`S{1ONa4 diff --git a/TP4/stub/0Bad/Base.class b/TP4/stub/0Bad/Base.class new file mode 100644 index 0000000000000000000000000000000000000000..729c95aa7c84d10f02456fe4b81fb6f6acf26235 GIT binary patch literal 820 zcmX^0Z`VEs1_pBm6HW#e1~o1Qbp{P~261)MvBLi1(erZv1s#_+=HJl(n>VcfW!ypClPJi)-gz{0@EAi*HXz{nuQz`&ryz{mgsT$>mew=pmsU|`DKz=Els2^1;}Oknfn8JHQE85kJYwX|inGq7#M zFkFFwfq{uZk%5Cji9r!+NdW^3$W06(yBSy_h1i+5GjMEX-~@BHSil@^Fo%Z~%;5!d z_}IW4e)hc#ERoEc7&wC?SvE0n2S>7QV&DyqWZT5RAH11?5#a(Z1||ju24)5m1||k3 O28cV98C1aTQ3U{3c8($d literal 0 HcmV?d00001 diff --git a/TP4/stub/0Bad/Base.java b/TP4/stub/0Bad/Base.java new file mode 100644 index 0000000..5e6a4cf --- /dev/null +++ b/TP4/stub/0Bad/Base.java @@ -0,0 +1,4 @@ +// juste un type énuméré pour nommer les bases +public enum Base { + A,C,G,T +} diff --git a/TP4/stub/0Bad/Exemple.class b/TP4/stub/0Bad/Exemple.class new file mode 100644 index 0000000000000000000000000000000000000000..1e92419ea49d4d142d5b50cbccedcc016a45dab9 GIT binary patch literal 1209 zcmX^0Z`VEs1_pD6AT9=R21QN=B?e^<1{E#_RR%S726avb4F*jv237_w5K9}x(gCq_ zL4+PVgFY7n4}$>*gCR(_5eI`Y2ZISn$P}c~3}lKqh-JafV9Cy4#mK;BlbM%UV#mn9 ztf3jk$iU*9pOVVR!0(fpm+DuVo0M7?UR*QmZ+bTn3t{} zTvC*omu?Nx$QxXen4ImKSO8Ve6`WsMl$`383DV5tT9KMtkdvwh(#pdi!63=bV9mo| z!(hwEAf23_S6ot5np~2ZpQn&gs*qHanWy0H91`N_&dy-R!(h+gz{tSmo1f>Kn3fs8EnttWcI;TC7lzlbBhQ%EREr;LXS&>z}7kkXl-z z05Kx9NFg;(A+anm@9^@(yb?wRPtP0$uwljOsd);SdBp{pMX5y!1^J~#3YobDIfqx~ zrskET7AfSYXM*Uo#NfAq~mYzC?@BLjN@NKsB6BZH_0L?e3ivN$Ccr!q1yx-&Ac`GDBgj0~I_5Edx< z86ClT!7@IGxB@2)#t=pZMrTF_ehqXPj*@&x5@KW!(a^-SnUR4bJ+;IoH3{S;J`GJ| z{frFk>8T|k3mF+WG&CVj0XqWhMX(1T!31^$e|l<3aA{^qDl`=_C^CpKh%O4(;s>oKQ9w4mLNEI2)AB6REwOf!7ygF5fl= zmQ4&yI@=idAuJ&QC@r{+fkkH)^-L)E$yugOdG+fxfmE2_!yYMBntyS11Ez310w@B0}oW6ECVCNOsy>pOdH@@ P*ua9q42%rCV5|55R-ZSq literal 0 HcmV?d00001 diff --git a/TP4/stub/0Bad/MonBrin.java b/TP4/stub/0Bad/MonBrin.java new file mode 100644 index 0000000..e8ab155 --- /dev/null +++ b/TP4/stub/0Bad/MonBrin.java @@ -0,0 +1,32 @@ +/** + MonBrin code un brin d'ADN sous forme de liste simplement chaînée. + + Plusieurs instances de MonMaillon reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base. + + On n'utilise pas java.util et on recode tout. + + Cette version a un problème : la navigation n'est pas raisonnable +*/ +public class MonBrin { + MonMaillon p; + Base b; + + //Le constructeur fabrique un brin à partir du premier maillon p; + public MonBrin(MonMaillon p){ + this.p = p; + } + + public MonMaillon getDebut(){ + return this.p; + } + + /** et pour naviguer? + On pourrait implémenter l'interface iterator de java.util ici + **/ + Iterator index = b.iterator(); + + + +} + + diff --git a/TP4/stub/0Bad/MonMaillon.class b/TP4/stub/0Bad/MonMaillon.class new file mode 100644 index 0000000000000000000000000000000000000000..4d886e9cbdc4a388ccfc3a69fdcaf5031ad63a52 GIT binary patch literal 527 zcmX^0Z`VEs1_pBmX)Xp<22oB176vg8A=3*QNqZ;C+IgAYa>8T~brI{tEP}>+8_%t+; zbuuz=1?QI*C8xS&f(++JI7}}qu`H2?fr~+khk=cOori&gfs>Je3!#9KK>(ygKPNFS zUEe<`D>b={ + + public MonBrin(MonMaillon p){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public MonMaillon getDebut(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + + // rappel : on met @Override pour dire au compilateur qu'on veut surcharger (en particulier c'est le cas quand on implémente une interface) + // ce n'est pas nécessaire dans ce cas mais ça permet d'avoir des messages d'alerte si on se trompe (typo dans le nom de la méthode ...) + // voir https://stackoverflow.com/questions/94361/when-do-you-use-javas-override-annotation-and-why + @Override + public boolean hasNext(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + @Override + public Base next() { + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + throw new NoSuchElementException(); + + } + +} + + + + diff --git a/TP4/stub/1Iterable/MonMaillon.java b/TP4/stub/1Iterable/MonMaillon.java new file mode 100644 index 0000000..6f93fe5 --- /dev/null +++ b/TP4/stub/1Iterable/MonMaillon.java @@ -0,0 +1,28 @@ +/** + MonMaillon code un maillon d'un brin d'ADN. + plusieurs instances reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base. + On n'utilise pas java.util et on recode tout. + +*/ +public class MonMaillon { + + + public MonMaillon(Base b){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public MonMaillon(Base b, MonMaillon l){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public Base getBase(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public MonMaillon getSuiteMaillon(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + +} + + diff --git a/TP4/stub/2Iterator/Base.java b/TP4/stub/2Iterator/Base.java new file mode 100644 index 0000000..5e6a4cf --- /dev/null +++ b/TP4/stub/2Iterator/Base.java @@ -0,0 +1,4 @@ +// juste un type énuméré pour nommer les bases +public enum Base { + A,C,G,T +} diff --git a/TP4/stub/2Iterator/Exemple.java b/TP4/stub/2Iterator/Exemple.java new file mode 100644 index 0000000..b48d0a7 --- /dev/null +++ b/TP4/stub/2Iterator/Exemple.java @@ -0,0 +1,35 @@ +// Fichier Exemple pour le dernier exercice sur l'ADN (Iterable) + +public class Exemple{ + + public static void main(String[] args) { + + // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table + // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon + + System.out.println("construction du brin GCTTAG"); + MonMaillon l = new MonMaillon(Base.G); + l = new MonMaillon(Base.A,l); + l = new MonMaillon(Base.T,l); + l = new MonMaillon(Base.T,l); + l = new MonMaillon(Base.C,l); + l = new MonMaillon(Base.G,l); + + MonBrin m = new MonBrin(l); + + System.out.println("l'affichage par défaut du brin ne va pas vous plaire"); + System.out.println(m.toString()); + + System.out.println("On peut afficher en itérant avec forEach (une méthode proposée par Iterable, regardez la doc)"); + m.forEach(b -> System.out.println(b)); + + System.out.println("On a découplé la navigation de la structuration en implémentant iterable plutôt que iterator. On peut maintenant naviguer 2 fois facilement, c'est vraiment trop fort."); + m.forEach(b -> System.out.println(b)); + + System.out.println("On peut même utiliser les boucles avancées de Java 8 et notre code en devient presque pythonesque"); + for(Base b: m){ + System.out.println(b); + } + } + +} diff --git a/TP4/stub/2Iterator/MonBrin.java b/TP4/stub/2Iterator/MonBrin.java new file mode 100644 index 0000000..b6782cc --- /dev/null +++ b/TP4/stub/2Iterator/MonBrin.java @@ -0,0 +1,37 @@ +import java.util.Iterator; +import java.util.NoSuchElementException; +/** + MonBrin code un brin d'ADN sous forme de liste simplement chaînée. + + Plusieurs instances de MonMaillon reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base. + + On n'utilise pas java.util et on recode tout. + + Cette version est correcte : la structuration et la navigation sont dans 2 classes séparées. +La classe MonBrin implémente Iterable au sens où elle peut générer à la demande un objet Iterator. + +NB : Notez que j'implémente Iterable plutôt que Iterable qui n'était pas tout à fait propre +c'est un peu technique et c'est lié aux types génériques. + Il y a des détails ici +https://stackoverflow.com/questions/20790770/why-cant-i-assign-a-raw-type-to-a-parameterized-type-java?rq=1 +*/ +public class MonBrin implements Iterable{ + + + public MonBrin(MonMaillon p){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public MonMaillon getDebut(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + /** Pour naviguer? + On implémente l'interface iterator de java.util ici + L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navigation fonctionne. + **/ + @Override + public Iterator iterator() { + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } +} diff --git a/TP4/stub/2Iterator/MonBrinIterator.java b/TP4/stub/2Iterator/MonBrinIterator.java new file mode 100644 index 0000000..a2a85e7 --- /dev/null +++ b/TP4/stub/2Iterator/MonBrinIterator.java @@ -0,0 +1,32 @@ +import java.util.Iterator; +import java.util.NoSuchElementException; + +/** +MonBrinIterator + +gère la navigation dans un Brin d'ADN + +*/ +public class MonBrinIterator implements Iterator { + + public MonBrinIterator(MonMaillon m){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + /** Pour naviguer? + On implémente l'interface iterable de java.util ici + L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navogation fonctionne. + **/ + @Override + public boolean hasNext(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + @Override + public Base next() { + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + +} + + diff --git a/TP4/stub/2Iterator/MonMaillon.java b/TP4/stub/2Iterator/MonMaillon.java new file mode 100644 index 0000000..d5e4c66 --- /dev/null +++ b/TP4/stub/2Iterator/MonMaillon.java @@ -0,0 +1,29 @@ +/** + MonMaillon code un maillon d'un brin d'ADN. + plusieurs instances reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base. + On n'utilise pas java.util et on recode tout. + +*/ +public class MonMaillon { + + //Le constructeur de base retourne un brin à une base; + public MonMaillon(Base b){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + // Le constructeur évolué ajoute une base à un brin. + public MonMaillon(Base b, MonMaillon l){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public Base getBase(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public MonMaillon getSuiteMaillon(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + +} + + diff --git a/TP4/stub/3IteratorDifferentInnerStructure/Base.java b/TP4/stub/3IteratorDifferentInnerStructure/Base.java new file mode 100644 index 0000000..5e6a4cf --- /dev/null +++ b/TP4/stub/3IteratorDifferentInnerStructure/Base.java @@ -0,0 +1,4 @@ +// juste un type énuméré pour nommer les bases +public enum Base { + A,C,G,T +} diff --git a/TP4/stub/3IteratorDifferentInnerStructure/Exemple.java b/TP4/stub/3IteratorDifferentInnerStructure/Exemple.java new file mode 100644 index 0000000..b4afd21 --- /dev/null +++ b/TP4/stub/3IteratorDifferentInnerStructure/Exemple.java @@ -0,0 +1,58 @@ +// Fichier Exemple pour le dernier exercice sur l'ADN (Iterable) + +public class Exemple{ + + public static void main(String[] args) { + + // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table + // codon CAT code Histidine + // codon CGT code Arginine + // codon GCC code Analine + // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon + + System.out.println("construction du brin CGT CAT CGT GCC CAT GCT TAG"); + MonBrin l = new MonBrin(Base.G); + l = new MonBrin(Base.A,l); + l = new MonBrin(Base.T,l); + // + l = new MonBrin(Base.T,l); + l = new MonBrin(Base.C,l); + l = new MonBrin(Base.G,l); + // + l = new MonBrin(Base.T,l); + l = new MonBrin(Base.A,l); + l = new MonBrin(Base.C,l); + // + l = new MonBrin(Base.C,l); + l = new MonBrin(Base.C,l); + l = new MonBrin(Base.G,l); + // + l = new MonBrin(Base.T,l); + l = new MonBrin(Base.G,l); + l = new MonBrin(Base.C,l); + // + l = new MonBrin(Base.T,l); + l = new MonBrin(Base.A,l); + l = new MonBrin(Base.C,l); + // + l = new MonBrin(Base.T,l); + l = new MonBrin(Base.G,l); + l = new MonBrin(Base.C,l); + // + + System.out.println("l'affichage par défaut ne va toujours pas vous plaire"); + System.out.println(l.toString()); + + System.out.println("On peut afficher en itérant avec forEach (une méthode proposée par Iterable, regardez la doc)"); + l.forEach(b -> System.out.println(b)); + + System.out.println("On a découplé la navigation de la structuration en implémentant iterable plutôt que iterator. On peut maintenant naviguer 2 fois facilement, c'est vraiment trop fort."); + l.forEach(b -> System.out.println(b)); + + System.out.println("On peut même utiliser les boucles avancées de Java 8 et notre code en devient presque pythonesque"); + for(Base b: l){ + System.out.println(b); + } + } + +} diff --git a/TP4/stub/3IteratorDifferentInnerStructure/MonBrin.java b/TP4/stub/3IteratorDifferentInnerStructure/MonBrin.java new file mode 100644 index 0000000..6cd0ad1 --- /dev/null +++ b/TP4/stub/3IteratorDifferentInnerStructure/MonBrin.java @@ -0,0 +1,83 @@ +import java.util.Iterator; +import java.util.NoSuchElementException; + +/** +MonBrin code un brin d'ADN sous forme de tableaux. Dynamiquement, la taille du tableau est augmentée en cas de besoin (la taille est initialement 3*4 elle est multipliée ensuite pour être toujours de la forme 3*2^n). +On utilise System.arraycopy et java.util.Arrays.copyOfRange pour faire ça efficacement. +voir +https://docs.oracle.com/javase/8/docs/api/java/lang/System.html#arraycopy-java.lang.Object-int-java.lang.Object-int-int- +https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#copyOfRange-T:A-int-int- + +Cette version est correcte : la structuration et la navigation sont dans 2 classes séparées. +La classe MonBrin implémente Iterable au sens où elle peut générer à la demande un objet Iterator. + +NB : Notez que j'implémente Iterable plutôt que Iterable qui n'était pas tout à fait propre +c'est un peu technique et c'est lié aux types génériques. + Il y a des détails ici +https://stackoverflow.com/questions/20790770/why-cant-i-assign-a-raw-type-to-a-parameterized-type-java?rq=1 +*/ + +public class MonBrin implements Iterable { + + /** + C'est le constructeur de base (pun intended) qui construit un brin à une base + + @param b : la base + + Ici je pourrais mettre un commentaire plus long sur le fonctionement détaillé de mon super constructeur. + + */ + public MonBrin(Base b){ + + } + + /** + C'est le constructeur évolué qui construit un brin en ajoutant la base donnée en argument devant le brin donné en argument. + + @param b : la base qui va aller devant + @param l : le brin qui sera à la suite + + NB. Ce constructeur est un peu obsolète avec la nouvelle structure interne. + On devrait en ajouter un qui prend en paramètre un tableau de bases. + */ + public MonBrin(Base b, MonBrin l){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public Base getBase(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public int length(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public int limit(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public int capacity(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public Base getBase(int i){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public Base[] getBases(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + /** Pour naviguer? + On implémente l'interface iterator de java.util ici + L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navigation fonctionne. + **/ + @Override + public Iterator iterator() { + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + +} + + diff --git a/TP4/stub/3IteratorDifferentInnerStructure/MonBrinIterator.java b/TP4/stub/3IteratorDifferentInnerStructure/MonBrinIterator.java new file mode 100644 index 0000000..363d355 --- /dev/null +++ b/TP4/stub/3IteratorDifferentInnerStructure/MonBrinIterator.java @@ -0,0 +1,33 @@ +import java.util.Iterator; +import java.util.NoSuchElementException; + +/** +MonBrinIterator + +gère la navigation dans un Brin d'ADN + +*/ +public class MonBrinIterator implements Iterator { + + //Le constructeur de base retourne un brin à une base; + public MonBrinIterator(MonBrin brin){ + } + + /** Pour naviguer? + On implémente l'interface iterable de java.util ici + L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navigation fonctionne. + **/ + + @Override + public boolean hasNext(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + @Override + public Base next() { + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + +} + + diff --git a/TP4/stub/explication.txt b/TP4/stub/explication.txt new file mode 100644 index 0000000..9254e46 --- /dev/null +++ b/TP4/stub/explication.txt @@ -0,0 +1,20 @@ +Les biologistes sont des gens étranges pour lesquels les string n'ont que 4 lettres : A,C,G ou T. +Ils ne connaissent pas les String, ils parlent d'ADN. + + +Le Brin est une succession de Maillons. +Il suffit de connaître le premier maillon pour définir un brin d'ADN. + + +----------+ + | maillon | + | | _____ next __> autre Maillon + | | + +----+-----+ + | + | val + \|/ + +----------+ + | Base | + | A | + | | + +----+-----+ diff --git a/TP5/stub/exo3/Chef.java b/TP5/stub/exo3/Chef.java new file mode 100644 index 0000000..38ed1b9 --- /dev/null +++ b/TP5/stub/exo3/Chef.java @@ -0,0 +1,48 @@ +import java.util.LinkedHashSet; +import java.util.Objects; + +/** feuille du motif composite */ +public class Chef extends Person { + + + public boolean addSubalterne(Person p){ + + } + + + + /** constructeur + * + * @param n fun factor + * + */ + public Chef(int n){ + super(n); + // d'autres choses peut-être. + } + + + /** + * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. + * + * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle. + * + */ + public int bestPartyWithoutMe(){ + // to do + } + + /** + * La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). + * soit c'est la meilleure fête avec moi. + * + * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle). + * + */ + public int bestParty(){ + // to do + } + +} + + diff --git a/TP5/stub/exo3/Exemple.java b/TP5/stub/exo3/Exemple.java new file mode 100644 index 0000000..9a23013 --- /dev/null +++ b/TP5/stub/exo3/Exemple.java @@ -0,0 +1,36 @@ +public class Exemple { + public static void main(String[] args) { + // bar 2 + // foo 5 + // titi 4 + // tata 4 + // toto 6 + // tete 6 + + Travailleur titi = new Travailleur(4); + Travailleur tata = new Travailleur(4); + Travailleur toto = new Travailleur(6); + + Chef foo = new Chef(5); + foo.addSubalterne(titi); + foo.addSubalterne(tata); + foo.addSubalterne(toto); + System.out.println(foo.bestParty()); + System.out.println(foo.bestPartyWithoutMe()); + + Travailleur tete = new Travailleur(6); + // System.out.println(tete.bestParty()); + // System.out.println(tete.bestPartyWithoutMe()); + + Chef bar = new Chef(2); + bar.addSubalterne(foo); + bar.addSubalterne(tete); + System.out.println(bar.bestParty()); + //System.out.println(bar.bestPartyWithoutMe()); + } + +} + + + + diff --git a/TP5/stub/exo3/Exemple2.java b/TP5/stub/exo3/Exemple2.java new file mode 100644 index 0000000..808a518 --- /dev/null +++ b/TP5/stub/exo3/Exemple2.java @@ -0,0 +1,33 @@ +public class Exemple2 { + public static void main(String[] args) { + // Exemple inspiré question Thibault B. + // 1 + // 10 + // 1 + // 1 + // 10 + // 3 + // 4 + + Travailleur a = new Travailleur(3); + Travailleur b = new Travailleur(4); + Chef c = new Chef(10); + c.addSubalterne(a); + c.addSubalterne(b); + Chef d = new Chef(1); + d.addSubalterne(c); + Chef e = new Chef(1); + e.addSubalterne(d); + Chef f = new Chef(10); + f.addSubalterne(e); + Chef g = new Chef(1); + g.addSubalterne(f); + + System.out.println(g.bestParty()); + } + +} + + + + diff --git a/TP5/stub/exo3/Exemple3.java b/TP5/stub/exo3/Exemple3.java new file mode 100644 index 0000000..55651c9 --- /dev/null +++ b/TP5/stub/exo3/Exemple3.java @@ -0,0 +1,43 @@ +public class Exemple3 { + public static void main(String[] args) { + + Travailleur a = new Travailleur(3); + Travailleur b = new Travailleur(4); + Chef c = new Chef(10); + c.addSubalterne(a); + c.addSubalterne(b); + Chef d = new Chef(1); + d.addSubalterne(c); + Chef e = new Chef(1); + e.addSubalterne(d); + Chef f = new Chef(10); + f.addSubalterne(e); + Chef g = new Chef(1); + g.addSubalterne(f); + + Travailleur titi = new Travailleur(4); + Travailleur tata = new Travailleur(4); + Travailleur toto = new Travailleur(6); + Chef foo = new Chef(5); + foo.addSubalterne(titi); + foo.addSubalterne(tata); + foo.addSubalterne(toto); + Chef bar = new Chef(2); + bar.addSubalterne(foo); + Travailleur tete = new Travailleur(6); + bar.addSubalterne(tete); + + Chef x = new Chef(2); + x.addSubalterne(g); + x.addSubalterne(bar); + Chef y = new Chef(39); + y.addSubalterne(x); + + System.out.println(y.bestParty()); + } + +} + + + + diff --git a/TP5/stub/exo3/Person.java b/TP5/stub/exo3/Person.java new file mode 100644 index 0000000..b4f1951 --- /dev/null +++ b/TP5/stub/exo3/Person.java @@ -0,0 +1,44 @@ + +/** "Les personnes sont soit des chefs, soit des travailleurs" */ +public abstract class Person{ + /** + * valeur indiquant le niveau de coolitude de la personne + */ + private int funFactor; + + /** + * @return la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête. + * + */ + public int getFunFactor(){ + return this.funFactor; + } + + /** + * constructeur + * + * NB. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées. + * + * @see Travailleur, Chef + */ + // + public Person(int n){ + if (n < 0) + throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n); + this.funFactor = n; + } + + /** + * + * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle. + */ + public abstract int bestPartyWithoutMe(); + + + /** + * + * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle). + */ + public abstract int bestParty(); +} + diff --git a/TP5/stub/exo3/Travailleur.java b/TP5/stub/exo3/Travailleur.java new file mode 100644 index 0000000..7df408b --- /dev/null +++ b/TP5/stub/exo3/Travailleur.java @@ -0,0 +1,31 @@ +/** feuille du motif composite */ +public class Travailleur extends Person { + + /** constructeur + * + * @param n fun factor + * + */ + public Travailleur(int n){ + super(n); + } + + /** + * + * @return fête sans le travailleur + */ + public int bestPartyWithoutMe(){ + // return null; + } + + /** + * @return fête avec le travailleur + */ + public int bestParty(){ + // return null; + } + + +} + + diff --git a/TP5/stub/exo4/Chef.java b/TP5/stub/exo4/Chef.java new file mode 100644 index 0000000..38ed1b9 --- /dev/null +++ b/TP5/stub/exo4/Chef.java @@ -0,0 +1,48 @@ +import java.util.LinkedHashSet; +import java.util.Objects; + +/** feuille du motif composite */ +public class Chef extends Person { + + + public boolean addSubalterne(Person p){ + + } + + + + /** constructeur + * + * @param n fun factor + * + */ + public Chef(int n){ + super(n); + // d'autres choses peut-être. + } + + + /** + * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. + * + * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle. + * + */ + public int bestPartyWithoutMe(){ + // to do + } + + /** + * La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). + * soit c'est la meilleure fête avec moi. + * + * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle). + * + */ + public int bestParty(){ + // to do + } + +} + + diff --git a/TP5/stub/exo4/Exemple.java b/TP5/stub/exo4/Exemple.java new file mode 100644 index 0000000..9a23013 --- /dev/null +++ b/TP5/stub/exo4/Exemple.java @@ -0,0 +1,36 @@ +public class Exemple { + public static void main(String[] args) { + // bar 2 + // foo 5 + // titi 4 + // tata 4 + // toto 6 + // tete 6 + + Travailleur titi = new Travailleur(4); + Travailleur tata = new Travailleur(4); + Travailleur toto = new Travailleur(6); + + Chef foo = new Chef(5); + foo.addSubalterne(titi); + foo.addSubalterne(tata); + foo.addSubalterne(toto); + System.out.println(foo.bestParty()); + System.out.println(foo.bestPartyWithoutMe()); + + Travailleur tete = new Travailleur(6); + // System.out.println(tete.bestParty()); + // System.out.println(tete.bestPartyWithoutMe()); + + Chef bar = new Chef(2); + bar.addSubalterne(foo); + bar.addSubalterne(tete); + System.out.println(bar.bestParty()); + //System.out.println(bar.bestPartyWithoutMe()); + } + +} + + + + diff --git a/TP5/stub/exo4/Exemple2.java b/TP5/stub/exo4/Exemple2.java new file mode 100644 index 0000000..808a518 --- /dev/null +++ b/TP5/stub/exo4/Exemple2.java @@ -0,0 +1,33 @@ +public class Exemple2 { + public static void main(String[] args) { + // Exemple inspiré question Thibault B. + // 1 + // 10 + // 1 + // 1 + // 10 + // 3 + // 4 + + Travailleur a = new Travailleur(3); + Travailleur b = new Travailleur(4); + Chef c = new Chef(10); + c.addSubalterne(a); + c.addSubalterne(b); + Chef d = new Chef(1); + d.addSubalterne(c); + Chef e = new Chef(1); + e.addSubalterne(d); + Chef f = new Chef(10); + f.addSubalterne(e); + Chef g = new Chef(1); + g.addSubalterne(f); + + System.out.println(g.bestParty()); + } + +} + + + + diff --git a/TP5/stub/exo4/Exemple3.java b/TP5/stub/exo4/Exemple3.java new file mode 100644 index 0000000..55651c9 --- /dev/null +++ b/TP5/stub/exo4/Exemple3.java @@ -0,0 +1,43 @@ +public class Exemple3 { + public static void main(String[] args) { + + Travailleur a = new Travailleur(3); + Travailleur b = new Travailleur(4); + Chef c = new Chef(10); + c.addSubalterne(a); + c.addSubalterne(b); + Chef d = new Chef(1); + d.addSubalterne(c); + Chef e = new Chef(1); + e.addSubalterne(d); + Chef f = new Chef(10); + f.addSubalterne(e); + Chef g = new Chef(1); + g.addSubalterne(f); + + Travailleur titi = new Travailleur(4); + Travailleur tata = new Travailleur(4); + Travailleur toto = new Travailleur(6); + Chef foo = new Chef(5); + foo.addSubalterne(titi); + foo.addSubalterne(tata); + foo.addSubalterne(toto); + Chef bar = new Chef(2); + bar.addSubalterne(foo); + Travailleur tete = new Travailleur(6); + bar.addSubalterne(tete); + + Chef x = new Chef(2); + x.addSubalterne(g); + x.addSubalterne(bar); + Chef y = new Chef(39); + y.addSubalterne(x); + + System.out.println(y.bestParty()); + } + +} + + + + diff --git a/TP5/stub/exo4/Person.java b/TP5/stub/exo4/Person.java new file mode 100644 index 0000000..b4f1951 --- /dev/null +++ b/TP5/stub/exo4/Person.java @@ -0,0 +1,44 @@ + +/** "Les personnes sont soit des chefs, soit des travailleurs" */ +public abstract class Person{ + /** + * valeur indiquant le niveau de coolitude de la personne + */ + private int funFactor; + + /** + * @return la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête. + * + */ + public int getFunFactor(){ + return this.funFactor; + } + + /** + * constructeur + * + * NB. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées. + * + * @see Travailleur, Chef + */ + // + public Person(int n){ + if (n < 0) + throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n); + this.funFactor = n; + } + + /** + * + * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle. + */ + public abstract int bestPartyWithoutMe(); + + + /** + * + * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle). + */ + public abstract int bestParty(); +} + diff --git a/TP5/stub/exo4/Travailleur.java b/TP5/stub/exo4/Travailleur.java new file mode 100644 index 0000000..7df408b --- /dev/null +++ b/TP5/stub/exo4/Travailleur.java @@ -0,0 +1,31 @@ +/** feuille du motif composite */ +public class Travailleur extends Person { + + /** constructeur + * + * @param n fun factor + * + */ + public Travailleur(int n){ + super(n); + } + + /** + * + * @return fête sans le travailleur + */ + public int bestPartyWithoutMe(){ + // return null; + } + + /** + * @return fête avec le travailleur + */ + public int bestParty(){ + // return null; + } + + +} + + diff --git a/TP5/stub/exo5/Chef.java b/TP5/stub/exo5/Chef.java new file mode 100644 index 0000000..38ed1b9 --- /dev/null +++ b/TP5/stub/exo5/Chef.java @@ -0,0 +1,48 @@ +import java.util.LinkedHashSet; +import java.util.Objects; + +/** feuille du motif composite */ +public class Chef extends Person { + + + public boolean addSubalterne(Person p){ + + } + + + + /** constructeur + * + * @param n fun factor + * + */ + public Chef(int n){ + super(n); + // d'autres choses peut-être. + } + + + /** + * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. + * + * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle. + * + */ + public int bestPartyWithoutMe(){ + // to do + } + + /** + * La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). + * soit c'est la meilleure fête avec moi. + * + * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle). + * + */ + public int bestParty(){ + // to do + } + +} + + diff --git a/TP5/stub/exo5/Exemple.java b/TP5/stub/exo5/Exemple.java new file mode 100644 index 0000000..9a23013 --- /dev/null +++ b/TP5/stub/exo5/Exemple.java @@ -0,0 +1,36 @@ +public class Exemple { + public static void main(String[] args) { + // bar 2 + // foo 5 + // titi 4 + // tata 4 + // toto 6 + // tete 6 + + Travailleur titi = new Travailleur(4); + Travailleur tata = new Travailleur(4); + Travailleur toto = new Travailleur(6); + + Chef foo = new Chef(5); + foo.addSubalterne(titi); + foo.addSubalterne(tata); + foo.addSubalterne(toto); + System.out.println(foo.bestParty()); + System.out.println(foo.bestPartyWithoutMe()); + + Travailleur tete = new Travailleur(6); + // System.out.println(tete.bestParty()); + // System.out.println(tete.bestPartyWithoutMe()); + + Chef bar = new Chef(2); + bar.addSubalterne(foo); + bar.addSubalterne(tete); + System.out.println(bar.bestParty()); + //System.out.println(bar.bestPartyWithoutMe()); + } + +} + + + + diff --git a/TP5/stub/exo5/Exemple2.java b/TP5/stub/exo5/Exemple2.java new file mode 100644 index 0000000..808a518 --- /dev/null +++ b/TP5/stub/exo5/Exemple2.java @@ -0,0 +1,33 @@ +public class Exemple2 { + public static void main(String[] args) { + // Exemple inspiré question Thibault B. + // 1 + // 10 + // 1 + // 1 + // 10 + // 3 + // 4 + + Travailleur a = new Travailleur(3); + Travailleur b = new Travailleur(4); + Chef c = new Chef(10); + c.addSubalterne(a); + c.addSubalterne(b); + Chef d = new Chef(1); + d.addSubalterne(c); + Chef e = new Chef(1); + e.addSubalterne(d); + Chef f = new Chef(10); + f.addSubalterne(e); + Chef g = new Chef(1); + g.addSubalterne(f); + + System.out.println(g.bestParty()); + } + +} + + + + diff --git a/TP5/stub/exo5/Exemple3.java b/TP5/stub/exo5/Exemple3.java new file mode 100644 index 0000000..55651c9 --- /dev/null +++ b/TP5/stub/exo5/Exemple3.java @@ -0,0 +1,43 @@ +public class Exemple3 { + public static void main(String[] args) { + + Travailleur a = new Travailleur(3); + Travailleur b = new Travailleur(4); + Chef c = new Chef(10); + c.addSubalterne(a); + c.addSubalterne(b); + Chef d = new Chef(1); + d.addSubalterne(c); + Chef e = new Chef(1); + e.addSubalterne(d); + Chef f = new Chef(10); + f.addSubalterne(e); + Chef g = new Chef(1); + g.addSubalterne(f); + + Travailleur titi = new Travailleur(4); + Travailleur tata = new Travailleur(4); + Travailleur toto = new Travailleur(6); + Chef foo = new Chef(5); + foo.addSubalterne(titi); + foo.addSubalterne(tata); + foo.addSubalterne(toto); + Chef bar = new Chef(2); + bar.addSubalterne(foo); + Travailleur tete = new Travailleur(6); + bar.addSubalterne(tete); + + Chef x = new Chef(2); + x.addSubalterne(g); + x.addSubalterne(bar); + Chef y = new Chef(39); + y.addSubalterne(x); + + System.out.println(y.bestParty()); + } + +} + + + + diff --git a/TP5/stub/exo5/Person.java b/TP5/stub/exo5/Person.java new file mode 100644 index 0000000..b4f1951 --- /dev/null +++ b/TP5/stub/exo5/Person.java @@ -0,0 +1,44 @@ + +/** "Les personnes sont soit des chefs, soit des travailleurs" */ +public abstract class Person{ + /** + * valeur indiquant le niveau de coolitude de la personne + */ + private int funFactor; + + /** + * @return la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête. + * + */ + public int getFunFactor(){ + return this.funFactor; + } + + /** + * constructeur + * + * NB. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées. + * + * @see Travailleur, Chef + */ + // + public Person(int n){ + if (n < 0) + throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n); + this.funFactor = n; + } + + /** + * + * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle. + */ + public abstract int bestPartyWithoutMe(); + + + /** + * + * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle). + */ + public abstract int bestParty(); +} + diff --git a/TP5/stub/exo5/Travailleur.java b/TP5/stub/exo5/Travailleur.java new file mode 100644 index 0000000..7df408b --- /dev/null +++ b/TP5/stub/exo5/Travailleur.java @@ -0,0 +1,31 @@ +/** feuille du motif composite */ +public class Travailleur extends Person { + + /** constructeur + * + * @param n fun factor + * + */ + public Travailleur(int n){ + super(n); + } + + /** + * + * @return fête sans le travailleur + */ + public int bestPartyWithoutMe(){ + // return null; + } + + /** + * @return fête avec le travailleur + */ + public int bestParty(){ + // return null; + } + + +} + +