Universidad Tecnológica de Honduras

Asignatura
Programación avanzada I

Catedrático
PhD. Carlos Hugo Estrada

Alumno
Marco Antonio Vásquez Mendoza

Número de Cuenta:
202220110037

Tarea:
Ejercicios de clase y asignaciones

Fecha de límite entrega:

16 de marzo de 2024
import javax.swing.*;
import java.awt.*;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;

public class Tren extends JFrame {

public Tren() {
setTitle("Tren en Java");
setSize(800, 600);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);

TrenPanel TrenPanel = new TrenPanel();

add(TrenPanel);

setVisible(true);
}

public static void main(String[] args) {

SwingUtilities.invokeLater(() -> new Tren());
}
}

import javax.swing.*;
import java.awt.*;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;

class TrenPanel extends JPanel {

@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
 Graphics2D g2d = (Graphics2D) g;
g2d.setColor(new Color(135, 206, 250)); // Color celeste para el fondo
g2d.fillRect(0, 0, getWidth(), getHeight());

// Rectangulo que simula la calle

Rectangle calle = new Rectangle(0, 395, getWidth(), getHeight());
g2d.setColor(new Color(0, 205, 0)); // Color verde para la calle
g2d.fill(calle);
g2d.setColor(Color.BLACK);
g2d.draw(calle);

int arbolX = -30; // Posición X del árbol

int arbolY = 210; // Posición Y del árbol
int arbol2X = -30;
int arbol2Y = 280;

// Triángulo superior
int[] xPointsSuperior = {arbolX, arbolX + 40, arbolX + 80}; // Coordenadas X del
triángulo superior
int[] yPointsSuperior = {arbolY, arbolY - 100, arbolY}; // Coordenadas Y del
triángulo superior
Polygon trianguloSuperior = new Polygon(xPointsSuperior, yPointsSuperior, 3);
g2d.setColor(new Color(34, 139, 34)); // Color verde oscuro para la copa del
árbol
g2d.fill(trianguloSuperior);

// Triángulo inferior
int[] xPointsSuperiorr = {arbol2X, arbol2X + 40, arbol2X + 80}; // Coordenadas X
del triángulo superior
int[] yPointsSuperiorr = {arbol2Y, arbol2Y - 100, arbol2Y}; // Coordenadas Y del
triángulo superior
Polygon trianguloSuperiorr = new Polygon(xPointsSuperiorr, yPointsSuperiorr,
3);
g2d.setColor(new Color(34, 139, 34)); // Color verde oscuro para la copa del
árbol
g2d.fill(trianguloSuperiorr);

int trenX = 200; // Posición inicial del tren en X

int trenY = 300; // Posición inicial del tren en Y
int vagonWidth = 100; // Ancho de cada vagón (aumentado)
int vagonHeight = 80; // Altura de cada vagón (aumentado)
int vagonSeparation = 20; // Separación entre vagones

// Cabina del tren

Rectangle cabina = new Rectangle(220, 230, 80, 150);
 g2d.setColor(new Color(255, 102, 0));
g2d.fill(cabina);
g2d.setColor(Color.BLACK);
g2d.draw(cabina);

// Dibujar los 3 vagones del tren

for (int i = 0; i < 3; i++) {
int vagonX = trenX + (vagonWidth + vagonSeparation) * (i + 1);
Rectangle vagon = new Rectangle(vagonX, trenY, vagonWidth,
vagonHeight);
g2d.setColor(new Color(204, 0, 0));
g2d.fill(vagon);
g2d.setColor(Color.BLACK);
g2d.draw(vagon);
}

// Union 1
int roadWidth = 20;
int roadHeight = 10;
int roadX = 300;
int roadY = 340;
g2d.setColor(new Color(255, 102, 0));
g2d.fillRect(roadX, roadY, roadWidth, roadHeight);
g2d.setColor(Color.BLACK);
g2d.drawRect(roadX, roadY, roadWidth, roadHeight);

// Union 2
int road2Width = 20;
int road2Height = 10;
int road2X = 420;
int road2Y = 340;
g2d.setColor(new Color(255, 102, 0));
g2d.fillRect(road2X, road2Y, road2Width, road2Height);
g2d.setColor(Color.BLACK);
g2d.drawRect(road2X, road2Y, road2Width, road2Height);

// Union 3
int road3Width = 20;
int road3Height = 10;
int road3X = 540;
int road3Y = 340;
g2d.setColor(new Color(255, 102, 0));
g2d.fillRect(road3X, road3Y, road3Width, road3Height);
g2d.setColor(Color.BLACK);
g2d.drawRect(road3X, road3Y, road3Width, road3Height);

// Cabina
int CabinaWidth = 100;
int CabinaHeight = 80;
int CabinaX = 120;
int CabinaY = 300;
g2d.setColor(new Color(255, 102, 0));
g2d.fillRect(CabinaX, CabinaY, CabinaWidth, CabinaHeight);
g2d.setColor(Color.BLACK);
g2d.drawRect(CabinaX, CabinaY, CabinaWidth, CabinaHeight);

// Ventana
int VentanaWidth = 70;
int VentanaHeight = 50;
int VentanaX = 225;
int VentanaY = 250;
g2d.setColor(new Color(51, 51, 51));
g2d.fillRect(VentanaX, VentanaY, VentanaWidth, VentanaHeight);
g2d.setColor(Color.BLACK);
g2d.drawRect(VentanaX, VentanaY, VentanaWidth, VentanaHeight);

// Borde 1
int BordeWidth = 100;
int BordeHeight = 20;
int BordeX = 210;
int BordeY = 220;
g2d.setColor(new Color(204, 0, 0));
g2d.fillRect(BordeX, BordeY, BordeWidth, BordeHeight);
g2d.setColor(Color.BLACK);
g2d.drawRect(BordeX, BordeY, BordeWidth, BordeHeight);

// Tapa
int TapaWidth = 20;
int TapaHeight = 80;
int TapaX = 140;
int TapaY = 220;
g2d.setColor(new Color(204, 0, 0));
g2d.fillRect(TapaX, TapaY, TapaWidth, TapaHeight);
g2d.setColor(Color.BLACK);
g2d.drawRect(TapaX, TapaY, TapaWidth, TapaHeight);

// Borde tapa
int BordetWidth = 30;
int BordetHeight = 20;
int BordetX = 135;
int BordetY = 220;
g2d.setColor(new Color(255, 102, 0));
g2d.fillRect(BordetX, BordetY, BordetWidth, BordetHeight);
g2d.setColor(Color.BLACK);
g2d.drawRect(BordetX, BordetY, BordetWidth, BordetHeight);

// Tapa vagon 1
int Tapav1Width = 110;
int Tapav1Height = 20;
int Tapav1X = 315;
int Tapav1Y = 280;
g2d.setColor(new Color(255, 102, 0));
g2d.fillRect(Tapav1X, Tapav1Y, Tapav1Width, Tapav1Height);
g2d.setColor(Color.BLACK);
g2d.drawRect(Tapav1X, Tapav1Y, Tapav1Width, Tapav1Height);

// Tapa vagon 2
int Tapav2Width = 110;
int Tapav2Height = 20;
int Tapav2X = 435;
int Tapav2Y = 280;
g2d.setColor(new Color(255, 102, 0));
g2d.fillRect(Tapav2X, Tapav2Y, Tapav2Width, Tapav2Height);
g2d.setColor(Color.BLACK);
g2d.drawRect(Tapav2X, Tapav2Y, Tapav2Width, Tapav2Height);

// Tapa vagon 3
int Tapav3Width = 110;
int Tapav3Height = 20;
int Tapav3X = 555;
int Tapav3Y = 280;
g2d.setColor(new Color(255, 102, 0));
g2d.fillRect(Tapav3X, Tapav3Y, Tapav3Width, Tapav3Height);
g2d.setColor(Color.BLACK);
g2d.drawRect(Tapav3X, Tapav3Y, Tapav3Width, Tapav3Height);

// Triángulo al lado izquierdo de la cabina

int[] xPoints = {120, 120, 40}; // Coordenadas X de los vértices del triángulo
int[] yPoints = {330, 380, 380}; // Coordenadas Y de los vértices del triángulo
Polygon triangulo = new Polygon(xPoints, yPoints, 3);
g2d.setColor(new Color(204, 0, 0));
g2d.fill(triangulo);
g2d.setColor(Color.BLACK);
g2d.draw(triangulo);

// circulo dentro de primer vagon

g2d.setColor(Color.YELLOW);
int sunRadius = 35;
int sunX = 336;
int sunY = 305;
g2d.fillOval(sunX, sunY, sunRadius * 2, sunRadius * 2);
// Rectangulo dentro del segundo vagon
int rWidth = 80;
int rHeight = 40;
int rX = 450;
int rY = 320;
g2d.setColor(new Color(0, 0, 255));
g2d.fillRect(rX, rY, rWidth, rHeight);
g2d.setColor(Color.BLACK);
g2d.drawRect(rX, rY, rWidth, rHeight);

//Ruedas
g2d.setColor(Color.YELLOW);
int r1Radius = 20;
int r1X = 120;
int r1Y = 370;
g2d.fillOval(r1X, r1Y, r1Radius * 2, r1Radius * 2);
g2d.setColor(Color.BLACK); // Borde negro
g2d.drawOval(r1X, r1Y, r1Radius * 2, r1Radius * 2);

g2d.setColor(Color.YELLOW);
int r2Radius = 20;
int r2X = 170;
int r2Y = 370;
g2d.fillOval(r2X, r2Y, r2Radius * 2, r2Radius * 2);
g2d.setColor(Color.BLACK); // Borde negro
g2d.drawOval(r2X, r2Y, r2Radius * 2, r2Radius * 2);

g2d.setColor(Color.YELLOW);
int r3Radius = 30;
int r3X = 230;
int r3Y = 355;
g2d.fillOval(r3X, r3Y, r3Radius * 2, r3Radius * 2);
g2d.setColor(Color.BLACK); // Borde negro
g2d.drawOval(r3X, r3Y, r3Radius * 2, r3Radius * 2);

g2d.setColor(Color.YELLOW);
int r4Radius = 20;
int r4X = 320;
int r4Y = 370;
g2d.fillOval(r4X, r4Y, r4Radius * 2, r4Radius * 2);
g2d.setColor(Color.BLACK); // Borde negro
g2d.drawOval(r4X, r4Y, r4Radius * 2, r4Radius * 2);

g2d.setColor(Color.YELLOW);
int r5Radius = 20;
int r5X = 380;
 int r5Y = 370;
g2d.fillOval(r5X, r5Y, r5Radius * 2, r5Radius * 2);
g2d.setColor(Color.BLACK); // Borde negro
g2d.drawOval(r5X, r5Y, r5Radius * 2, r5Radius * 2);

g2d.setColor(Color.YELLOW);
int r6Radius = 20;
int r6X = 440;
int r6Y = 370;
g2d.fillOval(r6X, r6Y, r6Radius * 2, r6Radius * 2);
g2d.setColor(Color.BLACK); // Borde negro
g2d.drawOval(r6X, r6Y, r6Radius * 2, r6Radius * 2);

g2d.setColor(Color.YELLOW);
int r7Radius = 20;
int r7X = 500;
int r7Y = 370;
g2d.fillOval(r7X, r7Y, r7Radius * 2, r7Radius * 2);
g2d.setColor(Color.BLACK); // Borde negro
g2d.drawOval(r7X, r7Y, r7Radius * 2, r7Radius * 2);

g2d.setColor(Color.YELLOW);
int r8Radius = 20;
int r8X = 560;
int r8Y = 370;
g2d.fillOval(r8X, r8Y, r8Radius * 2, r8Radius * 2);
g2d.setColor(Color.BLACK); // Borde negro
g2d.drawOval(r8X, r8Y, r8Radius * 2, r8Radius * 2);

g2d.setColor(Color.YELLOW);
int r9Radius = 20;
int r9X = 620;
int r9Y = 370;
g2d.fillOval(r9X, r9Y, r9Radius * 2, r9Radius * 2);
g2d.setColor(Color.BLACK); // Borde negro
g2d.drawOval(r9X, r9Y, r9Radius * 2, r9Radius * 2);

int hexagonSize = 35;

int hexagonX = 612;
int hexagonY = 340;
Polygon hexagon = createHexagon(hexagonX, hexagonY, hexagonSize);
g2d.setColor(new Color(0, 153, 0)); //
g2d.fill(hexagon);
g2d.setColor(Color.BLACK);
g2d.draw(hexagon);
}
 private Polygon createHexagon(int x, int y, int size) {
Polygon hexagon = new Polygon();
for (int i = 0; i < 6; i++) {
double angle = 2 * Math.PI / 6 * i;
int xPos = x + (int) (size * Math.cos(angle));
int yPos = y + (int) (size * Math.sin(angle));
hexagon.addPoint(xPos, yPos);
}
return hexagon;
}
}
import javax.swing.JFrame;

