Ik vraag me af of er een funciton is in Java die een lijn van de coördinaten (X1, X2) naar (Y1, Y2) kan tekenen?
Wat ik wil is om zoiets te doen:
drawLine(x1, x2, x3, x4);
En ik wil het op elk moment in de code kunnen doen, waardoor verschillende regels tegelijk worden weergegeven.
Ik heb geprobeerd dit te doen:
public void paint(Graphics g){
g.drawLine(0, 0, 100, 100);
}
Maar dit geeft me geen controle over wanneer de functie wordt gebruikt en ik kan niet achterhalen hoe u het meerdere keren kunt noemen.
Ik hoop dat je begrijpt wat ik bedoel!
P.S. Ik wil een coördinatensysteem maken met veel coördinaten.
Antwoord 1, Autoriteit 100%
Een heel eenvoudig voorbeeld van een swingcomponent om lijnen te tekenen. Het houdt intern een lijst met de regels die zijn toegevoegd met de methode-addline. Telkens wanneer een nieuwe regel wordt toegevoegd, wordt opnieuw gevorderd om de grafische subsytem te informeren dat een nieuwe verf vereist is.
De klas bevat ook een aantal voorbeelden van gebruik.
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.LinkedList;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class LinesComponent extends JComponent{
private static class Line{
final int x1;
final int y1;
final int x2;
final int y2;
final Color color;
public Line(int x1, int y1, int x2, int y2, Color color) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
this.color = color;
}
}
private final LinkedList<Line> lines = new LinkedList<Line>();
public void addLine(int x1, int x2, int x3, int x4) {
addLine(x1, x2, x3, x4, Color.black);
}
public void addLine(int x1, int x2, int x3, int x4, Color color) {
lines.add(new Line(x1,x2,x3,x4, color));
repaint();
}
public void clearLines() {
lines.clear();
repaint();
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
for (Line line : lines) {
g.setColor(line.color);
g.drawLine(line.x1, line.y1, line.x2, line.y2);
}
}
public static void main(String[] args) {
JFrame testFrame = new JFrame();
testFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
final LinesComponent comp = new LinesComponent();
comp.setPreferredSize(new Dimension(320, 200));
testFrame.getContentPane().add(comp, BorderLayout.CENTER);
JPanel buttonsPanel = new JPanel();
JButton newLineButton = new JButton("New Line");
JButton clearButton = new JButton("Clear");
buttonsPanel.add(newLineButton);
buttonsPanel.add(clearButton);
testFrame.getContentPane().add(buttonsPanel, BorderLayout.SOUTH);
newLineButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
int x1 = (int) (Math.random()*320);
int x2 = (int) (Math.random()*320);
int y1 = (int) (Math.random()*200);
int y2 = (int) (Math.random()*200);
Color randomColor = new Color((float)Math.random(), (float)Math.random(), (float)Math.random());
comp.addLine(x1, y1, x2, y2, randomColor);
}
});
clearButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
comp.clearLines();
}
});
testFrame.pack();
testFrame.setVisible(true);
}
}
Antwoord 2, autoriteit 28%
Sla de regels op in een soort lijst. Als het tijd is om ze te schilderen, herhaal je de lijst en teken je ze allemaal. Zoals dit:
Screenshot
DrawLines
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.geom.Line2D;
import javax.swing.JOptionPane;
import javax.swing.JComponent;
import javax.swing.SwingUtilities;
import java.util.ArrayList;
import java.util.Random;
class DrawLines {
public static void main(String[] args) {
Runnable r = new Runnable() {
public void run() {
LineComponent lineComponent = new LineComponent(400,400);
for (int ii=0; ii<30; ii++) {
lineComponent.addLine();
}
JOptionPane.showMessageDialog(null, lineComponent);
}
};
SwingUtilities.invokeLater(r);
}
}
class LineComponent extends JComponent {
ArrayList<Line2D.Double> lines;
Random random;
LineComponent(int width, int height) {
super();
setPreferredSize(new Dimension(width,height));
lines = new ArrayList<Line2D.Double>();
random = new Random();
}
public void addLine() {
int width = (int)getPreferredSize().getWidth();
int height = (int)getPreferredSize().getHeight();
Line2D.Double line = new Line2D.Double(
random.nextInt(width),
random.nextInt(height),
random.nextInt(width),
random.nextInt(height)
);
lines.add(line);
repaint();
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(Color.white);
g.fillRect(0, 0, getWidth(), getHeight());
Dimension d = getPreferredSize();
g.setColor(Color.black);
for (Line2D.Double line : lines) {
g.drawLine(
(int)line.getX1(),
(int)line.getY1(),
(int)line.getX2(),
(int)line.getY2()
);
}
}
}
Antwoord 3, autoriteit 8%
Je moet een klasse maken die Component uitbreidt. Daar kunt u de verfmethode overschrijven en uw verfcode invoeren in:
package blah.whatever;
import java.awt.Component;
import java.awt.Graphics;
public class TestAWT extends Component {
/** @see java.awt.Component#paint(java.awt.Graphics) */
@Override
public void paint(Graphics g) {
super.paint(g);
g.drawLine(0,0,100,100);
g.drawLine(10, 10, 20, 300);
// more drawing code here...
}
}
Zet dit onderdeel in de GUI van uw applicatie. Als je Swing gebruikt, moet je in plaats daarvan JComponent uitbreiden en paintComponent overschrijven.
Zoals Helios al zei, vertelt de verfcode het systeem hoe je component eruitziet. Het systeem zal om deze informatie vragen (roep uw verfcode op) wanneer het denkt dat het (opnieuw) geverfd moet worden, bijvoorbeeld als een raam voor uw component wordt verplaatst.
Antwoord 4, autoriteit 3%
In je klas zou je het volgende moeten hebben:
public void paint(Graphics g){
g.drawLine(x1, y1, x2, y2);
}
Vervolgens in code, indien nodig, verander je x1, y1, x2, y2 en roep je repaint();aan.
Antwoord 5, autoriteit 3%
Ik begrijp dat je Java AWT API gebruikt om te tekenen. De verfmethode wordt aangeroepen wanneer de besturing opnieuw moet worden geverfd. En ik ben er vrij zeker van dat het in het grafische argument aangeeft welke rechthoek degene is die opnieuw moet worden geverfd (om te voorkomen dat alles opnieuw wordt getekend).
Dus als je een vaste afbeelding presenteert, teken je gewoon wat je nodig hebt in die methode.
Als je aan het animeren bent, neem ik aan dat je een bepaald gebied ongeldig kunt maken en dat de verfmethode automatisch wordt aangeroepen. U kunt dus de status wijzigen, de oproep ongeldig maken en deze wordt opnieuw aangeroepen.
Antwoord 6, autoriteit 3%
Om je een idee te geven:
public void paint(Graphics g) {
drawCoordinates(g);
}
private void drawCoordinates(Graphics g) {
// get width & height here (w,h)
// define grid width (dh, dv)
for (int x = 0; i < w; i += dh) {
g.drawLine(x, 0, x, h);
}
for (int y = 0; j < h; j += dv) {
g.drawLine(0, y, w, y);
}
}
Antwoord 7
U kunt de getGraphicsmethode van het onderdeel waarop u wilt tekenen. Dit zou je op zijn beurt in staat moeten stellen lijnen te trekken en andere dingen te maken die beschikbaar zijn via de Graphicsklasse
Antwoord 8
Ik heb een hele reeks methoden gebouwd om punten, lijnen, rechthoeken, cirkels, enz. te tekenen. Ik heb het ontworpen om het venster te behandelen als een stuk ruitjespapier waarbij de oorsprong niet linksboven hoeft te zijn en de y-waarden nemen toe naarmate u omhoog gaat. Zo teken ik lijnen:
public static void drawLine (double x1, double y1, double x2, double y2)
{
((Graphics2D)g).draw(new Line2D.Double(x0+x1*scale, y0-y1*scale, x0+x2*scale, y0-y2*scale));
}
In het bovenstaande voorbeeld vertegenwoordigt (x0, y0)de oorsprong in schermcoördinaten en is scaleeen schaalfactor. De invoerparameters moeten worden opgegeven als grafiekcoördinaten, niet als schermcoördinaten. Er wordt geen repaint()aangeroepen. Je kunt dat opslaan totdat je alle lijnen hebt getekend die je nodig hebt.
Het komt me voor dat iemand misschien niet in termen van ruitjespapier wil denken:
((Graphics2D)g).draw(new Line2D.Double(x1, y1, x2, y2));
Let op het gebruik van Graphics2D. Dit stelt ons in staat om een Line2Dobject te tekenen met doubles in plaats van ints. Naast andere vormen biedt mijn klas ondersteuning voor 3D-perspectieftekenen en verschillende gemaksmethoden (zoals het tekenen van een cirkel gecentreerd op een bepaald punt met een straal). Als iemand geïnteresseerd is, zou ik graag meer van deze klas willen delen.
Antwoord 9
a simple line , after that you can see also a doted line
import java.awt.*;
import javax.swing.*;
import java.awt.Graphics.*;
import java.awt.Graphics2D.*;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.BasicStroke;
import java.awt.Event.*;
import java.awt.Component.*;
import javax.swing.SwingUtilities;
/**
*
* @author junaid
*/
public class JunaidLine extends JPanel{
//private Graphics Graphics;
private void doDrawing(Graphics g){
Graphics2D g2d=(Graphics2D) g;
float[] dash1 = {2f,0f,2f};
g2d.drawLine(20, 40, 250, 40);
BasicStroke bs1 = new BasicStroke(1,BasicStroke.CAP_BUTT,
BasicStroke.JOIN_ROUND,1.0f,dash1,2f);
g2d.setStroke(bs1);
g2d.drawLine(20, 80, 250, 80);
}
@Override
public void paintComponent(Graphics g){
super.paintComponent( g);
doDrawing(g);
}
}
class BasicStrokes extends JFrame{
public BasicStrokes(){
initUI();
}
private void initUI(){
setTitle("line");
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
add(new JunaidLine());
setSize(280,270);
setLocationRelativeTo(null);
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable(){
@Override
public void run(){
BasicStrokes bs = new BasicStrokes();
bs.setVisible(true);
}
});
}
}
Antwoord 10
Om je oorspronkelijke vraag te beantwoorden, is het (x1, y1)tot (x2, y2).
Bijvoorbeeld
Dit is om een horizontale lijn te tekenen:
g.drawLine( 10, 30, 90, 30 );
vs
Dit is om een verticale lijn te tekenen:
g.drawLine( 10, 30, 10, 90 );
Ik hoop dat het helpt.