Lab2-POO

UNIVERSIDAD ISRAEL
CIENCIAS DE LA INGENIERÍA
CARRERA DE SISTEMAS DE INFORMACIÓN
PROGRAMACIÓN ORIENTADA A OBJETOS
SEMESTRE 2021 A
LABORATORIO S2
TEMA: Aplicaciones Java (Gráficas)
PROFESOR: Mg. Luis Fernando Aguas Bucheli
QUITO, 2021

Ciencias de la Ingeniería
Universidad Israel
Carrera de Sistemas de Información
1. TEMA: Aplicaciones Java (Gráficas)
2. OBJETIVOS:
• Adquirir los conceptos básicos relacionados con la POO
• Reconocer las características de la POO
3. OBJETIVOS DE DESARROLLO SOSTENIBLE:
4. INTRODUCCION:
Casi todas las componentes y contenedores de Swing tienen un método paint(g) asociado que
sirve para dibujarlos en pantalla. Java invoca este método automáticamente cuando tiene que
mostrar, de forma estándar, la componente o contenedor en cuestión (esto es, sus bordes, su
título, si lo tiene, etc.)
El método paint(g) se redefine cuando se quiere que estos elementos tengan un aspecto
particular, por ejemplo, cuando se quiere dibujar algo específico sobre ellos.
El método paint(g) es de la forma
public void paint(Graphics g) {
...
}
Donde g es un objeto de la clase abstracta Graphics. Todo contenedor o componente que se
pueda dibujar en pantalla tiene asociado un objeto g de esta clase, con la información sobre el
área de la pantalla que el
contenedor o la componente cubre. Además, el objeto g dispone de métodos para hacer gráficos
(dibujar círculos, rectángulos, líneas, etc.)
La clase Graphics se importa de awt:

Universidad Israel
import java.awt.*;
Cuando el método paint(g) se ejecuta es porque ha sido invocado por otros métodos, nunca
invocado por
nosotros, y el parámetro que usa corresponde a un objeto de la clase Graphics asociado al
contenedor o
componente que estemos manejando.
Cuando se redefine el método paint(g), siempre se comienza con una invocación super.paint(g)
al método de la superclase, asegurando así que se dibuja la parte estándar del contenedor o
componente que estemos manejando.
Por ejemplo, vamos a dibujar una cara en un marco. Un marco es un elemento de la clase JFrame
y para dibujar en él procedemos así:
public void paint (Graphics g){
super.paint(g);
//Dibujo el contorno de la cara
g.setColor(Color.BLACK);
g.fillOval(105, 70, 100, 100);
//Dibujo de los ojos
g.setColor(Color.GREEN);
g.fillOval(125, 100, 10, 10);
g.fillOval(175, 100, 10, 10);
//Dibujo de la nariz
g.drawLine(150, 100, 150, 130);
//Dibujo de la boca
g.drawArc(118, 120, 75, 30, 180, 180);
}
Para entender lo que ha hecho el método anterior hay que saber que:
El sistema de coordenadas de un contenedor tiene su origen en su esquina superior izquierda.
Las abscisas se incrementan hacia la derecha y las ordenadas hacia abajo.
Cada punto es un píxel.
En general, el dibujo de una figura (rectángulo, elipse, rectángulo redondo, etc.) se realiza dando
las coordenadas de la esquina superior izquierda de un rectángulo imaginario que la contiene.
Algunos métodos de la clase Graphics para dibujar figuras son:
drawLine(x1,y1,x2,y2): dibuja una línea recta desde el punto (x1,y1) al punto (x2,y2)

