Skip to content

TDm1

Révisions générales

  • Faire un programme en Java qui affiche "bonjour !"

Utilisation sous Linux de gedit pour créer le fichier source .java et les commandes javac pour compiler et java pour exécuter.

  • Faire une classe Robot avec

    • un champs posX
    • un champs posY
    • un ou des champs pour modéliser la direction (angle)
    • des accesseurs
      • public double getPosX();
      • public double getPosY();
      • public double getAngle();
    • un constructeur naturel
    • des méthodes avance()/recule() (surcharge)
    • redéfinir la méthode toString()

  • En utilisant l'héritage, proposer une classe JumpingRobot qui représente des robots pouvant reculer, avancer et sauter.

  • Ajouter une méthode robotCount() qui renvoie le nombre de Robot existant. Comment faire ? Que veut dire le mot clef static appliqué à un champs en java ?

Validation

Téléchargez les quatres fichiers :

  • RobotInterface.java 
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
    public interface RobotInterface {


    public double getPosX();
    public double getPosy();

    /**
     * 
     * @return the angle in degree (!!) 0 means Robot is facing UP
     */
    public double getAngle();


    public void move(final double distance);

    /**
     * 
     * @param angle the angle in degree, positive angle is a left rotation
     */
    public void rotate(final double angle);

}
  • DrawRobots.java 
      1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
    import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Polygon;
import java.awt.Stroke;
import java.awt.Toolkit;
import java.awt.geom.AffineTransform;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;



public class DrawRobots {

    private final List<RobotInterface> robots;
    private final JFrame frame;

    private static final int offset = 30;
    private static final int robotWidth = 75;
    private static final int robotHeight = 75;

    public DrawRobots() {

        robots = new ArrayList<RobotInterface>();
        frame = new JFrame("EIG-2221 Robot Display");

        final Image nxt = Toolkit.getDefaultToolkit().createImage("nxt.png");
        final Image nxtScaled = nxt.getScaledInstance(robotWidth,robotHeight,Image.SCALE_DEFAULT);

        JPanel panel = new JPanel() {
            @Override
            public void paintComponent(Graphics g) {
                super.paintComponent(g);

                Graphics2D g2d = (Graphics2D) g;


                g2d.setColor(Color.BLACK);
                Stroke stroke = new BasicStroke(1);
                g2d.setStroke(stroke);

                g2d.drawLine(offset, offset, frame.getWidth()-offset, offset);

                Arrow a_axis = new Arrow(5);
                a_axis.drawArrowHead(g2d, frame.getWidth()-offset, offset, frame.getWidth()-offset+5, offset);

                g2d.drawLine(offset, offset, offset, getHeight()-offset);
                a_axis.drawArrowHead(g2d, offset, getHeight()-offset, offset, getHeight()-offset+5);    

                g2d.setColor(Color.RED);

                for(RobotInterface r : robots) {

                    AffineTransform at = new AffineTransform();

                     // 4. translate it to the center of the component
                     at.translate(r.getPosX()+offset, r.getPosy()+offset);
                     // 3. do the actual rotation
                     at.rotate(Math.toRadians(-r.getAngle()+90));
                     // 2. scale the image
                     //at.scale(0.5, 0.5);
                     // 1. translate the object to rotate around the center
                     at.translate(-nxtScaled.getWidth(this) / 2, -nxtScaled.getHeight(this) / 2);


                    g2d.drawImage(nxtScaled,at, this);          
                }


            }   
        };
        panel.setPreferredSize(new Dimension(600,600));
        frame.setContentPane(panel);
        frame.pack();

    }




    public void sleep(final int millis) {

        try {
            SwingUtilities.invokeAndWait(new Runnable() {

                @Override
                public void run() {
                    try {
                        Thread.sleep(millis);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        } catch (InvocationTargetException e) {

            e.printStackTrace();
        } catch (InterruptedException e) {

            e.printStackTrace();
        }
    }

    public void show() {    
        frame.setVisible(true);
    }
    public void hide() {    
        frame.setVisible(false);
        frame.dispose();
    }

    public void refresh() {
        frame.repaint();
    }

    public void addRobot(final Robot r){
        robots.add(r);
        refresh();
    }

    public void removeRobot(final Robot r) {
        robots.remove(r);
        refresh();
    }


    static class Arrow
    {
        private final Polygon arrowHead = new Polygon ();

        /**
         * Create an arrow.
         *
         * @see https://stackoverflow.com/questions/2027613/how-to-draw-a-directed-arrow-line-in-java
         *
         * @param size Size of the arrow to draw.
         */
        public Arrow (int size)
        {
            // create a triangle centered on (0,0) and pointing right
            arrowHead.addPoint (size, 0);
            arrowHead.addPoint (-size, -size);
            arrowHead.addPoint (-size, size);
            //arrowHead.addPoint (0, 0); // Another style
        }

        /**
         * Draw the arrow at the end of a line segment. Drawing the line segment must be done by the caller, using whatever
         * stroke and color is required.
         */
        public void drawArrowHead (Graphics2D g, double x0, double y0, double x1, double y1)
        {
            final AffineTransform tx = AffineTransform.getTranslateInstance (x1, y1);
            tx.rotate (Math.atan2 (y1 - y0, x1 - x0));
            g.fill (tx.createTransformedShape (arrowHead));
        }
    }



}
  • Test.java 
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
    import javax.swing.SwingUtilities;

public class Test {



    public static void moveSlowly(final double distance, final Robot r, final int speed) {

        int dir = distance>0?1:-1;
        for(int i=0; i< Math.abs(distance) ; i++){
            r.move(dir);        
            dr.refresh();
            dr.sleep(10000/speed);      
        }


    }

    public static void rotateSlowly(final double angle, final Robot r, final int speed){

        int dir=angle>0?1:-1;

        for(int i = 0; i<Math.abs(angle%360);i++) {
            r.rotate(dir);
            dr.refresh();
            dr.sleep(10000/speed);
        }       
    }

    private static  DrawRobots dr = new DrawRobots(); 

    public static void main(String[] args)  {

                dr.show();
                Robot r = new Robot(0,0,0);
                dr.addRobot(r);

                moveSlowly(100, r, 1000);

                dr.sleep(1000);             
                rotateSlowly(-90,r,1000);


                dr.sleep(1000);
                moveSlowly(100, r, 1000);


                dr.sleep(1000);             
                rotateSlowly(45,r,1000);

                dr.sleep(1000);
                moveSlowly(100,r,1000);


                dr.sleep(1000);
                moveSlowly(-100,r,1000);

                dr.sleep(1000);
                dr.hide();


    }
}

  • nxt.png

Modifiez votre classe Robot pour qu'elle implémente l'interface RobotInterface. Compilez le fichier Test.java, il devrait vous permettre d'afficher une fenêtre graphique et de voir un robot se déplacer. Vous pouvez modifier la classe Test comme bon vous semble.

La multiprogrammation

  • On veut réaliser un programme qui demande un mot de passe à l'utilisateur, mais qui termine au bout de de 10 secondes si le mot de passe n'est pas saisi correctement. Ecouter les explications !
  • On veut réaliser un programme qui affiche un message toutes les 3 secondes. La solution que vous avez proposée fonctionne t elle si il y a plusieurs taches de différentes périodes ? Comment mettre une échéance ? Comment réagir en cas de dépassement ?