Ajuda, programa básico.... (Java)

Jv.Batista

I fold therefore I AM
bom, o trabalho autónomo (como o prof lhe chama xD) desta semana é fazer algo parecido com isto

1223447400.jpg


tipo, o rectangulo e a linha foi coisa de 5 min

agora n tou a ver é como é que para o rectangulo 2 o meto a começar ao lado do primeiro...

aceitam.se sugestões...

vou usar um ciclo para meter x retangulos e outro para meter x linhas, só não tou a ver como os meto a aparecer ao lado uns dos outros...

GRect r2 = new.GRect ( (x + constante), y);

o x( ponta do anterior ), é que eu não tou a ver como vou buscar...
 
Última edição:
Só precisas de guardar a coordenada x do último rectângulo que foi desenhado e somar-lhe um offset ou valor constante como tu definiste. Para tal, precisas de uma variável do género offsetX que vai sendo incrementada com a largura de cada rectângulo (+ offset). Algo do género:

Código:
int offsetX = 0;
for (int i = 0; i < 20; i++)
{
    DrawRectangle(offsetX, y, larguraRectangulo, alturaRectangulo);
    offsetX += larguraRectangulo + constante;
}
 
Só precisas de guardar a coordenada x do último rectângulo que foi desenhado e somar-lhe um offset ou valor constante como tu definiste. Para tal, precisas de uma variável do género offsetX que vai sendo incrementada com a largura de cada rectângulo (+ offset). Algo do género:

Código:
int offsetX = 0;
for (int i = 0; i < 20; i++)
{
    DrawRectangle(offsetX, y, larguraRectangulo, alturaRectangulo);
    offsetX += larguraRectangulo + constante;
}

thanks,

vou tentar fazer isso...

tb, só tenho 2 aulas de programação...

um colega meu fez à unha... :005:

edit: aqui fica o código do programa já completo...

Código:
import acm.graphics.*;
import acm.program.*;
import acm.gui.*; 
import acm.util.*; 
import acm.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.applet.*;

/** Este código utiliza a <a href="http://jtf.acm.org/index.html">
 * biblioteca ACM Java Task Force</a> para a qual existe
 * <a href="http://jtf.acm.org/javadoc/student/index.html">esta documentação</a>.
 * <p>
 * Esta classe é um exemplo de um "GraphicsProgram": um programa com
 * uma janela na qual é possível desenhar objectos gráficos. 
 * <p>
 * Este template para o BlueJ foi criado na 
 * <a href="http://www.estig.ipbeja.pt">
 * Escola Superior de Tecnologia e Gestão</a> do
 * Instituto Politécnico de Beja, por Joao Paulo Barros, 
 * em 2007/03/23. 
 * Esta é a versão de 2008/09/28.
 * <hr>
 * @author (o seu nome) 
 * @version (número de versão ou data) 
 */
 // Deve escrever o código utilizando a língua inglesa

public class _um_desenho_ extends GraphicsProgram 
{
    /** É aqui que os objectos da classe _um_desenho_ 
     *  começam realmente a fazer coisas. 
     *  Coloque o seu código entre as chavetas.
     */    
    public void run()
    {
        
        // Este código cria um objecto da classe GLabel e 
        // guarda o nome desse objecto na variável oneGLabel
        GLabel oneGLabel = new GLabel("Desenho Marado", 40, 10);
        // Pede ao objecto da classe _um_desenho_ para adicionar
        // o nosso objecto GLabel na janela gráfica
        this.add(oneGLabel);

            int larguraRectangulo = 20;
            int alturaRectangulo = 373;
            int ponto_inicial_r_y = 30;
            int afastamento_r = 30;
            int afastamento_l_c = 50;
            int afastamento_l_b = 50;
            int ponto_inicial_r_x = 15;
            int inicio_linha_x = 75;
            int inicio_linha_y = 30;
            int fim_linha_x_constante_ = 0;
            int fim_linha_y_constante_ = 390;
            for (int i = 0; i < 13; i++)
            {
                GRect r1 = new GRect(ponto_inicial_r_x, ponto_inicial_r_y, larguraRectangulo, alturaRectangulo);
                ponto_inicial_r_x += larguraRectangulo + afastamento_r;
                r1.setFilled(true);
                r1.setFillColor( Color.YELLOW );
                this.add(r1);
                //r1.sendToBack();
                r1.sendToFront();
                GLine l1 = new GLine(inicio_linha_x, inicio_linha_y, fim_linha_x_constante_, fim_linha_y_constante_);
                fim_linha_x_constante_ += afastamento_l_b;
                inicio_linha_x += afastamento_l_c;
                this.add(l1);
                l1.sendToBack();
                //l1.sendToFront();
                
            }   
    }
}