public class MostrarColores {

public static void main(String[] args) {
JFrame frame = new JFrame("Uso de colores");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JPanelColor jPanelColor = new JPanelColor();

frame.add(jPanelColor);

frame.setSize(400, 180);
frame.setVisible(true);
}
}

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;

public class JPanelColor extends JPanel {

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
this.setBackground(Color.WHITE);

g.setColor(new Color(255, 0, 0));

g.fillRect(15, 25, 100, 20);
g.setColor(Color.GREEN);
 g.drawOval(15, 25, 100, 20); // Ovalo dentro del primer rectángulo
g.drawString("RGB actual: " + g.getColor(), 130, 40);

g.setColor(new Color(0.50f, 0.75f, 0.0f));

g.fillRect(15, 50, 100, 20);
g.setColor(Color.YELLOW);
g.drawOval(15, 50, 100, 20); // Ovalo dentro del segundo rectángulo
g.drawString("RGB actual: " + g.getColor(), 130, 65);

g.setColor(Color.BLUE);
g.fillRect(15, 75, 100, 20);
g.setColor(Color.RED);
g.drawOval(15, 75, 100, 20); // Ovalo dentro del tercer rectángulo
g.drawString("RGB actual: " + g.getColor(), 130, 90);

Color color = Color.MAGENTA;

g.setColor(color);
g.fillRect(15, 100, 100, 20);
g.setColor(Color.BLUE);
g.drawOval(15, 100, 100, 20); // Ovalo dentro del cuarto rectángulo
g.drawString("Valores RGB: " + color.getRed() + ", " +
color.getGreen() + ", " + color.getBlue(), 130, 115);

// Rectangulo azul
g.setColor(Color.BLUE);
g.drawRect(5, 10, getWidth() - 17, getHeight() - 30);

// Linea morada
g.setColor(Color.MAGENTA);
g.drawLine(15, 15, getWidth() - 17, 15);

// Linea roja
g.setColor(Color.RED);
g.drawLine(15, 20, getWidth() - 17, 20);
}
import javax.swing.*;
import java.awt.*;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;

