Applet Graphics: Import Import Public Class Extends Public Void
Applet Graphics: Import Import Public Class Extends Public Void
*;
import java.applet.*;
public class anim1 extends Applet{
public void paint (Graphics g)
{
g.drawString("",400,300);
}
public static void main(String ad[])
{
anim1 a=new anim1();
Graphics g1;
a.paint(g1);
}
}
java
java
java
java
java
java
.
.
.
.
.
.
awt . Graphics ;
awt . Color ;
awt . Image ;
applet . Applet ;
lang . Math ;
util . Random ;
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
String cardNumber ;
double cardRandom ;
int cardRandomNumber ;
public int [] ranNum = new int [ 10 ];
Random ran = new Random ();
for ( int number = 0 ; number <= 9 ; )
{
cardRandom = ran . nextInt ( 52 ) + 1 ;
cardRandomNumber = ( int ) Math . round ( cardRandom );
si (cardRandomNumber> 0 && cardRandomNumber <= 52)
{ranNum [nmero] = cardRandomNumber;
nmero ++;}}}
}
java grficos inicializacin
Cdigo-Aprendiz
Albert Dong
20.6k23891
4928
3 Respuestas
activosms antiguosvotos
up
vote
vote downaceptada
proporcionar su propia aplicacin, que debe coincidir con esta firma de mtodo
exactamente. Eso significa que slo se permite un solo parmetro, es decir,
un Grficos objeto.
Usted es libre de crear un paintComponent () mtodo con ms argumentos, pero desde la
firma del mtodo no coincide, no ser llamado automticamente en el Tema Evento
Despacho cuando el sistema operativo decide el applet necesita ser repintado.
Con eso dicho, usted no tiene que extender JPanel con el fin de conseguir que esto
funcione. Puede ampliar cualquier clase que a su vez tiene JComponent como un
antepasado. En su caso particular, JPanel parece la mejor opcin. Le sugiero que
refactorizar el cdigo de la siguiente manera:
En RandomCards.java
pblicas RandomCards extiende JApplet {pblico
void init () {esto.
add (nuevos RandomCardsPanel ();}}
En RandomCardsPanel.java
pblica RandomCardsPanel extiende JPanel {// variables miembro privadas poner
aqu
pblica RandomCardsPanel () {// Dicho cdigo de su mtodo init actual ()
aqu}
pblica vaco paintComponent (Grficos g) {// Ponga su cdigo de pintura
personalizados aqu, incluyendo el establecimiento de el color de fondo y dibujar
las imgenes de la
tarjeta}}
usted no deberallamarlo expicitly. El sistema se llama este mtodo siempre que sea
apropiado.
Espero que esto ayude a aclarar algunos puntos. Buena suerte con su experiencia en
Java. Hganos saber si usted tiene ms preguntas.
cuota de mejorar esta respuesta
Cdigo-Aprendiz
20.6k23891
Buen enfoque, muy bien explicado. Otra forma de obtener el control directo de un grfico ejemplo es pintar en
un BufferedImage (y mostrarlo en una etiqueta). - Andrew Thompson 09 de septiembre '12 en 01:09
Le importara que muestra un ejemplo por favor? Creo que entiendo lo que usted dice, pero quiero confirmar.
Dong 11 de septiembre '12 a doce y veintitrs
1 AlbertDong Yo preferira que usted publique cdigo que muestra lo que usted entiende. Estar ms que feliz y
dispuesto a ayudarle a partir de ah. Usted puede editar su pregunta original aqu o publicar una nueva pregunta
completa, lo que usted piensa que es ms apropiado. - Cdigo-Aprendiz 11 de septiembre '12 a las 3:00
Lo siento por la respuesta tarda. Tuvo problemas con su ordenador y no era capaz de hacerlo funcionar hasta ayer.
editado mi cdigo original y sustituye pintura w / paintComponent (). Estoy seguro de lo que quieres decir con pintura
personalizada sin embargo. Necesito extender mi clase con JPanel con el fin de utilizar paintComponent ()?
Dong 16 de septiembre '12 a las 14:21
AlbertDong No s si es as le notifica de mi edicin de forma automtica. Este comentario seguramente llamar su
atencin, sin embargo. ;-) - Cdigo-Aprendiz 16 de septiembre '12 a las 17:07
mostrar 3 comentarios ms
up
vote
por
voto
Grficos g1;
una. Pintura (G1);
Por ejemplo:
// Bresenham.java
import
import
import
import
import
java.awt.*;
java.awt.event.*;
java.util.*;
javax.swing.JFrame;
java.lang.Math;
System.exit(-1);
}
if (args[0].equalsIgnoreCase("l")) {
}
if (args[0].equalsIgnoreCase("c")) {
}
*/
// Create an instance of this class that does the painting
new Bresenham();
}
// Constructor
Bresenham() {
// Call the constructor of the superclass
// i.e. open a JFrame named "Bresenham"
super("Bresenham");
// add a window listener that exits the program when the
JFrame is closed
addWindowListener(new WindowAdapter()
{public void windowClosing(WindowEvent e)
{System.exit(0);}});
setSize(900, 720);
// Add a canvas to the JFrame's ContentPane.
// The class CanvasBresenham inherits from Canvas!
getContentPane().add("Center", new CanvasBresenham());
// finally show it. This triggers the Canvas' paint
method.
show();
// this should be used, if the object to be painted has
changed.
// repaint();
}
}
class CanvasBresenham extends Canvas {
int centerX, centerY, dGrid = 1, maxX, maxY;
// initialize the graphics
void initgr() {
Dimension d;
// get the window size and compute minimum, maximum and
center
d = getSize();
maxX = d.width - 1;
maxY = d.height - 1;
centerX = maxX/2; centerY = maxY/2;
Algoritmo bsico
El algoritmo bsico utiliza la ecuacin de la recta expresada como
y = mx + b
Si la recta se dibuja desde el punto (x0, y0) hasta el punto (x1, y1), el algoritmo
varia x desde x0 hasta x1 en incrementos de una unidad. El siguiente es el cdigo
en Java.
public void rectaSimple(int x0, int y0, int x1, int y1,
Graphics g){
int dx = x1 - x0;
int dy = y1 - y0;
g.drawLine( x0, y0, x0, y0);//funciona!!
if (dx != 0){
float m = (float) dy / (float) dx;
float b = y0 - m*x0;
if(x1 > x0)
dx = 1;
else
dx = -1;
while (x0 != x1) {
x0 += dx;
y0 = Math.round(m*x0 + b);
g.drawLine( x0, y0, x0, y0);
}
}
}
El siguiente applet permite ver el proceso paso a paso. Seleccione dos puntos
sobre la cuadrcula y presione el botn "Siguiente" para ejecutar cada paso. Para
borrar presione el botn "Borrar". Note que para pendientes mayores de 45 o
menores de -45 el algoritmo dibuja rectas discontinuas.
//
// slope
//
Algoritmo de Bresenham
El algoritmo busca cual de dos pxeles es el que esta mas cerca segn la
trayectoria de la lnea. Consideremos el proceso de conversin para
lneas con pendiente positiva 0 < m < 1. Las posiciones de pxel a lo
largo de la trayectoria de una lnea se determinan al efectuar un
muestreo de x en intervalos unitarios.
voidLineBres(Graphicsg,intx0,inty0,intx1,int
y1){
intx,y,dx,dy,xend,p,incE,incNE;
dx=abs(x1x0);
dy=abs(y1y0);
p=2*dydx;
incE=2*dy;
incNE=2*(dydx);
/*determinarquepuntousarparaempezar,cualpara
terminar*/
if(x0>x1){
x=x1;
y=y1;
xend=x0;
}
else{
x=x0;
y=y0;
xend=x1;
}
g.drawLine( x0, y0, x0, y0);
/*seciclahastallegaralextremodelalnea*/
while(x<=xend){
g.drawLine(x,y,x,y);
x=x+1;
if(p<0)
p=p+incE
else{
y=y+1;
p=p+incNE;
}
g.drawLine( x0, y0, x0, y0);
}
}
El algoritmo de Bresenham se generaliza para lneas con una pendiente
arbitraria al considerar la simetra entre los diversos octantes y
cuadrantes del plano de xy. Para una lnea con una pendiente m > 1,
intercambiamos las funciones de las direcciones de x y y, o sea, pasamos
a lo largo de y en pasos unitarios y calculamos los valores sucesivos de x
y = y + stepy;
p = p + incNE;
}
g.drawLine( x0, y0, x0, y0);
}
}
else{
p = 2*dx - dy;
incE = 2*dx;
incNE = 2*(dx-dy);
while (y != y1){
y = y + stepy;
if (p < 0){
p = p + incE;
}
else {
x = x + stepx;
p = p + incNE;
}
g.drawLine( x0, y0, x0, y0);
}
}
}