mais uma vez, obrigado AliFromCairo
 
Última edição:
Ok, isso pode ser feito de várias formas. A mais simples seria passares os argumentos através da linha de comandos e acederes a eles através do parâmetro args do método main, mas penso que tal não é possível uma vez que não deves ter acesso à classe GraphicsProgram ou, mesmo que tenhas, possivelmente não a podes modificar.

Outra hipótese (provavelmente a mais aconselhável) é utilizares o método readInt() da classe GraphicsProgram, tal como documentado aqui.
 
Ok, isso pode ser feito de várias formas. A mais simples seria passares os argumentos através da linha de comandos e acederes a eles através do parâmetro args do método main, mas penso que tal não é possível uma vez que não deves ter acesso à classe GraphicsProgram ou, mesmo que tenhas, possivelmente não a podes modificar.

Outra hipótese (provavelmente a mais aconselhável) é utilizares o método readInt() da classe GraphicsProgram, tal como documentado aqui.

já tenho o programa completo... agora só falta simplificar...

Código:
import acm.graphics.*;
import acm.program.*;
import acm.gui.*; 
import acm.util.*; 
import acm.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.applet.*;

/** Este código utiliza a <a href="http://jtf.acm.org/index.html">
 * biblioteca ACM Java Task Force</a> para a qual existe
 * <a href="http://jtf.acm.org/javadoc/student/index.html">esta documentação</a>.
 * <p>
 * Esta classe é um exemplo de um "GraphicsProgram": um programa com
 * uma janela na qual é possível desenhar objectos gráficos. 
 * <p>
 * Este template para o BlueJ foi criado na 
 * <a href="http://www.estig.ipbeja.pt">
 * Escola Superior de Tecnologia e Gestão</a> do
 * Instituto Politécnico de Beja, por Joao Paulo Barros, 
 * em 2007/03/23. 
 * Esta é a versão de 2008/09/28.
 * <hr>
 * @author (o seu nome) 
 * @version (número de versão ou data) 
 */
 // Deve escrever o código utilizando a língua inglesa

public class _um_desenho_ extends GraphicsProgram 
{
    /** É aqui que os objectos da classe _um_desenho_ 
     *  começam realmente a fazer coisas. 
     *  Coloque o seu código entre as chavetas.
     */       
    public void run()
    {
        
        // Este código cria um objecto da classe GLabel e 
        // guarda o nome desse objecto na variável oneGLabel
        GLabel oneGLabel = new GLabel("Desenho Marado", 40, 10);
        // Pede ao objecto da classe _um_desenho_ para adicionar
        // o nosso objecto GLabel na janela gráfica
        this.add(oneGLabel);

            //coordenadas do rectangulo
            int larguraRectangulo = 20;
            int alturaRectangulo = 370;
            int ponto_inicial_r_y = 30;
            int ponto_inicial_r_x = 15;
            
            //coordenadas da linha
            int inicio_linha_x = 75;
            int inicio_linha_y = 30;
            int fim_linha_x = 0;
            int fim_linha_y = 390;
            
            //afastamento entre rectangulos
            int afastamento_r = 30;
            
            //afastamento entre linhas
            int afastamento_l = 50;
                        
            //caixa de dialogo para introdução do nº de rectangulos
            IODialog dialog = new IODialog();
            int n_d_r = dialog.readInt("Indique o número de rectangulos desejado", 0, 14);

            //ciclo para a criação de x rectangulos
            for (int a = 0; a < n_d_r; a++)
            {
                GRect r1 = new GRect(ponto_inicial_r_x, ponto_inicial_r_y, larguraRectangulo, alturaRectangulo);
                ponto_inicial_r_x += larguraRectangulo + afastamento_r;
                r1.setFilled(true);
                r1.setFillColor( Color.YELLOW );
                this.add(r1);
                //r1.sendToBack();
                r1.sendToFront();  
            }
            
            //caixa de dialogo para introducção do nº de linhas
            IODialog dialog2 = new IODialog();
            int n_d_l = dialog2.readInt("Indique o número de linhas desejado", 0, 14);
            
            //ciclo para a criação de x linhas
            for (int b = 0; b < n_d_l; b++)
            {
                GLine l1 = new GLine(inicio_linha_x, inicio_linha_y, fim_linha_x, fim_linha_y);
                fim_linha_x += afastamento_l;
                inicio_linha_x += afastamento_l;
                this.add(l1);
                l1.sendToBack();
                //l1.sendToFront();
            }
            
    }
}
em 10 min meti a coisa a funcionar como deve ser, o segredo é, quando não se está a ir lá, afastar uma beca e voltar a tentar mais tarde...