public class Camion extends JFrame {

public Camion() {
setTitle("Camión en Java");
setSize(800, 600);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);

CamionPanel camionPanel = new CamionPanel();

add(camionPanel);

setVisible(true);
}

public static void main(String[] args) {

SwingUtilities.invokeLater(() -> new Camion());
}
}
}

import javax.swing.*;
import java.awt.*;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;

class CamionPanel extends JPanel {

@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);

Graphics2D g2d = (Graphics2D) g;

g2d.setColor(new Color(135, 206, 250)); // RGB para el color celeste
g2d.fillRect(0, 0, getWidth(), getHeight());

// Obtener el tamaño de la ventana

int windowWidth = getWidth();
int windowHeight = getHeight();

// Calcular la posición central del camión

int camionWidth = 400; // Ancho total del camión
int camionHeight = 230; // Altura total del camión
int camionX = (windowWidth - camionWidth) / 2;
int camionY = (windowHeight - camionHeight) / 2;

// Cuerpo del camión (rectángulo blanco)

Rectangle cuerpo = new Rectangle(camionX + 50, camionY + 100, 200, 100);
g2d.setColor(Color.WHITE);
g2d.fill(cuerpo);
g2d.setColor(Color.BLACK);
g2d.draw(cuerpo);

// Cabina del camión (rectángulo azul con techo rojo)

