Curso de Java - Escrevendo Applets

Projeto 01

Neste projeto, vamos desenvolver applet na qual possa desenhar e visualizar algumas figuras geométricas simples, aperfeiçoando assim, a técnica de programação.

Primeira etapa: Classe de figuras

Vamos criar um applet na qual, desenha um quadrado, circulo e triangulo. Para isso, vamos implementar classes classe base denominado de figuras e usar polimorfísmo para poder desenhar e manipular figuras de forma única.
A classe figura contém um ponto que serve como referência para posição da figura, uma cor e dois métodos virtuais:

pertence: que testa, se o ponto está dentro da figura. Este método é essencial para testar se o mouse foi clicado sobre a figura.
desenha:: este método desenha a figura preenchido.
Vários construtores, inclusive uma que cria figura igual ao figura passado nele. Este método é similar a clone(), e permite criar cópias da classe definido.

class figura { 
    Point P; // ponto de referência da posição do objeto 
    public Color cor; // cor da figura 
    public void figura() { P = new Point(0,0); cor = new Color(0,0,0);} // construtor default 
    public void figura(int x, int y) { P = new Point(x,y);} 
    public void figura(int x, int y, Color cor) { P = new Point(x,y); 
         this.cor = new Color(cor.getRed(), cor.getBlue(), cor.getGreen()); }
    public void figura(figura fig) {
         figura(fig.p.x, fig.p.y, fig.cor); }
    // métodos virtuais 
    public bool pertence(Point P); 
    public void desenha(Graphics g); // desenha a figura preenchida na saída Graphics 
}

Uma classe derivada da classe figura devem implementar o método pertence e desenha. Por exemplo, uma classe quadrado que possui dois pontos de referência (canto superior esquerdo e canto inferior direito) pode ser implementado como sendo

class retangulo extends figura { 
    // P definido na super classe e o canto superior esquerdo 
    Point Q; // canto inferior direito 
    public void retangulo() { super(); Q = new Point(0,0); } // construtor default 
    public void retangulo(int x1, int y1, int x2, int y2) { super(x1,y1); Q = new Point(x2,y2); }
    public void retangulo(int x1, int y2, int x2, int y2, color cor) {
       super(x1,y1,cor); Q = new Point(x2,y2); }
    public void retangulo(retangulo retang) {
       super(retang); Q = new Point(x2,y2); } 
    // métodos virtuais
    public bool pertence(Point P) { 
      return ( (this.P.x<=P.x)&&(P.x<=Q.x) && (this.P.y<=P.y)&&(P.y<=Q.y) ); 
   } 
   public void desenha(Graphics g) { // desenha a figura preenchido saída Graphics
     int coordx[]={P.x, P.x, Q.x, Q.x};
     int coordy[]={P.y, Q.y, Q.y, P.y};
     g.setcolor(cor); // seta a cor
     Polygon  retang=new Polygon(coordx, coordy, 4); // retângulo é poligono de quatro vértices.
     g.fillPolygon(retang); 
 } 
}

A classe Polygon e a classe de polígono e, é criado, passando dois vetores de interiros (lista de coordenadas X e Y respectivamente) e um inteiro, indicando o número de vértices. O método fillPolygon da classe Graphics desenha o poligono preenchido.

Exercício 1:
Agora implemente uma classe extendido de figura, denominado de circulo. Lembre-se que:

O círculo pode ser representado pelo centro e raio.
O método
public abstract void fillOval(int x, int y, int width, int height)
desenha elipse preenchido, com centro em (x,y) com raios width e height nos eixos X e Y, respectivamente. Não esqueça de ajustar a cor.
Um ponto X pertence a um círculo de raio r com centro em P se e somente se <X-P> <= r*r

A classe deve ter construtores similares a da classe retangulo.

Exercício 2:
Implemente também, a classe triangulo. lembre-se que:

O triângulo pode ser representado por três pontos.
O método
bool inside(int x, int y)
da classe Polygon testa se o ponto (x,y) pertence ao poligono.

Esta classe será implementado de forma quase igual ao retangulo.