muito obrigado AliFromCairo
 
Última edição:
desculpem lá o double post

Código:
import acm.graphics.*;
import acm.program.*;
import acm.gui.*; 
import acm.util.*; 
import acm.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.applet.*;

/** Este código utiliza a <a href="http://jtf.acm.org/index.html">
 * biblioteca ACM Java Task Force</a> para a qual existe
 * <a href="http://jtf.acm.org/javadoc/student/index.html">esta documentação</a>.
 * <p>
 * Esta classe é um exemplo de um "GraphicsProgram": um programa com
 * uma janela na qual é possível desenhar objectos gráficos. 
 * <p>
 * Este template para o BlueJ foi criado na 
 * <a href="http://www.estig.ipbeja.pt">
 * Escola Superior de Tecnologia e Gestão</a> do
 * Instituto Politécnico de Beja, por Joao Paulo Barros, 
 * em 2007/03/23. 
 * Esta é a versão de 2008/09/28.
 * <hr>
 * @author (o seu nome) 
 * @version (número de versão ou data) 
 */
 // Deve escrever o código utilizando a língua inglesa

public class _um_desenho_ extends GraphicsProgram 
{
    /** É aqui que os objectos da classe _um_desenho_ 
     *  começam realmente a fazer coisas. 
     *  Coloque o seu código entre as chavetas.
     */       
    public void run()
    {
        
        // Este código cria um objecto da classe GLabel e 
        // guarda o nome desse objecto na variável oneGLabel
        GLabel oneGLabel = new GLabel("Desenho Marado", 40, 25);
        // Pede ao objecto da classe _um_desenho_ para adicionar
        // o nosso objecto GLabel na janela gráfica
        this.add(oneGLabel);

            //coordenadas do rectangulo
            int larguraRectangulo = 20;
            int alturaRectangulo = 370;
            int ponto_inicial_r_x = 15;
            
            //coordenadas da linha
            int inicio_linha_x = 75;
            int fim_linha_x = 0;     
          
            //usada no afastamento entre linhas e rectangulos
            int afastamento = 50;
                        
            //caixa de dialogo para introdução do nº de rectangulos
            IODialog dialog = new IODialog();
            int n_d_r = dialog.readInt("Indique o número de rectangulos desejado", 0, 15);

            //ciclo para a criação de x rectangulos a pedido do utilizador dentro do limite da janela visivel
            for (int a = 0; a < n_d_r; a++)
            {
                GRect r1 = new GRect(ponto_inicial_r_x, ( inicio_linha_x / 2), larguraRectangulo, alturaRectangulo);
                ponto_inicial_r_x += larguraRectangulo + ( afastamento - larguraRectangulo);
                r1.setFilled(true);
                r1.setFillColor( Color.YELLOW );
                this.add(r1);
                r1.sendToFront();  
            }
            
            //caixa de dialogo para introducção do nº de linhas
            IODialog dialog2 = new IODialog();
            int n_d_l = dialog2.readInt("Indique o número de linhas desejado", 0, 14);
            
            //ciclo para a criação de x linhas
            for (int b = 0; b < n_d_l; b++)
            {
                GLine l1 = new GLine(inicio_linha_x, (2 * larguraRectangulo), fim_linha_x, (larguraRectangulo + alturaRectangulo));
                fim_linha_x += afastamento;
                inicio_linha_x += afastamento;
                this.add(l1);
                l1.sendToBack();
            }
            
    }
}
este código está fácil de perceber ou nem por isso?