Rectangle cabina = new Rectangle(camionX + 250, camionY + 100, 70, 100);
g2d.setColor(Color.BLUE);
g2d.fill(cabina);
g2d.setColor(Color.BLACK);
g2d.draw(cabina);

// Techo rojo simétrico

int techoWidth = 70;
int techoHeight = 30;
int techoX = camionX + 250 + (cabina.width - techoWidth) / 2;
int techoY = camionY + 100;

GeneralPath techo = new GeneralPath();

techo.moveTo(techoX, techoY);
techo.lineTo(techoX + techoWidth, techoY);
techo.lineTo(techoX + techoWidth / 2, techoY - techoHeight);
techo.closePath();
 g2d.setColor(Color.RED);
g2d.fill(techo);
g2d.setColor(Color.BLACK);
g2d.draw(techo);

// Ruedas traseras (círculos negros)

Ellipse2D ruedaTraseraIzquierda = new Ellipse2D.Double(camionX + 60, camionY + 200, 30, 30);
g2d.setColor(Color.BLACK);
g2d.fill(ruedaTraseraIzquierda);
g2d.draw(ruedaTraseraIzquierda);

Ellipse2D ruedaTraseraDerecha = new Ellipse2D.Double(camionX + 95, camionY + 200, 30, 30);

g2d.setColor(Color.BLACK);
g2d.fill(ruedaTraseraDerecha);
g2d.draw(ruedaTraseraDerecha);

// Ruedas delanteras (círculos negros)

Ellipse2D ruedaDelanteraIzquierda = new Ellipse2D.Double(camionX + 180, camionY + 200, 30,
30);
g2d.setColor(Color.BLACK);
g2d.fill(ruedaDelanteraIzquierda);
g2d.draw(ruedaDelanteraIzquierda);

Ellipse2D ruedaDelanteraDerecha = new Ellipse2D.Double(camionX + 215, camionY + 200, 30,

30);
g2d.setColor(Color.BLACK);
g2d.fill(ruedaDelanteraDerecha);
g2d.draw(ruedaDelanteraDerecha);

Ellipse2D ruedaDelanteraDerecha2 = new Ellipse2D.Double(camionX + 335, camionY + 200, 30,

30);
g2d.setColor(Color.BLACK);
g2d.fill(ruedaDelanteraDerecha2);
g2d.draw(ruedaDelanteraDerecha2);

// Cuadrado al lado derecho de la cabina

Rectangle cuadrado = new Rectangle(camionX + 320, camionY + 140, 50, 60);
g2d.setColor(Color.BLUE);
g2d.fill(cuadrado);
g2d.setColor(Color.BLACK);
g2d.draw(cuadrado);

// Triángulo justo arriba del cuadrado

int[] xPointsTriangulo = {camionX + 320, camionX + 345, camionX + 370};
int[] yPointsTriangulo = {camionY + 140, camionY + 100, camionY + 140};
GeneralPath triangulo = new GeneralPath();
triangulo.moveTo(xPointsTriangulo[0], yPointsTriangulo[0]);
for (int i = 1; i < xPointsTriangulo.length; i++) {
 triangulo.lineTo(xPointsTriangulo[i], yPointsTriangulo[i]);
}
triangulo.closePath();

g2d.setColor(Color.PINK);
g2d.fill(triangulo);
g2d.setColor(Color.BLACK);
g2d.draw(triangulo);

// Cuadrado dentro de la cabina

int cuadradoDentroX = camionX + 255;
int cuadradoDentroY = camionY + 110;
int cuadradoDentroWidth = 60;
int cuadradoDentroHeight = 80;

Rectangle cuadradoDentro = new Rectangle(camionX + 260, camionY + 110, 50, 30);

g2d.setColor(new Color(51, 204, 255));
g2d.fill(cuadradoDentro);
g2d.setColor(Color.BLACK);
g2d.draw(cuadradoDentro);

Rectangle cuadradoDentro2 = new Rectangle(camionX + 260, camionY + 155, 50, 40);

g2d.setColor(new Color(0, 102, 0));
g2d.fill(cuadradoDentro2);
g2d.setColor(Color.BLACK);
g2d.draw(cuadradoDentro2);

// Rectángulo que simula la calle

Rectangle calle = new Rectangle(0, 395, getWidth(), getHeight() );
g2d.setColor(Color.GRAY);
g2d.fill(calle);
g2d.setColor(Color.BLACK);
g2d.draw(calle);

// Triángulo girado con la parte puntiaguda hacia la derecha

int[] xPointsTrianguloDerecha = {camionX + 420, camionX + 370, camionX + 420}; //
Coordenadas x del triángulo girado
int[] yPointsTrianguloDerecha = {camionY + 140, camionY + 170, camionY + 200}; //
Coordenadas y del triángulo girado
GeneralPath trianguloDerecha = new GeneralPath();
trianguloDerecha.moveTo(xPointsTrianguloDerecha[0], yPointsTrianguloDerecha[0]);
for (int i = 1; i < xPointsTrianguloDerecha.length; i++) {
trianguloDerecha.lineTo(xPointsTrianguloDerecha[i], yPointsTrianguloDerecha[i]);
}
trianguloDerecha.closePath();
g2d.setColor(Color.ORANGE);
g2d.fill(trianguloDerecha);
g2d.setColor(Color.BLACK);
 g2d.draw(trianguloDerecha);
}
}

