From c0b06ea83777dab28f22dad2dcd6704c31669ee4 Mon Sep 17 00:00:00 2001 From: HORVILLE Ewen Date: Mon, 23 May 2022 16:20:43 +0200 Subject: [PATCH] DEV 2.2 & TP14 --- APL2.1/TP14/Homotetie/Homotetie.class | Bin 0 -> 891 bytes APL2.1/TP14/Homotetie/Homotetie.java | 25 +++ APL2.1/TP14/Homotetie/polygone.bin | Bin 0 -> 320 bytes APL2.1/TP14/Homotetie/polygonex2.bin | Bin 0 -> 160 bytes APL2.1/TP14/Memoire/CloseListener.class | Bin 0 -> 1842 bytes APL2.1/TP14/Memoire/CloseListener.java | 78 +++++++++ APL2.1/TP14/Memoire/Fond.class | Bin 0 -> 1983 bytes APL2.1/TP14/Memoire/Fond.java | 62 ++++++++ APL2.1/TP14/Memoire/Observer.class | Bin 0 -> 877 bytes APL2.1/TP14/Memoire/Observer.java | 24 +++ APL2.1/TP14/Memoire/save.dat | Bin 0 -> 26 bytes APL2.1/TP14/Polygone/Polygone.class | Bin 0 -> 1868 bytes APL2.1/TP14/Polygone/Polygone.java | 56 +++++++ APL2.1/TP14/Polygone/Test.class | Bin 0 -> 661 bytes APL2.1/TP14/Polygone/Test.java | 17 ++ APL2.1/TP14/Polygone/polygone.bin | Bin 0 -> 320 bytes .../TP01/MonInt/Ma-Touille-pour-les-tests.txt | 3 + DEV 2.2/TP01/MonInt/MonInt.class | Bin 0 -> 2485 bytes DEV 2.2/TP01/MonInt/MonInt.java | 113 +++++++++++++ DEV 2.2/TP01/v0/Carte.class | Bin 0 -> 2437 bytes DEV 2.2/TP01/v0/Carte.java | 148 ++++++++++++++++++ DEV 2.2/TP01/v0/EnsembleCarte.class | Bin 0 -> 1829 bytes DEV 2.2/TP01/v0/EnsembleCarte.java | 142 +++++++++++++++++ DEV 2.2/TP01/v0/Joueur.class | Bin 0 -> 1481 bytes DEV 2.2/TP01/v0/Joueur.java | 96 ++++++++++++ DEV 2.2/TP01/v0/Table.class | Bin 0 -> 1360 bytes DEV 2.2/TP01/v0/Table.java | 126 +++++++++++++++ DEV 2.2/TP01/v0/TestCarte.class | Bin 0 -> 1476 bytes DEV 2.2/TP01/v0/TestCarte.java | 84 ++++++++++ DEV 2.2/TP01/v0/TestEnsemble.java | 0 30 files changed, 974 insertions(+) create mode 100644 APL2.1/TP14/Homotetie/Homotetie.class create mode 100644 APL2.1/TP14/Homotetie/Homotetie.java create mode 100644 APL2.1/TP14/Homotetie/polygone.bin create mode 100644 APL2.1/TP14/Homotetie/polygonex2.bin create mode 100644 APL2.1/TP14/Memoire/CloseListener.class create mode 100644 APL2.1/TP14/Memoire/CloseListener.java create mode 100644 APL2.1/TP14/Memoire/Fond.class create mode 100644 APL2.1/TP14/Memoire/Fond.java create mode 100644 APL2.1/TP14/Memoire/Observer.class create mode 100644 APL2.1/TP14/Memoire/Observer.java create mode 100644 APL2.1/TP14/Memoire/save.dat create mode 100644 APL2.1/TP14/Polygone/Polygone.class create mode 100644 APL2.1/TP14/Polygone/Polygone.java create mode 100644 APL2.1/TP14/Polygone/Test.class create mode 100644 APL2.1/TP14/Polygone/Test.java create mode 100644 APL2.1/TP14/Polygone/polygone.bin create mode 100644 DEV 2.2/TP01/MonInt/Ma-Touille-pour-les-tests.txt create mode 100644 DEV 2.2/TP01/MonInt/MonInt.class create mode 100644 DEV 2.2/TP01/MonInt/MonInt.java create mode 100644 DEV 2.2/TP01/v0/Carte.class create mode 100644 DEV 2.2/TP01/v0/Carte.java create mode 100644 DEV 2.2/TP01/v0/EnsembleCarte.class create mode 100644 DEV 2.2/TP01/v0/EnsembleCarte.java create mode 100644 DEV 2.2/TP01/v0/Joueur.class create mode 100644 DEV 2.2/TP01/v0/Joueur.java create mode 100644 DEV 2.2/TP01/v0/Table.class create mode 100644 DEV 2.2/TP01/v0/Table.java create mode 100644 DEV 2.2/TP01/v0/TestCarte.class create mode 100644 DEV 2.2/TP01/v0/TestCarte.java create mode 100644 DEV 2.2/TP01/v0/TestEnsemble.java diff --git a/APL2.1/TP14/Homotetie/Homotetie.class b/APL2.1/TP14/Homotetie/Homotetie.class new file mode 100644 index 0000000000000000000000000000000000000000..918ff0f1046192b9b943e85b97b5ba468caaaa67 GIT binary patch literal 891 zcmZuvOLNjt6#i~Wav=>5c@$8q)>olWs8vzxV^izMNXr67Wn2ZC!COPZV9>hvm$>P= z8<>$9e}F&1zu-S`A)X5=Su~kB_a^6jk9*Gj{`>1U0FUuN#}Wb@iUAcGL+r@>V3uvu z>6Yv5Bdg;vXpe*=yeABST>d3TkRd%Q5^njKu&t`oA9@XMV41xjbOxjE+Ml|vW0l&% z(ZOLz>M%npS6h%1Kseopk}&Ecd}?~8k5ESh=OjGNkogNISzpDBAxT-krTWnGd0JtJ z{PT3YJ$IFW!IAaBq_7{RBZCW4`65Ghq3kaqY3c8hfy=nU5TeEj+ics`tW#B)yK3N? z%yH_@Vb$>@>kR`pvCa_uI1nCnk2MFohhZi6=BxoQgd3jOdAD!&XZ0Kv z5tTIC31WN66CfdX+6v?HuQ9+nu2s*t9ER$OU>omD7 zM6rVy_Go=UnL3haB2CB?UejFe5UK!WO5QogT`psUBf*hjbg*AYPl=6DN`|65^*w?t G;r<`7zb5@*wj-_QC9j=m!ARDHAXN literal 0 HcmV?d00001 diff --git a/APL2.1/TP14/Memoire/CloseListener.class b/APL2.1/TP14/Memoire/CloseListener.class new file mode 100644 index 0000000000000000000000000000000000000000..15d23fd09e0159ba0caefbdcbf7d5fe00889e136 GIT binary patch literal 1842 zcmah}O>o^Q7oj1v3?RGA!-{dL9O`|g%Bk*rXSi1+>&d^y$oDJy6SY% znXbC(jNR3pYr7ybb*AmQ|EQa$&*38>)=n1pJ?FmXIq&m+p1=P2?RNmTQ1ruvV-ju+ z9`p$eJlD7Ncv-hf@ofINQE&wMlBQ)kw*`(x#~=IQg-^n-p&y#Sa0{+CoVc-VSWbM+ zw2F3PLG1;6CBwW&|SIHiJnPaqWS@qwnuIHN)eBBBt( z0+9|v(e@CwPyvi+7{zHCXJBh)(b;I_B;`i{XEc1Ej#SL|470RB;sDNRIFAbg{nV!I zg6^2M#fZDPP$CSiX4cBm8;P`%pT1*7d{F9dB^9uTrhG~UU>UBRp#!ZQYh8Y#i!QB=u zTY;cQOS2NU1Wt7GpUN)m6pV_B&4)YqMB=W7Su|8V^;o-K?EzKG2X>&Fm?Z?HapjxofP|*Q*;`!<4Wp4(;>=M7$*V#_BgAFV_zOh!la6yGmztZ zBJe367cW=7DU@sc8|5mvdM@umyyiyW38gv){FLkXj8Z`({9OG00~;XV^P^#>2>YT7 z6EEq6kJesJG$H>)AoB*n^*0z?A3Cv%&@RHuSDJW#+D$n&?V&uI=%c)tkg<@viOaE& zN6AQE6O%u7cOSNQvWXj1y+R=2{S~((-X`W_P27KnBAjryPqc(5;*QW}Hsb!{75bNX zktg%7>E~5?{UwqpVG|bD2zKx-yYxGJj~}>t@e^K9?`q{Pk1*pJrgntLQHKS3 z3@x3-4V>c(e;!NJKEy@Z9;fw7c*b|8#K&Wk<8L8`3MR=jMWzwjzea{B{7ehK;5zZZ zQ~39|@k->Rk^zaJ5E608=Yng}$Ei*3G0W~=2-GlV_UN9cS52L|l=1!z7hjU3WVN1l htM&i2ze(7$qhWUl`|4=e0%7{mum^GT^oh5>;AzTc2*X0_E>o(%X`rjuhIJ_?Ur@@UcLTX<63`3U$V=_|lP{ zz}W-g$SoQfJ1o&k>qP^XaG9l|34!DRrCGOBb{#5C4K-_`fbBo(_ykup=mtK;B*A&I z;=7*Am=!-KeV>J^2pntL+XEd`KFG&afv%tyyAkV{QlK<^X5e#NZ-QF39n0O`6?qq^ z!xAk}vj%S9rhv}!EZG%%wa9h}C00}+ZVAMLO51L$VdtE3)n~6sv!r2;LGQBDc2OQ+ zMsb%#sF+)F)H2x`w_)f=V_x;g0-LOrJK8;<6hxH9eFI-0$AZ#}HRo_hI2&^sz7#mJ z*LSmS(PeQLv8+rEsAS{~tl$B2MIg!lfU5;H zsw#vtZ1^^=K%gB=Fd{rF{5Hs2@D3;I5N}8b_&gOGh@t~kY>`%?f3u-R+j-r6kNYzf-a`0GhM^A6dz~yL!U=4gVg!o z$-QdeB)W+H2*$aAucC)NAH#ieR?v?p+^}mHV9kyb;tA|f`a7J$E1brUT#`RgvqPC=*hN!M?ytzPAN+RiJ@$ls-@D0wE^|afnosn{=2!M=*m?S{hOdMM)5n31WGn2NWuW>W{2ldK zA29L3^x6NU@y>2qXIh+$A#u#d-0X9^XEr*= zqAM9@cP!hIuNeZld^?ITA{wGPu0dy5^3wTuiiLAZrLyeUl3TWL3FiibaS5l%ZP5>7i6OMlN4ALI7M3;K*0F*N!`wx! zWvB1B)R@Ccwc2<`h59x51Qeo*(zv4|i@OZ5p^$sL`=RGLBh`Xr?rL_v9mX0%u>6_Z ziZiDpuLy(X!%{tr4F;{odsGZp(M=s&Dyr2=Z!7hKl7{+n5%o7-rB2jGgN|?yc&D#!xHrG1aNj%bK#@w)q`5Cs_T8Ou@M4`}aLR zQ83m|5v6#6d_^_mQLPaLpni@Rl1N~Ywk!*S29zYq6t-#Mc4^wrDJzD+A7nMW(2$Pn Kr0JyxQ~U=Ai^UfJ literal 0 HcmV?d00001 diff --git a/APL2.1/TP14/Memoire/Observer.java b/APL2.1/TP14/Memoire/Observer.java new file mode 100644 index 0000000..0f416c6 --- /dev/null +++ b/APL2.1/TP14/Memoire/Observer.java @@ -0,0 +1,24 @@ +import java.awt.Color; +import java.awt.event.*; +import javax.swing.JPanel; +import javax.swing.JButton; + +class Observer implements ActionListener { + public Observer() { + + } + + public void actionPerformed(ActionEvent evt) { + String name = evt.getActionCommand(); + JPanel f = (JPanel)((JButton)evt.getSource()).getParent(); + + + if (name == "Jaune") { + f.setBackground(Color.YELLOW); + } else if (name == "Cyan") { + f.setBackground(Color.CYAN); + } else if (name == "Magenta") { + f.setBackground(Color.MAGENTA); + } + } +} \ No newline at end of file diff --git a/APL2.1/TP14/Memoire/save.dat b/APL2.1/TP14/Memoire/save.dat new file mode 100644 index 0000000000000000000000000000000000000000..8e58a8d259052c1a6b30222d0b76741af76cc560 GIT binary patch literal 26 ecmZ4UmVvcggn@zCmVto@NHe5>@c(!3-T?qfa|aOs literal 0 HcmV?d00001 diff --git a/APL2.1/TP14/Polygone/Polygone.class b/APL2.1/TP14/Polygone/Polygone.class new file mode 100644 index 0000000000000000000000000000000000000000..255faa8c435ebdab44af7e58662933b6dd1d88bc GIT binary patch literal 1868 zcmaJ?T~`}b6y28qlY}8qzNu0vg7OiQTCA<6ppcf5HWVxfQv4c{DH$@%gv>oV)Md`<#37+n+B_0L-8oMH50Ansv0G zRiJCvI53Wq-l65}B=4>mj%f?D-n1M`&I*LaC)PED1^QK3(sGjvmThL7Qbn%HvT5vv z5fz9fk|o!!?zoPb*tVP~H0TPxU7&Y7>+iG;!gC8xNh!#V0OT!08Ue^CVz{8TcL@wM zw)5aX1QAqFkB(mS2}DTEvW;!q^a*Do7{H*0i#p!Gn*!mL1~&n5B+#_w2VBzemU=5_ zNDP;Cj3_9Ln(`S(Mlgyo4e#i97vln*0S#48ntMFRtw_qNt0TP?N^5wM>Y~$=I;Ie( z$~~iKrd=mz$PG&tIP;|8NKc?|Jd>F??@km6BsE;o@xC&!`^@;j0pwXy$Jw+xhG`ui zs7$uxY}Ye2d>Gi2S-yRgGfUEP8JfTi1^Ur{va-CrYv!cy=>SqXZYnSuQ8IW$6tnn5 z!>2mtFfVYyXJZ`7WO-& zUM=d#;I2UXjw$DjTydxDR-8QRG6&FIKlj(NYb zw{4c!>UG?{Drv@&QEEKL{A{G%y%H~(LwU@a@R{phdty(f)6TTIQKP%S2QUfAw*!HR=%~Tj=8Y|+%LO{IAM(*K9D^6Lt5nT6HFJKw|)TaG_tbMZ&sOSD2D2Z%N_ z^8-AYJcf7$ZL=$KjJE76#5Sjn(YZ7kuc5m$Z2uhn3H`x`q0sEmc?{P>xJN66HV9{dZ@LBM1H literal 0 HcmV?d00001 diff --git a/APL2.1/TP14/Polygone/Polygone.java b/APL2.1/TP14/Polygone/Polygone.java new file mode 100644 index 0000000..65be658 --- /dev/null +++ b/APL2.1/TP14/Polygone/Polygone.java @@ -0,0 +1,56 @@ + + +import javax.swing.*; +import java.awt.*; +import java.io.DataInputStream; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.ObjectInputStream; + +public class Polygone extends JPanel { + private int[] x; + private int[] y; + + public Polygone() { + super(); + + try { + + FileInputStream fis = new FileInputStream("./polygone.bin"); + DataInputStream b = new DataInputStream(fis); + + x = new int[b.available() / 8]; + y = new int[b.available() / 8]; + + for (int i = 0; i < x.length; i++) { + x[i] = b.readInt() * 2; + y[i] = b.readInt() * 2; + System.out.println(x[i] + ", " + y[i]); + } + + b.close(); + } catch (IOException e) { + System.out.println(e); + } + + this.repaint(); + } + + @Override + protected void paintComponent(Graphics g) { + // obligatoire : on crée un nouveau pinceau pour pouvoir le modifier plus tard + Graphics secondPinceau = g.create(); + // obligatoire : si le composant n'est pas censé être transparent + if (this.isOpaque()) { + // obligatoire : on repeint toute la surface avec la couleur de fond + secondPinceau.setColor(this.getBackground()); + secondPinceau.fillRect(0, 0, this.getWidth(), this.getHeight()); + } + // maintenant on dessine ce que l'on veut + secondPinceau.setColor(Color.BLACK); + if (x != null) { + secondPinceau.fillPolygon(x, y, x.length); + } + + } +} \ No newline at end of file diff --git a/APL2.1/TP14/Polygone/Test.class b/APL2.1/TP14/Polygone/Test.class new file mode 100644 index 0000000000000000000000000000000000000000..349a375c88e90c0f7a852f2c160a8e79da663ee3 GIT binary patch literal 661 zcmYjPO>fgc5PcInaX#F}DWsH^Qp#7II8BZm3LFS36s0XvsvzLBiI-?A$F6LLQhotP z{t6dYq7pxV-@_R(n^X$+YIZ&I=DnHm{{H*(7l3DImyv^E!L*S_f#95q&!Q8EaNIc_ zp2|^5C_Gi6N}m%9w=u9#B&=xAmrio781`mA786;91w)&P4I4{@N+Q! zIA{!XylTVIaf{=9^>voGV&evG5=uHpTtrh=-Ee!eQp9=Mnfne!D8@40(?zTjif^Of zVjP9cP}kCRRJ5sTkqsMnu*nq*-zPNxqv}SJGtLRqy~cun;nc}nHtu1Yu*TKAl%K>j zNV`Fl$m25^U$Y0PuwHkq~`P2-W=SDLn@$=Z4-*v4c2ZTiW9hl>JRm%lc7 zC*JeTOVAHK5E^WC7%)*n6CR&6^cxI*f!9~C-e02B^BmvtGnBm={o$2i*`o}#E7UoB z>#$`Q8P-}g`pzrEZLgJK{he3HaMv?4++V1*QJHBLd6o`}SZCcWl(ED9UA`Pou*4T{ Q881-9D@G7njL%{BAEda0d;kCd literal 0 HcmV?d00001 diff --git a/APL2.1/TP14/Polygone/Test.java b/APL2.1/TP14/Polygone/Test.java new file mode 100644 index 0000000..ebfa7f4 --- /dev/null +++ b/APL2.1/TP14/Polygone/Test.java @@ -0,0 +1,17 @@ + +import javax.swing.JFrame; + +public class Test { + public static void main(String[] args) { + JFrame j = new JFrame(); + j.setLocation(100, 100); + j.setSize(500, 500); + j.setLayout(null); + Polygone p = new Polygone(); + p.setLocation(0, 0); + p.setSize(400, 400); + j.add(p); + j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + j.setVisible(true); + } +} diff --git a/APL2.1/TP14/Polygone/polygone.bin b/APL2.1/TP14/Polygone/polygone.bin new file mode 100644 index 0000000000000000000000000000000000000000..329c5a5439b7fa9f756602079796a31d85795871 GIT binary patch literal 320 zcmZvXp$&jQ5CpFhG%cVh0S%fG(3F4%O$lgPKvN8}JpP7%eC)Ahp_7MOqaBv4Ga4ShQA$-75^t&aCr6rA_+c zi%HYRCXGpB-)x&cR9m6Zq(1o8zo}{ayE6kUN}48c_uPBW`Q3BQ@0>G#{{8F^0E1Z0 zpbFI*QaWl-E6}`PE}8wd>CE+Cnq82EK%n-tI*b_@=j=Za?*7sX(4c;tK#W6 zpn-~$#F_4jqeLmgAa?86gS`TEb26At!eb7`)ZKm^?JyWO?lDo3suj#r@&nTe==CNi6Uz#Zws0~zQkg!a<1o4eS~^r7y}%;wdCNCv zZCNB6*EHk=S~v24c1>&8^IR{3ZpD6|K>LQum~G2B)6NHEWB6`CmKA6k{Q{SU+){~T z5#I`oyjhqxjnU8wyyaeFfh9eDX>vf~b zBIE@-;Tn@Qf*i5b1NCwEN0i4T<(%sVe&Ctq2^q}0MZc*Q3mGiJ)=*OQ!?!y&g0q|@ zcTx7oWW-H5Vip3|TNe1XvJex+81#ba6m98ujJxh)Sl(igRD`z4aB8_Mw@|N)ca4$P zA%;xb&Rc=x%q(;4bqV$#YvARN>@&|0-D!AaLl{CpA9Eb(Ma)TGLnzSsTFhI8qTw@v z{r|1X+Kc1H0oG#`CtEdFeg!C1sc8>1x2jphy~eI(&vE^fyJPAT!{4UdDnxG2Q)s!~ zr)YT0BY~S-vq*8>#x;vNw4jlbUZ{Fc0KTNT0vPGZZu=cAS98BX8_cP-X9aDx0_3KF zn|;sd9SHseoe$8urZT_xA?lx_duA0qFVwqL(Yw1*OL-sNZD$w<(1wG^p@VJSiCes> zh4>4@oTBPGkoYo4PXzBG?B<5=(eNC-Gub1nc=LsN?q}Y`=<3S~4!9QdMQF5Zp(#Hb z3DiFRDySOe{4W&ZZ17deN4aula8)ThL@agMm}9{FXPn1?S8Yx(dnRUM8*z*IRPp`r z9O;?b>^rMCF|I@{J3w(liOqG{LCTYn+>m{r@~PAloMk3QS8$P1@4D0%OMSe%#EWFx zLj|?nuxLxgijUB6s)jdhH7ocivf6wiXt?R*F*Cb}B`hP4d$^CU`1=hW;5+`t8J$Hd z;~8erjbJB6$<_t*GfO9N5knkx6P$EcaG9g*3iB{UwClvXNyHoYf_c2h+}y`)A{X&B zB+)J6m-xaW9>T^Wlq04Nq4pmd)o3VaNU#4vXvo)%t}ko@scIx*=y=2rt2mop!N(7v xr5+(w{VO^*$}J`~6FpIbD*X)Gmfom(nZvwdmy$&sH(Kw&=UImPfKl8<+rRgpPx=4= literal 0 HcmV?d00001 diff --git a/DEV 2.2/TP01/MonInt/MonInt.java b/DEV 2.2/TP01/MonInt/MonInt.java new file mode 100644 index 0000000..323aa39 --- /dev/null +++ b/DEV 2.2/TP01/MonInt/MonInt.java @@ -0,0 +1,113 @@ +// notez le s après Object. Permet entre autre de stipuler qu'un objet o n'est pas null avec la méthode Objects.requireNonNull(o, "message d'erreur détaillé"); +import java.util.Objects; + +/* + * Sorte de Int du pauvre à laquelle on ajoute un nom sous forme textuelle. + * + * Classe donnée à titre d'exemple pour illustrer les ingrédients techniques de la prog défensive. + * et les assertions java + */ +public class MonInt { + + // un entier + private int valeur ; + // son nom sous forme textuelle + private String nom ; + + public MonInt(int n, String s){ + this.valeur = n; + this.nom = s; + } + + /** + * division du pauvre. + * + * + * @param c le diviseur par lequel on souhaite diviser this + */ + public void divise (MonInt c){ + Objects.requireNonNull(c, "la classe denominateur ne peut pas être null"); + + int avant = this.valeur; + + this.valeur = this.valeur / c.getValeur(); + this.nom = "(" + this.nom + " divisé par " + c.getNom() +")"; + + assert(this.valeur*c.getValeur() == avant); // NB. un assert qui ne marche pas tout le temps. + } + + /** + * Un getter superstitieux. + * retourne une exception si la valeur vaut 13. + */ + public int getValeur(){ + if (valeur == 13) throw new IllegalStateException("Comme disait Sacha Guitry, je ne suis pas superstitieux mais on ne sait jamais."); + return valeur; + } + + public String getNom(){ + return nom; + } + + /** + * @return String representant l'entier. + */ + public String toString(){ + return this.getValeur() + " " + this.getNom(); + } + + /** + * C'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe. + * C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests + * (vous pouvez rejouer les tests plus tard). + * + * Idéalement on utilise un outil dédié comme JUnit qui favorise au maximum cette automatisation. + * + * @param args pas de paramètre en ligne de commande prévu. + */ + public static void main(String[] args) { + MonInt c3 = new MonInt(3,"trois"); + MonInt c4 = new MonInt(4,"quatre"); + MonInt c9 = new MonInt(9,"neuf"); + MonInt c13 = new MonInt(13,"treize"); + System.out.println(c3.toString()); + System.out.println(c4.toString()); + System.out.println(c9.toString()); + + + c9.divise(c3); + // 3 + System.out.println(c9.toString()); + + c3.divise(c4); + // 0 + System.out.println(c3.toString()); + + // tester des exceptions pas pratique + // Si on veut tester plusieurs exceptions + // il faut attraper et vérifier que c'est le bon type d'exception. + // ici manuellement en regardant le message. + try { + System.out.println(c13.toString()); // toucher au nbre 13 avec getValeur() + } + catch(Exception e){ + System.out.println(e); + } + + try{ + c9.divise(c3); //division par 0 + } + catch(Exception e){ + System.out.println(e); + } + + try{ + c9.divise(null); //division par null + } + catch(Exception e){ + System.out.println(e); + } + + + } +} diff --git a/DEV 2.2/TP01/v0/Carte.class b/DEV 2.2/TP01/v0/Carte.class new file mode 100644 index 0000000000000000000000000000000000000000..c7bc44324a22331b47d263d4b0f25eb7d920e65f GIT binary patch literal 2437 zcmaJ@+jA3D82_C#?WSSd(zFzjO9KK;QXt|LC`d~LT20F(rM1Ni+w_<&-Ry?VrUT=3 zypNYrADj`!2WE5zb$n2i)+sac&^P}m@ppE&HkIg1doJJkzTbEMHh=!L{0D$zsKpUM zlZL2{X0!-wylgBOSnx(3~?|PYSf! zGp-EJVni{u>*&Bn0d2vonll!8#I&L(baW}nmIcF-H8+M$0>>>QSyVvDm77UVRz2w^ zD@L`t@`FrDn@86uuYB*hGHJ_XMbqtR724dJQaO5A0uhjY+JGr2YDmrDF zO50Q3oLNo(r?D~g>PTXzK)fWqiPiWpywe&U5$IhrY{ar;$*>BZ;mMO%i?ZUGjvd1u zfrKCJq^*<(2nXWWg+7(Xl)$EX_g0;m(2x<>^#J^kTdI|%?bT`6C$K%xP#^tu%F^hI zGoe`>kK&*}%yR-g0^O7PJO!?QY0 z;?%lMDO_X8mf0Xqjs3DIs2S7Ao@EVrbYB|ffjEXSqTx9m&#U}&`AJyMLvt%i!m^d_ zQ5|EdBilTuRI+4PChFy^j&nHA=2NA?#)_x%eyRr2(@M*@QgJ~UJ)NH5mUCvw)R8xB zIaVvrNO#=u`>~BxRh%C+D&bvUO<>-!OByb&chT<$qLmHP7U)S`tm}-r`g(<~HF%y)C$M|1W=(s+nU~o> zXHY|@jH2hb*95+tR<_v^NurLt2F5JI(OCyj$fEJ5Lcczx|!_n!5&890s{g@OGTw<9A8<(A=m=dDzKscMECFL znam`%`P(9P+(6r1?3zmKUc%mc{i}rZRHAeW{jxWoV&zRGSy@)~0INfg`>;iB|S;a~{5Cj@QFEaCtIx{SwwpB2CF zPhiI!ZydIv$RKxR$5v&=b#$mmEaNHQ7Mc@>moX3k1QrDVP8fhl*N}#3wBkj)6rhP? zOoB?)cXtt+iZ0=q{B0(L#w_BrA~lmVO47bHlHwX8X@5W>bDa!{>K48!EFRA+qVV8D zAWmQ<5aKHV9?z_XmxAI*w0}#Kw8^zVpGP-sevO{I&fgVpU>n}VUc7}Y-o|0P!(TY> zGGFg;BEHY;f54P{h*^9D8z18;KB3g7q<)6$_#EHh3w(<&{SajlxsR_9)$lS?75u5x p4XYHcr!tqroc)AW**7r5y_@$U18e&0yuX&=@Fh-a1ui^n`5QNeL`?ty literal 0 HcmV?d00001 diff --git a/DEV 2.2/TP01/v0/Carte.java b/DEV 2.2/TP01/v0/Carte.java new file mode 100644 index 0000000..860678c --- /dev/null +++ b/DEV 2.2/TP01/v0/Carte.java @@ -0,0 +1,148 @@ +import java.util.Objects; + +// Copyright Florent Madelaine, (3 juin 2020) + +// florent.madelaine@u-pec.fr + +// Ce logiciel est un programme informatique simulant une petite partie du jeu de Memory + +// Ce logiciel est régi par la licence CeCILL soumise au droit français et +// respectant les principes de diffusion des logiciels libres. Vous pouvez +// utiliser, modifier et/ou redistribuer ce programme sous les conditions +// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA +// sur le site "http://www.cecill.info". + +// En contrepartie de l'accessibilité au code source et des droits de copie, +// de modification et de redistribution accordés par cette licence, il n'est +// offert aux utilisateurs qu'une garantie limitée. Pour les mêmes raisons, +// seule une responsabilité restreinte pèse sur l'auteur du programme, le +// titulaire des droits patrimoniaux et les concédants successifs. + +// A cet égard l'attention de l'utilisateur est attirée sur les risques +// associés au chargement, à l'utilisation, à la modification et/ou au +// développement et à la reproduction du logiciel par l'utilisateur étant +// donné sa spécificité de logiciel libre, qui peut le rendre complexe à +// manipuler et qui le réserve donc à des développeurs et des professionnels +// avertis possédant des connaissances informatiques approfondies. Les +// utilisateurs sont donc invités à charger et tester l'adéquation du +// logiciel à leurs besoins dans des conditions permettant d'assurer la +// sécurité de leurs systèmes et ou de leurs données et, plus généralement, +// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. + +// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez +// pris connaissance de la licence CeCILL, et que vous en avez accepté les +// termes. + +/** + * Classe représentant une carte de Memory + */ +public class Carte { + + /** + * Permet de savoir combien on a de cartes en tout. + * Pas vraiment clair qu'on veuille s'en servir ici. + * C'est purement pour des raisons pédagogiques de rappel de ce que veut dire un attribut de classe. + * + * Je ne rentre pas dans les détails de la destruction d'objets. + * Il faut lire la doc à propos de Objects.finalize() + */ + static int nbreCarte; + + /** + * False ssi caché + */ + private boolean visible; + + /** + * pour pouvoir apparier des cartes. + */ + private int valeur; + + /** Constructeur de carte. + */ + public Carte(int valeur){ + Carte.nbreCarte++; + this.visible=false; // caché par défaut + this.valeur=valeur; + } + + // NB. Moralement, les cartes ne devraient pas être cachées. + // dans cette version on ne fait rien mais on voudrait idéalement que ce ne soit pas possible + /** + * Prédicat permettant de tester le fait que deux cartes ont la même valeur + * @param Carte la carte à comparer à this. + * @return true si elles ont la même valeur. + * @throws NullPointerException si la carte passée en paramètre ou this est null. + * @throws IllegalArgumentException si l'argument n'est pas visible + * @throws IllegalStateExeption si this n'est pas visible + */ + public boolean egale(Carte c){ + Objects.requireNonNull(c, "la carte à tester passée en paramètre ne peut pas être null"); + Objects.requireNonNull(this, "la carte qu'on veut comparer (this) ne peut pas être null"); + + if (!this.getVisible()) throw new IllegalStateException("Carte non visible."); + if (!c.getVisible()) throw new IllegalArgumentException("Carte paramètre non visible."); + return c.valeur == this.valeur; + } + + public boolean getVisible(){ + return visible; + } + + /** + * Méthode inversant la visibilité d'une carte. + */ + public void toggleVisible(){ + this.visible = ! this.visible; + } + + /** + * @return String representant la carte (version longue) + * @see toString + */ + public String toStringLong(){ + return this.toString() + " parmi " + Carte.nbreCarte; + } + + /** + * @return String representant la carte. + */ + public String toString(){ + return "une carte " + (this.visible ? "visible" + " de valeur " + this.valeur: "cachée"); + } + + /** + * C'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe. + * C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests + * (vous pouvez rejouer les tests plus tard). + * + * Idéalement on utilise un outil dédié comme JUnit qui favorise au maximum cette automatisation. + * @param args pas de paramètre en ligne de commande prévu. + */ + public static void main(String[] args) { + Carte un = new Carte(1); + System.out.println(un.toString()); + Carte deux = new Carte (2); + System.out.println(deux.toString()); + Carte unBis = new Carte(1); + System.out.println(unBis.toString()); + + un.toggleVisible(); + System.out.println(un.toString()); + unBis.toggleVisible(); + System.out.println(unBis.toString()); + System.out.println(un.egale(unBis)); + unBis.toggleVisible();//true + System.out.println(unBis.toString()); + + System.out.println(un.toString()); + deux.toggleVisible(); + System.out.println(deux.toString()); + System.out.println(!un.egale(deux));//not false + + Carte bad = null; + un.egale(bad); + } +} + + diff --git a/DEV 2.2/TP01/v0/EnsembleCarte.class b/DEV 2.2/TP01/v0/EnsembleCarte.class new file mode 100644 index 0000000000000000000000000000000000000000..85bf583f0601584a44b76007252e3992dd291cd2 GIT binary patch literal 1829 zcma)6ZBrXn6n<_J*sxtnOL?&`Vv0~hfJUv_mr#mCkhFoSL6BB$FUc)zS#~qK8^-$0 ze<8o1U;Lmm6-GMa_}M?<|IqQ}xtoQCmO7oxoSbv+Ip;ZVdw&0C?^ghqQ8UqxaRV1k zBrx8AKIAodTZ`{#@~$SAOzPe<@V*v4=%(j26DA5;oH&LYu4^)B;D(8lnCgbWv^FSe zGG*W+12Y0f)pJATHUv(WAIdG6Z-lm!FWc^hs?Et@y`sW`Ku5)1b7k1@mB8T3>?X=Z z>4&N?sU6%^UqzyTC<(Mr*sdK;3M8{5O9H8)S7WFy;;4nj=Bn}+<*GwXQr2n$W;PBr za)++I+Vr;gmJWUC1`m`kkja*3+(2#8r->Qcx43myLRsCIm-RSuI`k@`Z@X&(J=u|F z4UTlz@=a~Qz$}3)Uc;}dSzG7QeF);B?v8~4ydlv4l1^E84W})f!|N6X@v(&=P3ANi z#GCtmEvVBC+o>tvLJ2noPE31V7_iFvyb9O7TF}*wTWORn%ws`A-?s1xKDF=}Di#*; zxj=``DIl{iZ`cPFv7Wk};QmA|xdTecPwxu^s%Yq(5 zS}%&U-GI{z>~Hm~vLhuEcW_tWY^J6%e03a^5o4L=PDwY+T+5g&dsA+xqUTm+xNL{( zoQnS->^O=$i!1_Bpe=kTo@ae zxt9^l@j`3a`-m-_h*exiS+6UXOFI5a9`S^^USI0z+!q*nHVE6@@-|ewfz1ZZ$|}e3 z$iOP0%AU8;s0&yn*HwPekwKu?weMSz;~342nUikKQNd8tvG8L4Et*4)i;wE+2=luw z_WQfgqKZQlrQ=jM85UU;7=EF?qjD1%_5GY*qym;^0O z contenu = new LinkedHashSet(); + + /** + * nbre de Cartes de l'ensemble. + * + */ + private int nbreCarte; + + /** + * Constructeur d'Ensemble vide. + */ + public EnsembleCarte(){ + this.nbreCarte=0; + } + + /** + * Ajoute une carte à l'ensemble. + * @param c une carte + * @return true si la carte est ajoutée à l'ensemble + * @throws NullPointerException si la carte est null + * @throws IllegalStateException si la carte ne peut pas être ajoutée car elle est déjà présente dans l'ensemble + */ + protected boolean add(Carte c){ + this.nbreCarte++; + return contenu.add(c); + } + + /** + * Enlève une carte à l'ensemble. + * @param c une carte + * @return true si la carte est retirée à l'ensemble + * @throws NullPointerException si la carte est null + * @throws IllegalStateException si la carte ne peut pas être enlevéé car elle n'est pas présente dans l'ensemble + */ + private boolean remove(Carte c){ + this.nbreCarte++; + return contenu.remove(c); + } + + /** + * Permet de transférer une paire de carte (par exemple depuis la table vers un joueur) + * Si ces cartes sont toutes les deux visibles + * @param target destination du transfert + * @param c1 première carte + * @param c2 seconde carte + * @return true en cas de succès, false sinon + * @throws NullPointerException si un élément passé en paramètre est null. + * @throws IllegalArgumentException si les cartes ne sont pas toutes les deux visibles + * @throws IllegalStateException si this ne contient pas les deux cartes. + */ + public boolean transfer(EnsembleCarte target, Carte c1, Carte c2){ + return this.contenu.contains(c1) && this.contenu.remove(c1) && target.add(c1) && this.contenu.contains(c2) && this.contenu.remove(c2) && target.add(c2); + } + + + public String toString(){ + // Stringbuilder is the most efficient method of building a String like datastructure incrementally. + StringBuilder sb = new StringBuilder(" de taille " + this.contenu.size() + ", contenant : \n"); + for (Carte c : this.contenu){ + sb.append(" _ " + c.toString() +"\n"); + } + return sb.toString(); + } + + + // tests obsolètes [serait OK si classe n'était pas abstraite] + + // public static void main(String[] args) { + + // Carte un = new Carte(1); + // Carte deux = new Carte (2); + // deux.toggleVisible(); + // Carte unBis = new Carte(1); + + // Carte deuxBis = new Carte(2); + + // EnsembleCarte e1 = new EnsembleCarte(); + // System.out.println(e1.add(un) && e1.add(deux)); + // System.out.println(e1.toString()); + + // EnsembleCarte e2 = new EnsembleCarte(); + // System.out.println(e2.add(un) && e2.add(unBis)); + // System.out.println(e2.toString()); + + // e1.transfer(e2,un,deuxBis); + // System.out.println(e1.toString()); + // System.out.println(e2.toString()); + + // } +} + + diff --git a/DEV 2.2/TP01/v0/Joueur.class b/DEV 2.2/TP01/v0/Joueur.class new file mode 100644 index 0000000000000000000000000000000000000000..a6d492d4c81562908ff2f5d3d4b4de0141aef36f GIT binary patch literal 1481 zcmaJ>OH&g;5dJ2w-7Kph_=*pVin<9ZzD0sBq7gKJ5(H7JtbvTUlI&2s6D%&?ym{A~ zH@&K*P$gCV0DqKaPc}j@l!u-Erl-H2p08*2*Y6)c0bEAOLKo6W#Bo@oBc0?uZs3Fo z$0BFOMAk&Ffs+<2oHB6Qf{nBu`jR+Awn83L$uJAUPAAh!CTf+t z9>Z?uN$aXkZIxurpA!XFr)#?_Yog|#)-~GLjmtK6Vwa75*w4^0B&7ijouLx>5I4!B8w$RR>`bfW-=9`!j4V~}2O0Y!{s6w?^PGeYyY4~Yr9LJ6<&5N|Mr pw|Inic#IEtf{%Dg(sonM2o4d4=-yobJHe*kMETuuN0 literal 0 HcmV?d00001 diff --git a/DEV 2.2/TP01/v0/Joueur.java b/DEV 2.2/TP01/v0/Joueur.java new file mode 100644 index 0000000..daa64e1 --- /dev/null +++ b/DEV 2.2/TP01/v0/Joueur.java @@ -0,0 +1,96 @@ +import java.util.Objects; + +// Copyright Florent Madelaine, (3 juin 2020) + +// florent.madelaine@u-pec.fr + +// Ce logiciel est un programme informatique simulant une petite partie du jeu de Memory + +// Ce logiciel est régi par la licence CeCILL soumise au droit français et +// respectant les principes de diffusion des logiciels libres. Vous pouvez +// utiliser, modifier et/ou redistribuer ce programme sous les conditions +// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA +// sur le site "http://www.cecill.info". + +// En contrepartie de l'accessibilité au code source et des droits de copie, +// de modification et de redistribution accordés par cette licence, il n'est +// offert aux utilisateurs qu'une garantie limitée. Pour les mêmes raisons, +// seule une responsabilité restreinte pèse sur l'auteur du programme, le +// titulaire des droits patrimoniaux et les concédants successifs. + +// A cet égard l'attention de l'utilisateur est attirée sur les risques +// associés au chargement, à l'utilisation, à la modification et/ou au +// développement et à la reproduction du logiciel par l'utilisateur étant +// donné sa spécificité de logiciel libre, qui peut le rendre complexe à +// manipuler et qui le réserve donc à des développeurs et des professionnels +// avertis possédant des connaissances informatiques approfondies. Les +// utilisateurs sont donc invités à charger et tester l'adéquation du +// logiciel à leurs besoins dans des conditions permettant d'assurer la +// sécurité de leurs systèmes et ou de leurs données et, plus généralement, +// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. + +// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez +// pris connaissance de la licence CeCILL, et que vous en avez accepté les +// termes. + +/** + * Classe servant à représenter le joueur dans le modèle. + * Pour l'instant juste un nom et un ensemble de cartes + */ +public class Joueur extends EnsembleCarte { + /** + * Nom du joueur + */ + private String nom; + + /** + * Constructeur + * @param nom Futur nom du joueur, ne doit pas être null + * @throws nullPointerException si nom est null. + */ + public Joueur(String nom){ + Objects.requireNonNull(nom); + this.nom=nom; + } + + public String toString(){ + return "Joueur " + this.nom + " " + super.toString(); + } + + + public static void main(String[] args) { + // c'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe. + // C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests (vous pouvez rejouer les tests plus tard). + + // Les Joueurs + Joueur toto = new Joueur("Toto"); + //Joueur titi = new Joueur("Titi"); + //Joueur tata = new Joueur("Tata"); + + // Les cartes + Carte un = new Carte(1); + Carte deux = new Carte (2); + Carte unBis = new Carte(1); + Carte deuxBis = new Carte(2); + + // la Table + Table t = new Table(); + t.add(un); + t.add(deux); + t.add(unBis); + t.add(deuxBis); + + System.out.println(t); + System.out.println(toto); + + t.reveler(un); + t.reveler(unBis); + + t.transfer(toto,un,unBis); + + System.out.println(t); + System.out.println(toto); + } +} + + diff --git a/DEV 2.2/TP01/v0/Table.class b/DEV 2.2/TP01/v0/Table.class new file mode 100644 index 0000000000000000000000000000000000000000..730e4cdbcee1bfd138fef8033c4befca0986c63a GIT binary patch literal 1360 zcma)5YflqF6g>moZdn(o^0Gd73E1)~sED@sqCzATG=V^n4`yh`cIkGv?hcLo6Muvs z)EJsT;t%jg8SnHF3MIx5J9FpEnLFp6o%{RG=`R3_STWFrK{X5+2x3@8BR6PkT*rh$ z?(2ve2q{hoLmh}=(!dm^)pAD1EJJX~axD3rp*;_1d(WVIqAYCTHN%u5nBkecLPOHslAh({7#kB`Y`I5XMyy&&fl*a5tJ0Y0M%Y9TdQHStbQ2MV@UrVlUwXW>A!Odo z`rSdyg)nd80Uk1FRpsjFBU)6G=~yuF7>hcdn0ShWi9Yl*bgnqQC{o$g6SS6YE@z7! z%eM$Lki-&IU(GPg7zT>GAX2WA;d0lKd5V0=9qBVnM6al;6(S>|YpULGlSjwC6h-pg zJ(3K4wL_L0e@BK&GEnd$8Q4=ja1kbHB}KBy*}i50Zx0SdMkZrBI-V&{UNMZFUuZdH zw;<~OrdG`=&q&uh){&yWns(j7QHjA^a~$ENZ0`GlO8nA%Lp?{${x{so+QJ{J9Za^C z-Gp2?xP4p_SJ0c^NTZb26e(`oTNb@g9j_V2Tk5+?8^hqgc^IL7>7u>@^%Qjn!Zco| z)d5Aa6gCq8!Fiz$|Pmpok?nNWsNAK4A+!_8{>AWnz6M&38z18}5>~>aQ?7 S$1+}!3!}6S(fS^JV}AkfgeX%0 literal 0 HcmV?d00001 diff --git a/DEV 2.2/TP01/v0/Table.java b/DEV 2.2/TP01/v0/Table.java new file mode 100644 index 0000000..de178c4 --- /dev/null +++ b/DEV 2.2/TP01/v0/Table.java @@ -0,0 +1,126 @@ +import java.util.LinkedHashSet; +import java.util.Objects; + +// Copyright Florent Madelaine, (3 juin 2020) + +// florent.madelaine@u-pec.fr + +// Ce logiciel est un programme informatique simulant une petite partie du jeu de Memory + +// Ce logiciel est régi par la licence CeCILL soumise au droit français et +// respectant les principes de diffusion des logiciels libres. Vous pouvez +// utiliser, modifier et/ou redistribuer ce programme sous les conditions +// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA +// sur le site "http://www.cecill.info". + +// En contrepartie de l'accessibilité au code source et des droits de copie, +// de modification et de redistribution accordés par cette licence, il n'est +// offert aux utilisateurs qu'une garantie limitée. Pour les mêmes raisons, +// seule une responsabilité restreinte pèse sur l'auteur du programme, le +// titulaire des droits patrimoniaux et les concédants successifs. + +// A cet égard l'attention de l'utilisateur est attirée sur les risques +// associés au chargement, à l'utilisation, à la modification et/ou au +// développement et à la reproduction du logiciel par l'utilisateur étant +// donné sa spécificité de logiciel libre, qui peut le rendre complexe à +// manipuler et qui le réserve donc à des développeurs et des professionnels +// avertis possédant des connaissances informatiques approfondies. Les +// utilisateurs sont donc invités à charger et tester l'adéquation du +// logiciel à leurs besoins dans des conditions permettant d'assurer la +// sécurité de leurs systèmes et ou de leurs données et, plus généralement, +// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. + +// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez +// pris connaissance de la licence CeCILL, et que vous en avez accepté les +// termes. + + + +/** + * Classe gérant la table de jeu du Memory dans le modèle + * Pour l'instant ne gère pas le tour des joueurs. + * Devrait probablement le faire un jour. + */ +public class Table extends EnsembleCarte { + + /** + * Constructeur de Table vide (seul constructeur pour l'instant) + */ + public Table(){ + } + + /** + * Nécessaire de la rendre publique car on a un parti pris que on commence avec une table vide à laquelle on ajoute des cartes. + * On pourrait alternativement faire un constructeur qui fabrique les cartes ou bien qui prend une collection de cartes. + * Ça n'aurait pas la vertu pédagogique de montrer qu'on peut surcharger une méthode en élevant les droits en java. + * + * Par délégation mais en rendant publique la méthode (pour l'initialisation en fait). + * @param c Carte à ajouter + * @return true si la carte est ajoutée à l'ensemble + * @throws NullPointerException si la carte est null + * @throws IllegalStateException si la carte ne peut pas être ajoutée car elle est déjà présente dans l'ensemble + */ + @Override + public boolean add(Carte c){ + return super.add(c); + } + + /** + * révèle une carte. + * @param c une carte à révèler + * @throws NullPointerException si la carte est null + * @throws IllegalArgumentException si la carte n'est pas sur la table + * @throws IllegalStateException si la carte est déjà révélée + */ + public void reveler(Carte c){ + Objects.requireNonNull(c); + c.toggleVisible(); + } + + /** + * cache une carte. + * @param c une carte à cacher + * @throws NullPointerException si la carte est null + * @throws IllegalArgumentException si la carte n'est pas sur la table + * @throws IllegalStateException si la carte est déjà cachée + */ + public void cacher(Carte c){ + Objects.requireNonNull(c); + c.toggleVisible(); + } + + + public String toString(){ + return "Table " + super.toString(); + } + + + public static void main(String[] args) { + // c'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe. + // C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests (vous pouvez rejouer les tests plus tard). + + // Les cartes + Carte un = new Carte(1); + Carte deux = new Carte (2); + Carte unBis = new Carte(1); + Carte deuxBis = new Carte(2); + + + // la Table + Table t = new Table(); + t.add(un); + t.add(deux); + t.add(unBis); + t.add(deuxBis); + + System.out.println(t); + + t.reveler(un); + t.reveler(unBis); + + System.out.println(t); + + } +} + + diff --git a/DEV 2.2/TP01/v0/TestCarte.class b/DEV 2.2/TP01/v0/TestCarte.class new file mode 100644 index 0000000000000000000000000000000000000000..83d38b50435ab6227f37011412f7f9a70568b601 GIT binary patch literal 1476 zcma)+Yf}4f^5IHD@N{X3+S|BP-2S4PYaU3WLm4dO!Z!5k->nyvrhsM9vmvm~T zAJC6#y5B_?#Ij&`&(D25r{U+XZ$AKR;!zX>2!s)gBZNT(qbKTTwWzB`tGIu3BASkZ z!41vOoGk@`T>c=8AqAlw)pA4>VML`_OhGVL$sfpr;W$R5&ah*)TDmyUZ0$(*o{q+G z2T2->mZ}Q{(OlJ&S0h<$paiY+xzws_yMh*s&b4}^W=~bS0uU6)!R-Gvly+R2|kSW?#br~FUr@Hj%+EKL5 zkei~c$)b$-m0Oh|BZGTvQ2B{~y@NrH_qm(ltZ)u3okRJ;g@Rd*^1AbMj_U#M>2m}; ziPU$5KLpPasTRH>Uf__pz*yHdi6Cu92ufg>y*hy;@g2=9X9e@V<~}t8Je$9!d9~SH zmH-ad0co0pEgr!n0aHjJ&F?g_jPW{X;XgnjM$!wK>PFH5%@LF#C`-^hK?__h_JJ0C z(As50Nu}BiL+0pxSGSX)C1$gL7?zo%6;Ch5++_KC(8NPdIbXDNDLQi{>7`z7Jny{} z_2{QqVBj(RenP*W((h+X&00SrPsY+M3}4?b!wtqd85^wcCK+2~yy#~X$XNCne=qkx xt57ECC8K#oQiWA`%}l-NtHKIFowm+!_S!mlfu4fOKWU)G27SxxRjvn6{0*YG7nuM6 literal 0 HcmV?d00001 diff --git a/DEV 2.2/TP01/v0/TestCarte.java b/DEV 2.2/TP01/v0/TestCarte.java new file mode 100644 index 0000000..a7dd593 --- /dev/null +++ b/DEV 2.2/TP01/v0/TestCarte.java @@ -0,0 +1,84 @@ +import static org.junit.Assert.assertTrue; // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe) +import static org.junit.Assert.assertFalse; // +import org.junit.Test; + + +/** + * Une classe pour faire des tests sur la classe Carte avec JUnit + */ +public class TestCarte { + + // un test pour Junit4 c'est une méthode avec l'annotation @Test devant une méthode avec un type de retour void. + @Test + public void egaleSiIdentiquesEtVisible() { + Carte un = new Carte(1); + un.toggleVisible(); + // on peut stipuler que des choses sont normalement égales (il faut charger de manière statique les Assert si on veut éviter d'avoir à écrire de quelle classe on parle) + assertTrue(un.egale(un)); + } + + // le nom du test doit être le plus explicite possible + @Test + public void egalSiMemeValeurEtVisible() { + Carte un = new Carte(1); + un.toggleVisible(); + Carte unBis = new Carte(1); + unBis.toggleVisible(); + assertTrue(un.egale(unBis)); + } + + @Test + public void pasEgalSiPasMemeValeurEtVisible() { + Carte un = new Carte(1); + un.toggleVisible(); + Carte deux = new Carte(2); + deux.toggleVisible(); + assertFalse(un.egale(deux)); + } + + // un test pour Junit4 qui cherche à vérifier qu'il y a bien une exception + @Test(expected = NullPointerException.class) + public void egalPasFaitPourNull(){ + Carte bad = null; + Carte un = new Carte(1); + un.egale(bad); + } + + // un autre test pour Junit4 qui cherche à vérifier qu'il y a bien une exception + @Test(expected = IllegalArgumentException.class) + public void egalPasFaitPourParametreNonVisible(){ + Carte un = new Carte(1); + un.toggleVisible(); + Carte deux = new Carte(2); + un.egale(deux); + } + + // un autre test pour Junit4 qui cherche à vérifier qu'il y a bien une exception + @Test(expected = IllegalStateException.class) + public void egalPasFaitPourCarteThisNonVisible(){ + Carte un = new Carte(1); + Carte deux = new Carte(2); + deux.toggleVisible(); + un.egale(deux); + } + + //Le monde est mal fait et parfois c'est le test qui est faux. + //Notez que je suis vraiment méchant car ce test est satisfait au début avec le code proposé... + //Moralité : faites des tests très simples et faites vous relire! + @Test + public void egalTestMalFait(){ + Carte un = new Carte(1); + un.toggleVisible(); + Carte deux = new Carte(2); + deux.toggleVisible(); + assertFalse(un.egale(deux)); + } + + // si on ne met pas l'annotation arobase test, le test n'est jamais pris en compte. + // c'est juste une méthode annexe qui n'est pas appellée comme dans n'importe quelle classe. + public void autreTestMalFait(){ + assertFalse(true); + } + + +} diff --git a/DEV 2.2/TP01/v0/TestEnsemble.java b/DEV 2.2/TP01/v0/TestEnsemble.java new file mode 100644 index 0000000..e69de29