Universidad Israel
fillRect(x,y,ancho,alto): rellena el rectángulo que tiene su esquina superior izquierda en (x,y) y
el ancho y largo dados
drawOval(x,y,ancho,alto): dibuja una elipse contenida en un rectángulo imaginario cuya esquina
superior izquierda está en (x,y) y tiene el ancho y largo dados
fillOval(x,y,ancho,alto): rellena la elipse especificada pordrawOval(x,y,ancho,largo)
drawArc(x,y,ancho,alto, inicioAngulo,barridoAngulo): dibuja parte de una elipse dentro de un
rectángulo imaginario cuya esquina superior izquierda está en (x,y), tiene el largo y ancho dados,
empieza a dibujar en el ángulo inicioAngulo y hace un barrido de barridoAngulo
setColor(Color.red): cambia la “tinta” del objeto g y la pone de color rojo. La clase Color se
importa de awt:
import java.awt.*;
Dibujar sobre paneles
Cuando se actualiza un componente, se borra su aspecto actual y seinvoca paint(g). El borrado
previo puede producir parpadeo (flickering) ,por lo que a veces el método paint(g) evita hacerlo.
Sin embargo, la actualización puede necesitar hacer el borrado previo(para actualizar el fondo
del componente, por ejemplo). En estos casos se invoca el método paintComponent(g) de la
clase JComponent, que permite hacer un barrido previo, pero usando la técnica del doble buffer
para eliminar el parpadeo.
En casos como los anteriores lo que se hace es redefinir el método paintComponent(g) en lugar
del método paint(g).
Por ejemplo, para dibujar la cara que pintamos antes, pero sobre un (j)panel en lugar de sobre
un marco, hacemos lo siguiente:
Se declara la clase PanelCara que extiende la clase JPanel, como clase (privada) de la clase
MarcoCara que habíamos creado antes
Se redefine el método paintComponent(g) usando las mismas instrucciones que antes, pero
llamando inicialmente a super.paintComponent(g)
public void paintComponent(Graphics g) {
super.paintComponent(g);...}
Cuando el contenido de un marco o panel cambia, el método repaint() se encarga de actualizar
el contenedor y mostrarlo por pantalla, invocando implícitamente el método paint(g) o
paintComponent(g).
Por ejemplo, para añadir un botón al marco que mostraba una cara sonriente de forma que,
cuando se pulse, la cara cambie a una cara eenojada, basta hacer lo siguiente:
Se añade a contentPane el botón cuyo efecto cambiará la sonrisa de la cara
Se añade un atributo booleano al marco que indica si la cara sonríe o no
private boolean sonrie=true;
Dentro del actionPerformed del boton codeamos lo siguiente:
sonrie=!sonrie;
repaint();
El método paintComponent(g) para pintar el panel se redefine por el siguiente:
public void paintComponent(Graphics g) {
super.paintComponent(g);
//Dibujo de la cara igual que antes, salvo la boca

Universidad Israel
...
//Dibujo de la boca
if (sonrie) g.drawArc(118, 125, 75, 30, 180, 180);
else g.drawArc(118, 125, 75, 30, 180, -180);
}
Dibujar texto
La clase Graphics permite “dibujar” texto, como alternativa al texto mostrado en los
componentes JLabel, JTextField y JTextArea. El método que permite graficar texto sobre el
JFrame es:
drawString(String str, int x, int y);
Clase Color
La clase java.awt.Color encapsula colores utilizando el formato RGB (Red, Green, Blue). Las
componentes de cada color primario en el color resultante se expresan con números enteros
entre 0 y 255, siendo 0 la intensidad mínima de ese color y 255 la máxima. En la clase Color
existen constantes para colores predeterminados de uso frecuente: black, white, green, blue,
red, yellow, magenta, cyan, orange, pink, gray, darkGray, lightGray.
Presentación de imágenes
Java permite incorporar imágenes de tipo GIF y JPEG definidas en ficheros. Se dispone para ello
de la clase java.awt.Image. Para cargar una imagen hay que indicar la localización del archivo y
cargarlo mediante el método getImage(). Este método existe en las clases java.awt.Toolkit.
Entonces, para cargar una imagen hay que comenzar creando un objeto (o una referencia) Image
y llamar al método getImage() (de Toolkit); Una vez cargada la imagen, hay que representarla,
para lo cual se redefine el método paint() para llamar al método drawImage() de la clase
Graphics. Los objetos Graphics pueden mostrar imágenes a través del método: drawImage().
Dicho método admite varias formas, aunque casi siempre hay que incluir el nombre del objeto
imagen creado.
Clase Image
Una imagen es un objeto gráfico rectangular compuesto por pixels coloreados. Cada pixel en
una imagen describe un color de una particular localización de la imagen.
A continuación, algunos métodos de la clase Image:
La clase Graphics provee el método drawImage() para dibujar imagenes; este método admite
varias formas:
- drawImage (Image i, int x, int y, ImageObserver o)
- drawImage (Image i,int x,int y,int width,int height,ImageObserver o)
Un ejemplo del metodo paint(Graphics G) para traer una imagen de la carpeta raiz es el
siguiente:

Universidad Israel
public void paint (Graphics g)
{
super.paint(g);
Toolkit t = Toolkit.getDefaultToolkit ();
Image imagen = t.getImage ("imagen1.jpg");
g.drawImage (imagen, 0, 0, this);
}
5. DESARROLLO:
RELACIÓN JERÁRQUICA
• Ingresamos a Netbeans

Universidad Israel
• Creamos un nuevo proyecto:
• Colocamos como nombre

Universidad Israel
Damos clic en Finish
Damos clic en delete

Universidad Israel
Luego Clic en Refactor
Para la Línea:
Creamos la clase Linea

Universidad Israel
import java.awt.*;
public class Linea{
protected int longi;
public Linea(int longi){
this.longi=longi;
}
public int get_longi(){
return longi;
}
public void set_longi(int longi){
this.longi=longi;
}
public void graficar(Graphics Cl, Linea cl, int x, int y){
Cl.setColor(Color.green);
Cl.drawLine(x,y+cl.get_longi()/2,x,y+cl.get_longi()+cl.get_longi()/2);
}
public void ver(Graphics Cl, Linea cl, int x, int y){
Font tipo1=new Font("Arial", Font.BOLD+Font.ITALIC,14);
Font tipo2=new Font("Comic Sans MS", Font.ITALIC,13);
Cl.setFont(tipo1);
Cl.setColor(Color.black);
Cl.drawString("Línea",x+255,y+180);
Cl.setColor(Color.blue);
Cl.setFont(tipo2);
Cl.drawString("Longitud: "+cl.get_longi()+" cm",x+255,y+305);
}
}//fin linea class
Teniendo:

Universidad Israel
Para el Cuadrado:
Luego creamos la clase Cuadrado en base al proceso anterior, con el siguiente código:
import java.awt.*;
/**
*
* @author LuisFernando
*/
public class Cuadrado extends Linea{
public Cuadrado (int longi){
super(longi);
}
public void graficar(Graphics Cl,int x, int y){
Cl.fillRect(x,y,super.get_longi(),super.get_longi()-1);
}
public double perimetro(){
return 4*(super.get_longi());

Universidad Israel
}
public double area(){
return java.lang.Math.pow(super.get_longi(),2);
}
public void ver(Graphics Cl,Cuadrado cu,int x, int y){
Cl.setFont(tipo1);
Cl.drawString("Cuadrado",x+480,y);
Cl.setFont(tipo2);
Cl.drawString("Lado: "+super.get_longi()+" cm",x+480,y+110);
Cl.drawString("Perímetro: "+cu.perimetro()+" cm",x+480,y+125);
Cl.drawString("Área: "+cu.area()+" cm²",x+480,y+140);
}
}//fin cuadrado class
Teniendo:
Para el Circulo:
Creamos la clase Círculo
import java.awt.*;
/**
*

Universidad Israel
*/
public class Circulo {
protected int radio;
public Circulo(int radio)
{
this.radio=radio;
}//fin circulo
public int get_radio(){
return radio;
}//fin get_radio
public void set_radio(int radio)
{
this.radio=radio;
}//fin setear
public void graficar(Graphics Cl,Circulo cl,int x, int y)
{
Cl.setColor(Color.red);
Cl.fillOval(x,y+15,cl.get_radio()*4,cl.get_radio()*4);
}//fin graficar
return java.lang.Math.PI*java.lang.Math.pow(this.radio,2);
}//fin area
return 2*java.lang.Math.PI*this.radio;
}
public void ver(Graphics Cl, Circulo cl, int x, int y){
Cl.setFont(tipo1);
Cl.drawString("Círculo",x,y);
Cl.setFont(tipo2);
Cl.drawString("Radio: "+cl.get_radio()+" cm",x,y+110);
Cl.drawString("Perímetro: "+cl.perimetro()+" cm",x,y+125);
Cl.drawString("Área: "+cl.area()+" cm²",x,y+140);
}
}//fin clase circulo
Teniendo:

