Arquivo Discussoes de Programacao e Tecnologia Oi!
Estou desenvolvendo uma API para Gravidade em 2D. Só que estou tendo um probleminha. Eu chamo o metodo l.add(shape); da minha List l = new ArrayList(); só que quando cehga a hora de pegar cada um desses itens da list e coloca-los na tela com o paintComponent() ele diz que o tamanho da list é 0! Não tenho muito código para exibir, pois estou usando somente um System.out.println(l.size()); Se alguem puder me ajudar ficarei agradecido!
Não tem que ter um tipo nesse ArreyList?
Exemplo:
ArrayList<Tipo> 1 = new ArrayList<tipo>();
:roll:
Cola teu código ai.
Essa é a classe da Lista das formas geométricas (Shapes) adicionadas ao Mundo 2D (World2D):
package net.jphysics.geometry;
import java.util.*;
public class ShapeList {
List l = new ArrayList();
//--------------------------------------------------------------------------
public void add(Shape s) {
l.add(s);
}
//--------------------------------------------------------------------------
public void remove(int index) {
l.remove(index);
}
public void remove(Shape s) {
l.remove(s);
}
public void removeAll() {
int x = 0;
while(x != l.size()) {
l.remove(x);
}
x = 0;
}
//--------------------------------------------------------------------------
public Shape get(int index) {
return (Shape) l.get(index);
}
public int size() {
return l.size();
}
}
add(shape);
size().;
Bom tenta isso…
public class ShapeList {
List l = new ArrayList();
//--------------------------------------------------------------------------
public void add(Shape s) {
l.add(s);
}
//--------------------------------------------------------------------------
public void remove(int index) {
l.remove(index);
}
public void remove(Shape s) {
l.remove(s);
}
public void removeAll() {
int x = 0;
while(x != l.size()) {
l.remove(x);
}
x = 0;
}
//--------------------------------------------------------------------------
public Shape get(int index) {
return (Shape) l.get(index);
}
public int size() {
return l.size();
}
public static void main(String[] args) {
Shape s = null;
try {
s = Shape.class.newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ShapeList shape = new ShapeList();
shape.add(s);
System.out.println("tamanho da lista = " + shape.size());
}
}
O que uma ShapeList tem de diferente de uma lista? Tem alguma operaçõa (método) diferente?
Crie a lista usando genéricos e pronto. Não há a necessidade de criar uma ShapeList. Se mesmo assim você quiser mesmo criar uma ShapeList (porque vai existir algum método a mais) ai sim você estenderia a clase ArrayList por exemplo.
Isso aqui é muito mais simples.
List<Shape> lista = new ArrayList<Shape>();
[]´s
E outra coisa. Seu método removeAll tem problema… Quando você remove um elemento da lista os índices mudam… Ou você faz isso usando um iterator, ou reinstancia a lista ou então usa o método removeAll (herdado da interface List).
[]´s
Bem, acho que vocês não me compreenderam direito, vou tentar me explicar melhor.
Há várias classes, a classe Square, a classe Circle, etc. Que são formas geométricas. E cada vez que um Circle ou um Quare é criado ele é adicionado à classe ShapeList. Depois eu acesso a ShapeList e pego o número de formas geométricas e utilizo um loop para renderiza-las na tela.
// painelDeDesenho.java
private ShapeList l = new ShapeList();
@Override
protected void paintComponent(Graphics g) {
// Here the jPhysics API will 'paint' all the
// stuff, like squares and circles.
Graphics2D g2d = (Graphics2D) g.create();
g.setColor(Color.black);
g.fillRect(0, 0, this.getWidth(), this.getHeight());
g.setColor(Color.white);
int[] values = new int[5];
for(i=0; i<l.size(); i++) {
if(l.get(i).equals(new Square())) {
values = l.get(i).getValues();
if(values[0] == 0) {
// É um quadrado, pois o values[0] representa o tipo da forma geométrica
g2d.draw(new Rectangle2D.Double
(values[1], values[2],
values[3], values[4]));
}
}
}
i = 0;
g2d.dispose();
}
Só que o 'l' sempre retorna 0!
OBS: Valeu pela dica David, já arrumei o removeAll!
Oi Gustavo,
Bem, acho que você está começando, então, vamos lá.
Se você tem uma superclasse comum (Shape), você pode-se valer do polimorfismo para "renderizar" as formas, sem precisar fazer essa comparação um pouco estranha do seu for. Digo estranha pois poderia ser feita de outra forma, usando o operador instanceof. Mas vamos a um exemplo:
Forma.javaimport java.awt.Graphics2D;
/**
*
* @author David Buzatto
*/
public abstract class Forma {
// as classes filhas de Shape vão herdar as "propriedades" x e y (acessadas
// através dos métodos get e set
private int x;
private int y;
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
// método abstrato que será implementado pelas classes filhas,
// sendo que é na implementação específica que o algoritmo de desenho
// é executado
public abstract void drawMe( Graphics2D g2d );
}
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;
/**
*
* @author David Buzatto
*/
public class Retangulo extends Forma {
private int largura;
private int altura;
public int getAltura() {
return altura;
}
public void setAltura(int altura) {
this.altura = altura;
}
public int getLargura() {
return largura;
}
public void setLargura(int largura) {
this.largura = largura;
}
// desenhando um retângulo...
@Override
public void drawMe( Graphics2D g2d ) {
Rectangle2D.Double r = new Rectangle2D.Double( getX(), getY(),
getLargura(), getAltura() );
g2d.draw( r );
}
}
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;
/**
*
* @author David Buzatto
*/
public class Quadrado extends Retangulo {
public int getTamanho() {
return getLargura();
}
public void setTamanho(int tamanho) {
setLargura(tamanho);
}
// desenhando um quadrado...
@Override
public void drawMe( Graphics2D g2d ) {
Rectangle2D.Double r = new Rectangle2D.Double( getX(), getY(),
getTamanho(), getTamanho() );
g2d.draw( r );
}
}
import java.awt.Graphics2D;
import java.awt.geom.Ellipse2D;
/**
*
* @author David Buzatto
*/
public class Circulo extends Forma {
private int raio;
public int getRaio() {
return raio;
}
public void setRaio(int raio) {
this.raio = raio;
}
// desenhando um círculo...
@Override
public void drawMe( Graphics2D g2d ) {
Ellipse2D.Double e = new Ellipse2D.Double( getX(), getY(), getRaio()*2, getRaio()*2 );
g2d.draw( e );
}
}
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JPanel;
/**
*
* @author David Buzatto
*/
public class PainelDesenho extends JPanel {
// uma lista de formas
private List<Forma> lista;
public PainelDesenho() {
// instancia a lista
lista = new ArrayList<Forma>();
}
@Override
protected void paintComponent( Graphics g ) {
Graphics2D g2d = ( Graphics2D ) g;
g.setColor( Color.black );
g.fillRect( 0, 0, this.getWidth(), this.getHeight() );
g.setColor( Color.white );
// itera pela lista
for ( Forma f : lista ) {
// como todo mundo que herda de Forma implementa o método drawMe,
// quando chamar f.drawMe, o método correspondente à instância
// em questão será executado.
f.drawMe( g2d );
}
}
}
Note que você pode inserir outras propriedades na classe Forma, como a cor da forma, se ela deve ser desenha ou preenchida, se você tem uma cor de preenchimento e uma de contorno...
Enfim, são muitas as possibilidades.
Se não souber o que é polimorfismo, dê uma olhada nesse link: http://www.guj.com.br/posts/list/49267.java
Perceba como ficou muito mais simples fazer o que você precisa.
[]´s