a meu ver está, visto que está lá os comentários a explicar para que cada coisa serve, os espaços e espaçamentos tornam o texto todo pipi, etc...

aceitam-se comentários e sugestões a melhorar o código...
 
Última edição:
Penso que ainda podes melhorar alguns pontos. Normalmente, existe uma convenção que dita que os nomes das classes (em Java) não devem ter '_' e devem começar por uma letra maiúscula, logo, penso que deverias mudar o nome da tua classe para algo mais convencional. Devias também ser mais coerente com os nomes que dás às tuas variáveis, por exemplo, utilizas alturaRectangulo (convenção Java, também conhecida por Camel Cased) em alguns casos e a notação com "_" noutros (e.g. inicio_linha_x). Adicionalmente, algumas variáveis têm um nome que não indica directamente o "significado" delas, como por exemplo, n_d_l ou n_d_r. Podias ter numeroLinhas e numeroRectangulos, respectivamente.

Podias também criar os métodos criarLinhas e criarRectangulos para envolver certos blocos do teu código, mas dada a dimensão do teu programa, penso que não ganhas muito em fazer isso.

Espero que ajude.
 
Última edição:
Ai se o JPB sabe:p
Entraste este ano? Anyway o jpb, entre outros vai ser um dos melhores profs que vais encontrar na estig.
Penso que ja te ajudaram bastante aqui em relação ao Java, mas quando deixares o BlueJ e começares a usar o eclipse eh que vai ser :rolleyes:
 
Ai se o JPB sabe:p
Entraste este ano? Anyway o jpb, entre outros vai ser um dos melhores profs que vais encontrar na estig.
Penso que ja te ajudaram bastante aqui em relação ao Java, mas quando deixares o BlueJ e começares a usar o eclipse eh que vai ser :rolleyes:

entrei o ano passado mas só este ano é que tenho p1...
ele não anda por estes lados, i think... e este tb era só pa tirar algumas dúvidas, não pedi para me fazerem o programa e nem eles faziam...

Código:
import acm.graphics.*;
import acm.program.*;
import acm.gui.*; 
import acm.util.*; 
import acm.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.applet.*;

/** Este código utiliza a <a href="http://jtf.acm.org/index.html">
 * biblioteca ACM Java Task Force</a> para a qual existe
 * <a href="http://jtf.acm.org/javadoc/student/index.html">esta documentação</a>.
 * <p>
 * Esta classe é um exemplo de um "GraphicsProgram": um programa com
 * uma janela na qual é possível desenhar objectos gráficos. 
 * <p>
 * Este template para o BlueJ foi criado na 
 * <a href="http://www.estig.ipbeja.pt">
 * Escola Superior de Tecnologia e Gestão</a> do
 * Instituto Politécnico de Beja, por Joao Paulo Barros, 
 * em 2007/03/23. 
 * Esta é a versão de 2008/09/28.
 * <hr>
 * @author (o seu nome) 
 * @version (número de versão ou data) 
 */
 // Deve escrever o código utilizando a língua inglesa

public class _um_desenho_ extends GraphicsProgram 
{
    /** É aqui que os objectos da classe _um_desenho_ 
     *  começam realmente a fazer coisas. 
     *  Coloque o seu código entre as chavetas.
     */       
    public void run()
    {
        
        // Este código cria um objecto da classe GLabel e 
        // guarda o nome desse objecto na variável oneGLabel
        GLabel oneGLabel = new GLabel("Desenho Marado", 40, 25);
        // Pede ao objecto da classe _um_desenho_ para adicionar
        // o nosso objecto GLabel na janela gráfica
        this.add(oneGLabel);

            //coordenadas do rectangulo
            int largRect = 20;
            int altRect = 370;
            int coord_x_Rect = 15;
            
            //coordenadas da linha
            int ini_coord_line_x = 75;
            int fin_coord_line_x = 0;     
          
            //usada no afastamento entre linhas e rectangulos
            int space = 50;
                        
            //caixa de dialogo para introdução do nº de rectangulos
            IODialog dialog = new IODialog();
            int n_d_r = dialog.readInt("Indique o número de rectangulos desejado", 0, 15);

            //ciclo para a criação de x rectangulos a pedido do utilizador dentro do limite da janela visivel
            for (int r = 0; r < n_d_r; r++)
            {
                GRect r1 = new GRect(coord_x_Rect, ( ini_coord_line_x / 2), largRect, altRect);
                r1.setFilled(true); r1.setFillColor( Color.YELLOW ); this.add(r1); r1.sendToFront();
                coord_x_Rect += space;
            }
            
            //caixa de dialogo para introducção do nº de linhas
            IODialog dialog2 = new IODialog();
            int n_d_l = dialog2.readInt("Indique o número de linhas desejado", 0, 14);
            
            //ciclo para a criação de x linhas
            for (int l = 0; l < n_d_l; l++)
            {
                GLine l1 = new GLine(ini_coord_line_x, (2 * largRect), fin_coord_line_x, (largRect + altRect));
                this.add(l1); l1.sendToBack();
                ini_coord_line_x += space; fin_coord_line_x += space; 
            }
            
    }
}
ainda lhe vou fazer mais umas alterações, mas acho que já tá bom... como ele diz, cada um tem o seu estilo de programação...