Universidad Israel
Para el Rectángulo:
Creamos la clase Rectangulo
import java.awt.*;
public class Rectangulo extends Linea{
int base;
public Rectangulo(int base, int longi){
super(longi);
this.base=base;
}
public int get_base(){
return base;
}
public void ver(Graphics Cl,Rectangulo rec,int x, int y){
Cl.setFont(tipo1);
Cl.drawString("Rectángulo",x+480,y+180);
Cl.setFont(tipo2);
Cl.drawString("Altura: "+super.get_longi()+" cm",x+480,y+305);
Cl.drawString("Base: "+rec.get_base()+" cm",x+480,y+320);
Cl.drawString("Perímetro: "+rec.perimetro()+" cm",x+480,y+335);
Cl.drawString("Área: "+rec.area()+" cm²",x+480,y+350);
}

Universidad Israel
return (2*(super.get_longi())+2*this.base);
}
return (this.base*super.get_longi())/2;
}
public void graficar(Graphics Cl,int x, int y){
Cl.setColor(Color.orange);
Cl.fillRect(x,y,super.get_longi()*2,this.base*4);
}
} //fin rectangulo class
Teniendo:
Para el Triángulo:
Creamos la clase Triangulo
import java.awt.*;
/**
*
*/
public class Triangulo extends Linea{
private int sop;
public Triangulo(int sop, int longi){
super(longi);

Universidad Israel
this.sop=sop;
}
public void graficar(Graphics Cl, Triangulo cl,int x, int y)
{
int x1 []={x,x-(cl.get_sop()/2)*3,x+(cl.get_sop()/2)*3};
int y1 []={y,y+super.get_longi()*3,y+cl.get_longi()*3};
Cl.setColor(Color.pink);
Cl.fillPolygon(x1,y1,3);
}//fin graficar
public int get_sop(){
return sop;
}
public void ver(Graphics Cl,Triangulo tri,int x, int y){
Cl.setFont(tipo1);
Cl.drawString("Triángulo",x+625,y);
Cl.setFont(tipo2);
Cl.drawString("Altura: "+super.get_longi()+" cm",x+625,y+180);
Cl.drawString("Base: "+tri.get_sop()+ " cm",x+625,y+195);
Cl.drawString("Área: "+tri.area()+" cm²",x+625,y+210);
}
return (super.get_longi()*this.sop)/2;
}
}//fin triangulo class
Teniendo

Universidad Israel
Para el Cilindro:
Creamos la clase Cilindro
import java.awt.*;
/**
*
*/
public class Cilindro extends Circulo{
private int largo;
public Cilindro(int radio,int largo){
super(radio);
this.largo=largo;
}
public int get_largo(){
return largo;
}
public void ver(Graphics Cl, Cilindro cl, int x, int y){
Cl.setFont(tipo1);
Cl.drawString("Cilindro",x+255,y);
Cl.setFont(tipo2);
Cl.drawString("Radio: "+super.get_radio()+" cm",x+255,y+110);
Cl.drawString("Altura: "+cl.get_largo()+" cm",x+255,y+125);

Universidad Israel
Cl.drawString("Superficie: "+cl.area()+" cm²",x+255,y+140);
Cl.drawString("Volumen: "+cl.volumen()+" cm³",x+255,y+155);
}
public double volumen(){
return super.area()*this.largo;
}
return (super.area()+super.perimetro()*this.largo);
}
public void graficar(Graphics Cl,Cilindro cl,int x, int y){
Cl.setColor(Color.cyan);
Cl.fillOval(x,y,super.get_radio()*2,super.get_radio());
Cl.fillOval(x,y+cl.get_largo(),super.get_radio()*2,super.get_radio());
Cl.drawLine(x,y+super.get_radio()/2,x,y+cl.get_largo()+super.get_radio()/2);
Cl.drawLine(x+super.get_radio()*2,y+super.get_radio()/2,x+super.get_radio()*2,y+cl.get_largo
()+super.get_radio()/2);
}
}//fin cilindro class
Teniendo:
Para el Cono:
Creamos la clase Cono
import java.awt.*;

