0. Objectius.

En aquesta unitat feim una passa endavant i ens disposam a:

      • Entendre la implementació d’una Canvas.
      • Entendre mètodes que donaran moviment a objectes.
  • Modificar els mètodes.

Primer estudiarem les propietats del projecte i després hi afegirem opcions de execució de botons i la creació de finestres més complexes que permetin cridar.

1. Investigar el projecte.

Per realitzar les pràctiques d’investigació emprarem el projecte BouncingBalls del llibre Programación Orientacda a Objectos con Java usando BlueJ. El projecte s’ha de descarregar d’aquí i l’hem d’importar al Netbeans amb l’opció de import project from ZIP.

Quan volem utilitzar un projecte la primera passa és descomposar en les peces que el formen (les classes) i investigar quina estructura agafen dins el conjunt del projecte.

 

2. Estudi de Classes.

  • Les classes són encapsulacions de les característiques que podrem utilitzar d’un objecte creat de la seva instància.
  • Per tant hem de saber quins estats i mètodes que implementen. A partir d’aquí tendrem una idea de què fa cada classe.
  • Els Javadocs són la documentació d’un codi. Aquí teniu el javadoc de BouncingBallsdemo. Per exemple per saber quina funció té la classe Canvas, classe, constructors i mètodes:
  • La Classe:
    • Tipus d’objecte: “java.lang.Object”.
    • Descripció: “Class Canvas – a class to allow for simple graphical drawing on a canvas.”.
    • Versió: 2016.02.29
    • Autor:Michael Kölling (mik), Bruce Quig.
  • Els Constructors.
    Constructors
    Constructor and Description
    Canvas(java.lang.String title)

    Create a Canvas with default height, width and background color (300, 300, white).
    Canvas(java.lang.String title, int width, int height)

    Create a Canvas with default background color (white).
    Canvas(java.lang.String title, int width, int height, java.awt.Color bgColor)

    Create a Canvas.
  • Mètodes que implementa.
    void draw(java.awt.Shape shape)

    Draw the outline of a given shape onto the canvas.
    boolean drawImage(java.awt.Image image, int x, int y)

    Draws an image onto the canvas.
    void drawLine(int x1, int y1, int x2, int y2)

    Draws a line on the Canvas.
    void drawString(java.lang.String text, int x, int y)

    Draws a String on the Canvas.
    void erase()

    Erase the whole canvas.
    void erase(java.awt.Shape shape)

    Erase a given shape’s interior on the screen.
    void eraseCircle(int xPos, int yPos, int diameter)

    Erase the internal dimensions of the given circle.
    void eraseOutline(java.awt.Shape shape)

    Erases a given shape’s outline on the screen.
    void eraseRectangle(int xPos, int yPos, int width, int height)

    Erase the internal dimensions of the given rectangle.
    void eraseString(java.lang.String text, int x, int y)

    Erases a String on the Canvas.
    void fill(java.awt.Shape shape)

    Fill the internal dimensions of a given shape with the current foreground color of the canvas.
    void fillCircle(int xPos, int yPos, int diameter)

    Fill the internal dimensions of the given circle with the current foreground color of the canvas.
    void fillRectangle(int xPos, int yPos, int width, int height)

    Fill the internal dimensions of the given rectangle with the current foreground color of the canvas.
    java.awt.Color getBackgroundColor()

    Returns the current color of the background
    java.awt.Font getFont()

    Returns the current font of the canvas.
    java.awt.Color getForegroundColor()

    Returns the current color of the foreground.
    java.awt.Dimension getSize()

    Returns the size of the canvas.
    boolean isVisible()

    Provide information on visibility of the Canvas.
    void setBackgroundColor(java.awt.Color newColor)

    Sets the background color of the Canvas.
    void setFont(java.awt.Font newFont)

    changes the current Font used on the Canvas
    void setForegroundColor(java.awt.Color newColor)

    Sets the foreground color of the Canvas.
    void setSize(int width, int height)

    Sets the size of the canvas.
    void setVisible(boolean visible)

    Set the canvas visibility and brings canvas to the front of screen when made visible.
    void wait(int milliseconds)

    Waits for a specified number of milliseconds before finishing.