Exercício 3:
Crie um applet para testar as três figuras acima e verifique se pode criar e desenhar corretamente.

Segunda etapa; classe de desenhos

Agora, vamos criar classe denominado de desenho que compõe de um vetor de figuras, e métodos de manipulação.

Campo:
Inicialmente, queremos que seja capaz de armazenar figuras com rótulo (nome) para facilitar a manipulação. Assim, esta classe deve possuir dois vetores: um vetor de classe figura e outro de String para guardar o nome correspondente. Claro, não devemos esquecer do número de elementos.

Métodos:

Esta classe deve ser capaz de inserir ou deletar figuras do vetor de figuras, referênciando pelo nome.
Deve ser capaz de desenhar todas figuras em ordem, sobrepondo-os segundo a prioridade.
dado ponto (x,y), deve identificar qual das figuras desenhadas contém este ponto. isto permite selecionar figura pelo mouse.
permite mudar a prioridade. Dado um nome, deve ser capaz de colocar por último, permitindo assim, que esta figura seja desenhado por último.

class desenho {
  figura figs[]; // lista de desenhos
  String nomes[]; // lista dos nomes das figuras 
  int numfigs; // número de figuras
  int maxfigs; // número máximo de figuras
  // construtor
  public desenho(){
    figs=new figura[50];
    nomes=new String[50];
    numfigs=0;
    maxfigs=50;
  }
  public desenho(int numfigs) {
    figs=new figura[numfigs];
    nomes=new String[numfigs];
    this.numfigs=0;
    maxfigs=numfigs;
  }
  // métodos auxiliares.
  private int procura(String nomefig) {
    // retorna o índice da figura.
    // caso não for encontrado, retorna numfigs
    int i=0;
    for(i=0;i<numfigs;i++)
      if(nomes[i].equal(nomefig)) break;
    return i;
  }
  // insere figura. 
  public bool adiciona(String nome, figura fig) {
    if(numfigs<maxfigs) {
       figs[numfigs]=new figura(fig);
       nomes[numfigs]=new String(nome);
       numfigs++;
       return true;
     }
     return false;
  }
  // elimina figura      
  public bool elimina(String nome) {
    int i = procura(nome);
    if(i<numfigs) {
       for(;i<numfigs-1;i++) {
         figs[i]=figs[i+1];
         nomes[i]=nomes[i+1];
         numfigs--;
       }
       return true;
     }
     return false;
  }
  // desenha figura
  public void desenha(Graphics g) {
    int i;
    for(i=0;i<numfigs;i++)
      figs[i].desenha(g);
  }
  // encontra a primeira figura que contém (x,y)     
  // retorna "" caso não existir
  public String pertence(int x, int y) {
    int i;
    for(i=numfigs-1;i>=0;i--)
      if(figs[i].pertence(x,y))
         return nomes[i];
    return new String("");
 }
 // faz com que a figura indicada tenha primeira prioridade
 // fique por cima
  public void prioridade(String nome) {
    int i=procura(nome);
    figura tempfig;
    String tempnome;
    if(i<numfigs) {
      temp = figs[i];
      tempnome = nomes[i];
      for(;i<numfigs-1;i++) {
         figs[i] = figs[i+1];
         nomes[i] = nomes[i+1];
      }
      figs[i]=tempfig;
      nomes[i]=tempnome;
    }
  }
  // testa, se a figura se encontra
  public bool pertence(String nome) {
    return (procura(nome)<numfigs);
  }
  // este método retorna a figura com nome especificado,
  // caso não encontrar, gera uma excessão
  // "Ele não tira cópia!"
  public figura pegafigura(String nome) {
    int i = procura(nome);
    if(i<numfigs)
      return figs[i];
    else {
      return 
      trows NoSuchElementException; // definido no java.util
         // coloque import java.util.*; no começo do arquivo.
  }
}

Exercício 1:
Analise a classe acima com cuidado e em seguida, faça um applet para testar.

Exercício 2:
Faça com que o applet identifique a figura clicada pelo mouse e coloca na primeira prioridade (desenhar por último). Para isso, defina o método mouseDown();

[anterior, índice, seguinte]