import javax.swing.*;
import java.awt.*;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;

public class Casa extends JFrame {

public Casa() {
setTitle("Tren en Java");
setSize(900, 600);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);

CasaPanel CasaPanel = new CasaPanel();

add(CasaPanel);

setVisible(true);
}

public static void main(String[] args) {

SwingUtilities.invokeLater(() -> new Casa());
}
}

import javax.swing.*;
import java.awt.*;
class CasaPanel extends JPanel {
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);

Graphics2D g2d = (Graphics2D) g;

g2d.setColor(new Color(135, 206, 250)); // Color celeste para el fondo
g2d.fillRect(0, 0, getWidth(), getHeight());

Rectangle calle = new Rectangle(0, 395, getWidth(), getHeight());

g2d.setColor(new Color(0, 153, 0)); // Color verde para la calle
g2d.fill(calle);

// TRONCO DE ARBOL
g2d.setColor(new Color(139, 69, 19));
int trunkWidth = 30;
int trunkHeight = 200;
int trunkX = 510;
int trunkY = 196;
g2d.fillRect(trunkX, trunkY, trunkWidth, trunkHeight);

//SOL
g2d.setColor(Color.YELLOW);
int sunRadius = 40;
int sunX = 20;
int sunY = 20;
g2d.fillOval(sunX, sunY, sunRadius * 2, sunRadius * 2);

// HOJAS TRIÁNGULO
g2d.setColor(new Color(0,204, 0));
int[] xPoints = {440, 535, 620};
int[] yPoints = {200, 50, 200};
Polygon triangle = new Polygon(xPoints, yPoints, 3);
g2d.fill(triangle);

// TRONCO DE ARBOL ROMBO

g2d.setColor(new Color(139, 69, 19));
int trunk2Width = 30;
int trunk2Height = 90;
int trunk2X = 650;
int trunk2Y = 306;
g2d.fillRect(trunk2X, trunk2Y, trunk2Width, trunk2Height);

// HOJAS ROMBO
int diamondWidth = 120;
int diamondHeight = 150;
int xOffset = 65;
 int yOffset = -60;
int[] xPointss = {600 - diamondWidth / 2 + xOffset, 600 + xOffset, 600 + diamondWidth / 2 +
xOffset, 600 + xOffset}; // Coordenadas X de los vértices del rombo
int[] yPointss = {322 + yOffset, 322 - diamondHeight / 2 + yOffset, 322 + yOffset, 322 +
diamondHeight / 2 + yOffset}; // Coordenadas Y de los vértices del rombo
Polygon diamond = new Polygon(xPointss, yPointss, 4);
g2d.setColor(new Color(0, 128, 0));
g2d.fill(diamond);

// TRONCO DE ARBOL PENTAGONO

g2d.setColor(new Color(139, 69, 19));
int trunk4Width = 30;
int trunk4Height = 200;
int trunk4X = 750;
int trunk4Y = 196;
g2d.fillRect(trunk4X, trunk4Y, trunk4Width, trunk4Height);

// PENTÁGONO ARBOL
g2d.setColor(new Color(139, 69, 19));
int trunk3Width = 30;
int trunk3Height = 200;
int trunk3X = 750;
int trunk3Y = 136; // Ajuste para subir el pentágono
g2d.fillRect(trunk3X, trunk3Y, trunk3Width, trunk3Height);
int sideLength = 100; // Longitud de un lado del pentágono
int[] xPointsCentral = {
trunk3X + trunkWidth / 2,
trunk3X + trunkWidth / 2 + (int) (sideLength * Math.cos(Math.toRadians(18))),
trunk3X + trunkWidth / 2 + (int) (sideLength * Math.cos(Math.toRadians(54))),
trunk3X + trunkWidth / 2 - (int) (sideLength * Math.cos(Math.toRadians(54))),
trunk3X + trunkWidth / 2 - (int) (sideLength * Math.cos(Math.toRadians(18)))
}; // Coordenadas X de los vértices del pentágono
int[] yPointsCentral = {
trunk3Y - 20 - (int) (sideLength * Math.sin(Math.toRadians(18))),
trunk3Y - 20 - (int) (sideLength * Math.sin(Math.toRadians(18))),
trunk3Y - 20 + (int) (sideLength * Math.sin(Math.toRadians(54))),
trunk3Y - 20 + (int) (sideLength * Math.sin(Math.toRadians(54))),
trunk3Y - 20 - (int) (sideLength * Math.sin(Math.toRadians(18)))
}; // Coordenadas Y de los vértices del pentágono
Polygon pentagonCentral = new Polygon(xPointsCentral, yPointsCentral, 5); // Crear un polígono
con los vértices del pentágono
g2d.setColor(new Color(113, 226, 48)); // Verde oscuro para las hojas
g2d.fill(pentagonCentral); // Rellenar el pentágono

// TALLOS DE FLOR
g2d.setColor(new Color(139, 69, 19));
int trunk5Width = 3;
int trunk5Height = 70;
int trunk5X = 50;
int trunk5Y = 438;
g2d.fillRect(trunk5X, trunk5Y, trunk5Width, trunk5Height);

g2d.setColor(new Color(139, 69, 19));

int trunk6Width = 3;
int trunk6Height = 40;
int trunk6X = 110;
int trunk6Y = 433;
g2d.fillRect(trunk6X, trunk6Y, trunk6Width, trunk6Height);