Universidad Israel
/**
*
*/
public class Cono extends Circulo{
private int altura;
public Cono(int radio, int altura){
super(radio);
this.altura=altura;
}
public int get_altura(){
return altura;
}
public void set_altura(){
this.altura=altura;
}
public void graficar(Graphics Cl,Cono cl,int x, int y){
Cl.setColor(Color.yellow);
Cl.fillOval(x,y,super.get_radio()*4,super.get_radio()*2);
Cl.drawLine(x,y+super.get_radio(),x+super.get_radio()*2,y+cl.get_altura()+super.get_radio());
Cl.drawLine(x+super.get_radio()*4,y+super.get_radio(),x+super.get_radio()*2,y+cl.get_altura()
+super.get_radio());
}
public void ver(Graphics Cl, Cono cl, int x, int y){
Cl.setFont(tipo1);
Cl.drawString("Cono",x,y+180);
Cl.setFont(tipo2);
Cl.drawString("Radio: "+super.get_radio()+" cm",x,y+305);
Cl.drawString("Altura: "+cl.get_altura()+" cm",x,y+320);
Cl.drawString("Superficie: "+cl.superficie(cl)+" cm²",x,y+335);
Cl.drawString("Volumen: "+cl.volumen(cl)+" cm³",x,y+350);
}
public double volumen(Cono cl){
return (super.area()*cl.get_altura())/3;
}
public double superficie(Cono cl){
return (super.area()+2*java.lang.Math.PI*cl.get_altura()+super.perimetro());
}
}//fin cono
Teniendo:

Universidad Israel
Creamos un jFrame
Colocamos el siguiente nombre:

Universidad Israel
Teniendo:
De la Pallete, escogemos un jButton y un jPanel, teniendo:

Universidad Israel
Seleccionamos el jPanel y vamos a propiedades a background
Teniendo

Universidad Israel
Luego seleccionamos el jButton y vamos a propiedades
Damos doble clic en el button

Universidad Israel
Colocamos este código
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
int hori=20; int vert=40;
Graphics Cl=jPanel1.getGraphics();
Circulo cir = new Circulo(20);
Cono con= new Cono(20,70);
Cilindro cil= new Cilindro(20,60);
Linea lin=new Linea(60);
Cuadrado cua= new Cuadrado(80);
Rectangulo rec= new Rectangulo(20,60);
Triangulo tri= new Triangulo(30,50);
cir.ver(Cl,cir,hori,vert);
cir.graficar(Cl,cir,hori,vert);
con.ver(Cl,con,hori,vert);
con.graficar(Cl,con,hori,vert+200);
cil.graficar(Cl,cil,hori+255,vert+15);
cil.ver(Cl,cil,hori,vert);
cua.graficar(Cl,hori+480,vert+15);
cua.ver(Cl,cua,hori,vert);
rec.ver(Cl,rec,hori,vert);

Universidad Israel
rec.graficar(Cl,hori+480,vert+200);
lin.graficar(Cl,lin,hori+255,vert+200);
lin.ver(Cl,lin,hori,vert);
tri.ver(Cl,tri,hori,vert);
tri.graficar(Cl, tri,hori+680,vert+15);
}
Teniendo:
Compilamos y ejecutamos:

Universidad Israel
6. BIBLIOGRAFIA:

Lab2-POO

Más contenido relacionado

La actualidad más candente (16)

Similar a Lab2-POO (20)

Más de Luis Fernando Aguas Bucheli (20)

Último (20)

Lab2-POO