Exercicis:

  • Exercici 12.1:
    • Amb la informació que tenim cerca dins el codi java de la classe per trobar de quina manera es comenten els codis per poder integrar-se dins un javadoc.
  • Exercici 12.2: 
    • Instal·lar el creador de javadoc al Netbeans, el “Javadoc API documentation” s’instal·la desde Tools->pluguins i fent una cerca de javadoc.
  • Exercici 12.3:
    • Afegeix al paquet balldemo la classe Punt. Comenta la classe Punt i genera el javadoc de les Classes. Observa com ha generat el javadoc. Puja aquest javadoc a la teva carpeta compartida amb el nom de javadocPunt.zip.
  • Exercici 12.4:
    • Creació de un UML (United Modeling Language). Un UML ens permet veure totes les classes del projecte, té una funcionalitat de mostrar classes dins un mateix diagrama. (si no tens el pluguin de l’UML, l’has d’instal·lar).
    • Crea l’UML del projecte actual (botó dreta damunt el package de projecte i tria “generate UML”.
UML del projecte Bouncing Ball V3. Mostra de totes les classes, les seves relacions i l’abast dels seus estats.

3. Estudi de l’estructura.

Molt bé, sabem que tenim una classe que pinta, una altra que és una bolla. I hem vist que tenen constructors i mètodes que els implementen. Ara és hora de posar en marxa el projecte i observar que fa.

Si l’has executat i ha funcionat veuràs que es tracta d’una aplicació que amolla dues bolles que boten amb un rebot bastant encertat. Ho fa una vegada i aquesta el la demostració de la implementació amb un codi que es troba al main.

Podem deduir que el bon comportament d’aquestes classes està generat per una estructura tal que ens permet tenir:

  1. Una classe canvas que és l’encarregada de la finestra i de pintar els objectes que es van generant.
  2. Una classe bouncingball que s’encarrega de crear bolles i de implementar el seu moviment bouncing
  3. Una classe demostració que posa en marxa l’aplicació.

Farem una investigació de codi, ho farem mirant la classe BallDemo.java i mirant pas per pas què és el que implementa:

  • El paquet al qual pertany, hem fet el projecte dins un paquet anomenat balldemo, això fa que s’integri tot dins un mateix paquet. (totes les classes del projecte duen com a primera línia)
package balldemo;
  • Declaració de la Classe BallDemo. Té com estat variable un Canvas públic amb nom de myCanvas. MyCanvas és el quadre on es dibuixaran les bolles.
public class BallDemo{
       private Canvas myCanvas;
       ......//conté mètodes de la Classe.
...}
  • Dins d’aquesta declaració hi trobam el mètode main.
public static void main(String[] args) {
// TODO code application logic here
BallDemo b = new BallDemo();
b.bounce();
}
  • ..que crida al constructor BallDemo(), aquest farà un nou objecte myCanvas que tendrà els mètodes del Canvas. En aquest cas construeix un objecte canvas de 600x500px.
public BallDemo(){
myCanvas = new Canvas("Ball Demo", 600, 500);}
  • b.bounce(); Significa que sobre l’objecte BallDemo b hi aplica el mètode bounce que és el que configura tota l’acció del moviment de les bolles.
public void bounce()
    {
        int ground = 300;   // position of the ground line

        myCanvas.setVisible(true);

        // draw the ground
        myCanvas.setForegroundColor(Color.BLACK);
        myCanvas.drawLine(50, ground, 550, ground);

        // create and show the balls
        BouncingBall ball = new BouncingBall(70, 50, 16, Color.BLUE, ground, myCanvas);
        ball.draw();
        BouncingBall ball2 = new BouncingBall(70, 80, 20, Color.RED, ground, myCanvas);
        ball2.draw();

        // make them bounce
        boolean finished =  false;//Variable de control final
        while (!finished) {
            myCanvas.wait(50);           // small delay
            ball.move();
            ball2.move();
            // stop once ball has travelled a certain distance on x axis
            if(ball.getXPosition() >= 550 || ball2.getXPosition() >= 550) {
                finished = true;
            }
        }
    }
  • El mètode bounce(), el primer que fa és inicialitzar la variable de línia de terra a 300, aquesta variable no és comuna a tot el canvas, és propia de cada bolla que es crei.
  • Les bolles es creen una a una fent un objecte nou de tipus BouncingBall() i invocant el seu constructor, els paràmetres que l’implementen, estan explicats al seu javadoc:
    • BouncingBall(int xPos, int yPos, int ballDiameter, java.awt.Color ballColor, int groundPos, Canvas drawingCanvas)
      Constructor for objects of class BouncingBall.
  • Quan s’ha creat una bolla s’ha de pintar mitjançant el mètode draw() de BouncingBall.

Exercici 12.5

  • Fes una tercera bolla d’un altre color i a una altra posició. Has de conseguir que boti amb les altres.
  • Canvia l’ordre d’execució del mètode move() de les bolles que reboten. Observa els canvis que fa l’execució.
  • Fes que la bolla que queda davant sigui blava. Fes una exportació com a  Exercici125.zip i desa’l a la carpeta compartida.

 

  • De la línia 52 a la 60 fa el bucle que controla els bots de les bolles, empra un delay per donar un espai de temps a l’aplicació i que no acabi de seguida. Cada bolla crida al mètode move() que és el que fa el moviment tipus bot. Observa el codi del metode move().
public void move()
{
        // remove from canvas at the current position
        erase();

         // compute new position
         ySpeed += GRAVITY;
         yPosition += ySpeed;
         xPosition +=2;

         // check if it has hit the ground
         if (yPosition >= (groundPosition - diameter) && ySpeed > 0) {
              yPosition = (int)(groundPosition - diameter);
              ySpeed = -ySpeed + ballDegradation;
          }
         // draw again at new position
         draw();
}

Exercici 12.7

  • Cream un nou tipus de moviment. Per això has d’estudiar el comportament del mètode move().
  • Per fer aquest nou tipus de moviment no crearem un mètode nou. Farem una classe nova BouncingNew que farà un extends de la classe BouncingBall que heretarà tots els estats i mètodes. Però li canviarem un mètode, el mètode move() mitjançant un @Override.
  • move() de BouncingNew ha de tenir el mateix codi de move(), sols has de canviar la línia on posa YSpeed+= GRAVITY per YSpeed+= (GRAVITY +2)
  • Crea un altre Classe extends de BouncingBall que tengui un altre tipus de moviment.
  • Fes que quan dues bolles es toquin canviin de color.
package balldemo;

import java.awt.Color;

public class BouncingNew extends BouncingBall{

       public BouncingNew(int xPos, int yPos, int ballDiameter, Color ballColor, int groundPos, Canvas drawingCanvas) {
           super(xPos, yPos, ballDiameter, ballColor, groundPos, drawingCanvas);
        }

       @Override
       public void move(){
       // remove from canvas at the current position
erase();

// compute new position
ySpeed += (GRAVITY + 2);
yPosition += ySpeed;
xPosition +=2;

// check if it has hit the ground
if (yPosition >= (groundPosition - diameter) && ySpeed > 0) {
yPosition = (int)(groundPosition - diameter);
ySpeed = -ySpeed + ballDegradation;
}

// draw again at new position
draw();
}

 

http://aula.gimnesia.net/wp-content/uploads/2018/04/Captura-de-pantalla-2018-04-30-a-les-17.24.37-1024x862.pnghttp://aula.gimnesia.net/wp-content/uploads/2018/04/Captura-de-pantalla-2018-04-30-a-les-17.24.37-150x150.pngadmin2on batxillerat0. Objectius. En aquesta unitat feim una passa endavant i ens disposam a: Entendre la implementació d'una Canvas. Entendre mètodes que donaran moviment a objectes. Modificar els mètodes. Primer estudiarem les propietats del projecte i després hi afegirem opcions de execució de botons i la creació de finestres més...Blog Aula Informàtica Gimnèsia