g2d.setColor(new Color(139, 69, 19));

int trunk7Width = 3;
int trunk7Height = 50;
int trunk7X = 168;
int trunk7Y = 433;
g2d.fillRect(trunk7X, trunk7Y, trunk7Width, trunk7Height);

g2d.setColor(new Color(139, 69, 19));

int trunk8Width = 3;
int trunk8Height = 61;
int trunk8X = 705;
int trunk8Y = 433;
g2d.fillRect(trunk8X, trunk8Y, trunk8Width, trunk8Height);

g2d.setColor(new Color(139, 69, 19));

int trunk9Width = 3;
int trunk9Height = 48;
int trunk9X = 765;
int trunk9Y = 433;
g2d.fillRect(trunk9X, trunk9Y, trunk9Width, trunk9Height);

g2d.setColor(new Color(139, 69, 19));

int trunk10Width = 3;
int trunk10Height = 55;
int trunk10X = 825;
int trunk10Y = 433;
g2d.fillRect(trunk10X, trunk10Y, trunk10Width, trunk10Height);

int flowerSize = 20;

// Posición de la primera flor en el eje X y en el eje Y
int flowerPosX = trunk5X + trunk5Width / 2; // Posición inicial en X de la primera flor
int flowerPosY = trunk5Y - flowerSize / 2 - 10; // Posición inicial en Y de la primera flor

// FLOR HEXÁGONO
drawFlower(g2d, flowerPosX, flowerPosY, flowerSize);

// Posición de la segunda flor en el eje X y en el eje Y

 int flower2PosX = flowerPosX + flowerSize * 3; // Posición inicial en X de la segunda flor
int flower2PosY = flowerPosY; // Posición inicial en Y de la segunda flor

// FLOR HEXÁGONO
drawFlower(g2d, flower2PosX, flower2PosY, flowerSize);

// Posición de la tercera flor en el eje X y en el eje Y

int flower3PosX = flower2PosX + flowerSize * 3; // Posición inicial en X de la tercera flor
int flower3PosY = flowerPosY; // Posición inicial en Y de la tercera flor

// FLOR HEXÁGONO
drawFlower(g2d, flower3PosX, flower3PosY, flowerSize);

// Posición de la cuarta flor en el eje X y en el eje Y

int flower4PosX = getWidth() - flowerSize * 3; // Posición inicial en X de la cuarta flor
int flower4PosY = flowerPosY; // Posición inicial en Y de la cuarta flor

// FLOR HEXÁGONO
drawFlower(g2d, flower4PosX, flower4PosY, flowerSize);

// Posición de la quinta flor en el eje X y en el eje Y

int flower5PosX = flower4PosX - flowerSize * 3; // Posición inicial en X de la quinta flor
int flower5PosY = flowerPosY; // Posición inicial en Y de la quinta flor

// FLOR HEXÁGONO
drawFlower(g2d, flower5PosX, flower5PosY, flowerSize);

// Posición de la sexta flor en el eje X y en el eje Y

int flower6PosX = flower5PosX - flowerSize * 3; // Posición inicial en X de la sexta flor
int flower6PosY = flowerPosY; // Posición inicial en Y de la sexta flor

// FLOR HEXÁGONO
drawFlower(g2d, flower6PosX, flower6PosY, flowerSize);
}

private void drawFlower(Graphics2D g2d, int posX, int posY, int size) {
// FLOR HEXÁGONO
int radiusFlower = size; // Radio del círculo exterior de la flor
int[] xPointsFlower = new int[6];
int[] yPointsFlower = new int[6];
for (int i = 0; i < 6; i++) {
double angleRad = Math.toRadians(60 * i);
xPointsFlower[i] = (int) (posX + radiusFlower * Math.cos(angleRad));
yPointsFlower[i] = (int) (posY + radiusFlower * Math.sin(angleRad));
}
g2d.setColor(new Color(255, 51, 153)); // Color amarillo para los pétalos
g2d.fillPolygon(xPointsFlower, yPointsFlower, 6); // Rellenar el hexágono exterior
// Posición del hexágono interior en el eje X y en el eje Y
int innerPosX = posX; // Posición en X del hexágono interior
int innerPosY = posY; // Posición en Y del hexágono interior

// Tamaño del hexágono interior

int innerSize = size / 2;

int[] xPointsInnerFlower = new int[6];

int[] yPointsInnerFlower = new int[6];
for (int i = 0; i < 6; i++) {
double angleRad = Math.toRadians(60 * i + 30); // Ajuste para desplazar los pétalos
xPointsInnerFlower[i] = (int) (innerPosX + innerSize * Math.cos(angleRad));
yPointsInnerFlower[i] = (int) (innerPosY + innerSize * Math.sin(angleRad));
}
g2d.setColor(new Color(255, 255, 0)); // Color rojo para el círculo interior
g2d.fillPolygon(xPointsInnerFlower, yPointsInnerFlower, 6); // Rellenar el hexágono interior

// CASA
g2d.setColor(new Color(255, 204, 0));
int houseWidth = 330;
int houseHeight = 150;
int houseX = 70;
int houseY = 245;
g2d.fillRect(houseX, houseY, houseWidth, houseHeight);

g2d.setColor(new Color(255, 102, 0));

int w1Width = 60;
int w1Height = 60;
int w1X = 110;
int w1Y = 280;
g2d.fillRect(w1X, w1Y, w1Width, w1Height);

g2d.setColor(new Color(255, 102, 0));

int w2Width = 60;
int w2Height = 60;
int w2X = 298;
int w2Y = 280;
g2d.fillRect(w2X, w2Y, w2Width, w2Height);

g2d.setColor(new Color(255, 102, 0));

int dWidth = 60;
int dHeight = 90;
int dX = 204;
int dY = 305;
g2d.fillRect(dX, dY, dWidth, dHeight);

// PENTÁGONO TECHO
 g2d.setColor(new Color(153, 102, 0)); // Color naranja para el techo
int roofWidth = 200;
int roofHeight = 100;
int roofX = 132;
int roofY = houseY - houseHeight + 60; // Ajuste para bajar más el techo
int[] xPointsRoof = {
roofX,
roofX + roofWidth,
roofX + roofWidth + roofWidth / 2,
roofX - roofWidth / 2,
roofX
}; // Coordenadas X de los vértices del pentágono
int[] yPointsRoof = {
roofY,
roofY,
roofY + roofHeight,
roofY + roofHeight,
roofY
}; // Coordenadas Y de los vértices del pentágono
Polygon pentagonRoof = new Polygon(xPointsRoof, yPointsRoof, 5); // Crear un polígono con los
vértices del pentágono
g2d.fill(pentagonRoof); // Rellenar el pentágono
}
}
import javax.swing.JFrame;