edit:

Código:
import acm.graphics.*;
import acm.program.*;
import acm.gui.*; 
import acm.util.*; 
import acm.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.applet.*;

/** Este código utiliza a <a href="http://jtf.acm.org/index.html">
 * biblioteca ACM Java Task Force</a> para a qual existe
 * <a href="http://jtf.acm.org/javadoc/student/index.html">esta documentação</a>.
 * <p>
 * Esta classe é um exemplo de um "GraphicsProgram": um programa com
 * uma janela na qual é possível desenhar objectos gráficos. 
 * <p>
 * Este template para o BlueJ foi criado na 
 * <a href="http://www.estig.ipbeja.pt">
 * Escola Superior de Tecnologia e Gestão</a> do
 * Instituto Politécnico de Beja, por Joao Paulo Barros, 
 * em 2007/03/23. 
 * Esta é a versão de 2008/09/28.
 * <hr>
 * @author (o seu nome) 
 * @version (número de versão ou data) 
 */
 // Deve escrever o código utilizando a língua inglesa

public class DesenhoMarado extends GraphicsProgram 
{
    /** É aqui que os objectos da classe _um_desenho_ 
     *  começam realmente a fazer coisas. 
     *  Coloque o seu código entre as chavetas.
     */       
    public void run()
    {
        
        // Este código cria um objecto da classe GLabel e 
        // guarda o nome desse objecto na variável oneGLabel
        GLabel oneGLabel = new GLabel("Desenho Marado", 40, 25);
        // Pede ao objecto da classe _um_desenho_ para adicionar
        // o nosso objecto GLabel na janela gráfica
        this.add(oneGLabel);

            //coordenadas do rectangulo
            int largRect = 20;
            int altRect = 370;
            int coordRectX = 15;
            
            //coordenadas da linha
            int coordLineX1 = 75;
            int coordLineX2 = 0;     
          
            //usada no afastamento entre linhas e rectangulos
            int space = 50;
                        
            //caixa de dialogo para introduçao do nº de rectangulos
            IODialog dialog = new IODialog();
            int numRect = dialog.readInt("Indique o número de rectângulos desejado", 0, 15);

            //ciclo para a criaçao de x rectangulos a pedido do utilizador dentro do limite da janela visivel
            for (int r = 0; r < numRect; r++)
            {
                GRect r1 = new GRect(coordRectX, ( coordLineX1 / 2), largRect, altRect);
                r1.setFilled(true); r1.setFillColor( Color.YELLOW ); this.add(r1); r1.sendToFront();
                coordRectX += space;
            }
            
            //caixa de dialogo para introducçao do nº de linhas
            IODialog dialog2 = new IODialog();
            int numLines = dialog2.readInt("Indique o número de linhas desejado", 0, 14);
            
            //ciclo para a criação de x linhas
            for (int l = 0; l < numLines; l++)
            {
                GLine l1 = new GLine(coordLineX1, (2 * largRect), coordLineX2, (largRect + altRect));
                this.add(l1); l1.sendToBack();
                coordLineX1 += space; coordLineX2 += space; 
            }
            
    }
}

e já chega, vou mas é tomar o pequeno almoço...
 
Última edição:
Back
Topo