public class DibujarArcos {

// ejecuta la aplicación
public static void main(String[] args) {
// crea marco para ArcosJPanel
JFrame marco = new JFrame("Dibujo de arcos"); // Cambié las comillas aquí
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

ArcosJPanel arcosJPanel = new ArcosJPanel();

marco.add(arcosJPanel);
marco.setSize(300, 210);
marco.setVisible(true);
}
}

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;

public class ArcosJPanel extends JPanel {

// dibuja rectángulos y arcos

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);

g.setColor(Color.RED);
g.drawRect(15, 35, 80, 80);
 g.setColor(Color.BLACK);
g.drawArc(15, 35, 80, 80, 0, 360);

// empieza en 0 y se extiende hasta 110

g.setColor(Color.RED);
g.drawRect(100, 35, 80, 80);

g.setColor(Color.BLACK);
g.drawArc(100, 35, 80, 80, 0, 110);

// empieza en 0 y se extiende hasta -270 grados

g.setColor(Color.RED);
g.drawRect(185, 35, 80, 80);

g.setColor(Color.BLACK);
g.drawArc(185, 35, 80, 80, 0, -270);

// empieza en 0 y se extiende hasta 360 grados

g.fillArc(15, 120, 80, 40, 0, 360);

// empieza en 270 y se extiende hasta -90 grados

g.fillArc(100, 120, 80, 40, 270, -90);

// empieza en 0 y se extiende hasta -270 grados

g.fillArc(185, 120, 80, 40, 0, -270);
}
}
import javax.swing.JFrame;

public class DibujarPoligonos {

// ejecuta la aplicación
public static void main(String[] args) {
// crea marco para objeto PoligonosJPanel
JFrame marco = new JFrame("Dibujo de poligonos"); // Cambié las comillas aquí
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

PoligonosJPanel poligonosJPanel = new PoligonosJPanel();

marco.add(poligonosJPanel);
marco.setSize(280, 270);
marco.setVisible(true);
}
}

import java.awt.Graphics;
import java.awt.Polygon;
import javax.swing.JPanel;

public class PoligonosJPanel extends JPanel {

// dibuja polígonos y polilíneas

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);

// dibuja polígono con objeto Polygon

int[] valoresX = {20, 40, 50, 30, 20, 15};
 int[] valoresY = {50, 50, 60, 80, 80, 60};
Polygon poligono1 = new Polygon(valoresX, valoresY, 6);
g.drawPolygon(poligono1);

// dibuja polilíneas con dos arreglos

int[] valoresX2 = {70, 90, 100, 80, 70, 65, 60};
int[] valoresY2 = {100, 100, 110, 110, 130, 110, 90};
g.drawPolyline(valoresX2, valoresY2, 7);

// rellena polígono con dos arreglos

int[] valoresX3 = {120, 140, 150, 190};
int[] valoresY3 = {40, 70, 80, 60};
g.fillPolygon(valoresX3, valoresY3, 4);

// dibuja polígono relleno con objeto Polygon

Polygon poligono2 = new Polygon();
poligono2.addPoint(165, 135);
poligono2.addPoint(175, 150);
poligono2.addPoint(270, 200);
poligono2.addPoint(200, 220);
poligono2.addPoint(130, 180);
g.fillPolygon(poligono2);
}
}
import javax.swing.JFrame;

public class Figuras {

public static void main(String[] args) {
JFrame marco = new JFrame("Dibujo de figuras en 2D");
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

FigurasJPanel figurasJPanel = new FigurasJPanel();

marco.add(figurasJPanel);
marco.setSize(425, 200);
marco.setVisible(true);
}
}

import java.awt.Color;
import java.awt.Graphics;
import java.awt.BasicStroke;
import java.awt.GradientPaint;
import java.awt.TexturePaint;
import java.awt.Rectangle;
import java.awt.Graphics2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import java.awt.geom.Arc2D;
import java.awt.geom.Line2D;
import java.awt.image.BufferedImage;
import javax.swing.JPanel;
public class FigurasJPanel extends JPanel {
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g;

g2d.setPaint(new GradientPaint(5, 30, Color.BLUE, 35, 100, Color.YELLOW, true));

g2d.fill(new Ellipse2D.Double(5, 30, 65, 100));

g2d.setPaint(Color.RED);
g2d.setStroke(new BasicStroke(10.0f));
g2d.draw(new Rectangle2D.Double(80, 30, 65, 100));

BufferedImage imagenBuf = new BufferedImage(10, 10, BufferedImage.TYPE_INT_RGB);

Graphics2D gg = imagenBuf.createGraphics();
gg.setColor(Color.YELLOW);
gg.fillRect(0, 0, 10, 10);
gg.setColor(Color.BLACK);
gg.drawRect(1, 1, 6, 6);
gg.setColor(Color.BLUE);
gg.fillRect(1, 1, 3, 3);
gg.setColor(Color.RED);
gg.fillRect(4, 4, 3, 3);

g2d.setPaint(new TexturePaint(imagenBuf, new Rectangle(10, 10)));

g2d.fill(new RoundRectangle2D.Double(155, 30, 75, 100, 50, 50));

g2d.setPaint(Color.WHITE);
g2d.setStroke(new BasicStroke(6.0f));
g2d.draw(new Arc2D.Double(240, 30, 75, 100, 0, 270, Arc2D.PIE));

g2d.setPaint(Color.GREEN);
g2d.draw(new Line2D.Double(395, 30, 320, 150));

float[] guiones = {10};

g2d.setPaint(Color.YELLOW);
g2d.setStroke(new BasicStroke(4, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 10,
guiones, 0));
g2d.draw(new Line2D.Double(320, 30, 395, 150));
}
}
import java.awt.Color;
import javax.swing.JFrame;

public class LineasRectsOvalos {

// ejecuta la aplicación
public static void main(String[] args) {

// crea marco para LineasRectsOvalosJPanel

JFrame marco = new JFrame("Dibujo de lineas, rectangulos y ovalos");
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

LineasRectsOvalosJPanel lineasRectsOvalosJPanel = new LineasRectsOvalosJPanel();

lineasRectsOvalosJPanel.setBackground(Color.WHITE);

marco.add(lineasRectsOvalosJPanel);
marco.setSize(400, 210);
marco.setVisible(true);
}
}

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;

public class LineasRectsOvalosJPanel extends JPanel {

@Override
public void paintComponent(Graphics g) {
 super.paintComponent(g);
this.setBackground(Color.WHITE);

g.setColor(Color.RED);
g.drawLine(5, 30, 380, 30);

g.setColor(Color.BLUE);
g.drawRect(5, 40, 90, 55);
g.fillRect(100, 40, 90, 55);

g.setColor(Color.CYAN);
g.fillRoundRect(195, 40, 90, 55, 50, 50);
g.drawRoundRect(290, 40, 90, 55, 20, 20);

g.setColor(Color.GREEN);
g.draw3DRect(5, 100, 90, 55, true);
g.fill3DRect(100, 100, 90, 55, false);

g.setColor(Color.MAGENTA);
g.drawOval(195, 100, 90, 55);
g.fillOval(290, 100, 90, 55);
}
}
import javax.swing.JFrame;

public class MostrarColores {

public static void main(String[] args) {
JFrame frame = new JFrame("Uso de colores");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JPanelColor jPanelColor = new JPanelColor();

frame.add(jPanelColor);

frame.setSize(400, 180);
frame.setVisible(true);
}
}

import java.awt.Graphics;
import java.awt.Color;
import javax.swing.JPanel;

public class JPanelColor extends JPanel {

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
this.setBackground(Color.WHITE);

g.setColor(new Color(255, 0, 0));

g.fillRect(15, 25, 100, 20);
g.drawString("RGB actual: " + g.getColor(), 130, 40);
 g.setColor(new Color(0.50f, 0.75f, 0.0f));
g.fillRect(15, 50, 100, 20);
g.drawString("RGB actual: " + g.getColor(), 130, 65);

g.setColor(Color.BLUE);
g.fillRect(15, 75, 100, 20);
g.drawString("RGB actual: " + g.getColor(), 130, 90);

Color color = Color.MAGENTA;

g.setColor(color);
g.fillRect(15, 100, 100, 20);
g.drawString("Valores RGB: " + color.getRed() + ", " +
color.getGreen() + ", " + color.getBlue(), 130, 115);
}
}
import javax.swing.JFrame;

public class MostrarColores2 {

public static void main(String[] args) {
MostrarColores2JFrame aplicacion = new MostrarColores2JFrame();
aplicacion.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JColorChooser;
import javax.swing.JPanel;

public class MostrarColores2JFrame extends JFrame {

private final JButton cambiarColorJButton;
private Color color = Color.LIGHT_GRAY;
private final JPanel coloresJPanel;

public MostrarColores2JFrame() {
super("Uso de JColorChooser");

coloresJPanel = new JPanel();

coloresJPanel.setBackground(color);
 cambiarColorJButton = new JButton("Cambiar color");
cambiarColorJButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent evento) {
color = JColorChooser.showDialog(MostrarColores2JFrame.this, "Seleccione un color",
color);

if (color == null) {
color = Color.LIGHT_GRAY;
}

coloresJPanel.setBackground(color);
}
});

add(coloresJPanel, BorderLayout.CENTER);
add(cambiarColorJButton, BorderLayout.SOUTH);

setSize(400, 130);
setVisible(true);
}
}