Programación de gráficos

Curso Java Experto

Clase 2

Uso del color

Graphics2D

setPaint(Color color)

g2.setPaint(Color.RED);

g2.drawString("Cuidado",100,100);

JPanel

setBackground(Color color)

setForeground(Color color)

Color

Black

Blue

Red

Cyan

const

...

La clase java.awt.Color ofrece constantes para 13 colores estándares.

También permite definir un color personalizado

Color(int rojo, int verde, int azul)

brighter()

darker()

Producen versiones más brillantes o más apagadas del color en curso.

SystemColor

Las constantes en esta clase encapsulan los colores que se emplean para los distintos elementos del sistema de usuario.

desktop: color de fondo del escritorio

window: color de fondo de las ventanas

menu: color de fondo para los menús

text: color de fondo para el texto

...

Llenado de formas

Basta con rellenar en lugar de pintar.

Rectangle2D rectangulo = ...;

g2.setPaint(Color.RED);

g2.fill(rectangulo);

class MarcoColor extends JFrame {
	public MarcoColor() {
		setSize(400, 400);
		setTitle("Prueba Figuras con colores");
		LaminaConRelleno lamina = new LaminaConRelleno();
		lamina.setBackground(SystemColor.window);
		add(lamina);
	}
}
class LaminaConRelleno extends JPanel {
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2 = (Graphics2D) g;

		// Dibujar rectangulo
		double xizq = 100;
		double ysup = 100;
		double anchura = 200;
		double altura = 150;
		Rectangle2D rectangulo = new Rectangle2D.Double(xizq, ysup, anchura, altura);
		g2.setColor(Color.WHITE);
		g2.draw(rectangulo);		
		g2.setPaint(Color.BLUE);
		g2.fill(rectangulo);

		// Dibujar elipse inscrita
		Ellipse2D elipse = new Ellipse2D.Double();
		elipse.setFrame(rectangulo);
		g2.setPaint(Color.PINK);
		g2.fill(elipse);

		// dibujar linea diagonal
		g2.setPaint(new Color(10, 70, 20).brighter().brighter());
		g2.draw(new Line2D.Double(xizq, ysup, xizq + anchura, ysup + altura));

	}}

Ejercicio 1

Uso de fuentes especiales para texto

Graphics2D

setFont(Font fuente)

Font

Font(tipo,estilo,tamaño)

BOLD

PLAIN

ITALIC

Ejercicio 2: detectar fuentes instaladas

import java.awt.GraphicsEnvironment;

public class ListaDeFuentes {

	public static void main(String[] args) {
		String[] nombresFuentes = GraphicsEnvironment.getLocalGraphicsEnvironment()
                                            .getAvailableFontFamilyNames();
		for(String nombre : nombresFuentes)
			System.out.println(nombre);

	}

}

Para poder establecer una base común, AWT define 5 nombres de fuentes lógicos:

  • SansSerif
  • Serif
  • Monospaced
  • Dialog
  • DialogInput

Equivalencia se define en jre/lib/fontconfig.properties

A partir de la versión 1.3 de JDK se pueden leer fuentes TrueType.

 

Ejercicio 3

class MarcoTexto extends JFrame {
	public MarcoTexto() {
		setSize(400, 400);
		setTitle("Prueba con fuentes");
		LaminaConTexto lamina = new LaminaConTexto();
		add(lamina);
	}
}

class LaminaConTexto extends JPanel {
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2 = (Graphics2D) g;
		Font fuente = new Font("Serif", Font.BOLD, 14);
		g2.setFont(fuente);
		g2.setColor(Color.PINK);

		String nombre = "Ejemplo fuente";

		// Medimos mensaje
		FontRenderContext contexto = g2.getFontRenderContext();
		Rectangle2D limites = fuente.getStringBounds(nombre, contexto);

		// obtenemos posicion
		double x = (getWidth() - limites.getWidth()) / 2;
		double y = (getHeight() - limites.getHeight()) / 2;

		g2.drawString(nombre, (int) x, (int) y);

	}
}

Usando imagenes

Image

ImageIO

Graphics

java.awt

javax.imageio

java.awt

getWidth()

getHeigth()

read(URL url)

read(File file)

drawImage(Image imagen, int x, int y,null)

copyArea()

Una vez que las imágenes están almacenadas en ficheros locales podemos leerlas desde la aplicación de Java para visualizarlas utilizando objetos de tipo Graphics.

File input = new File("src/icono.jpg");
Image imagen = ImageIO.read(input);
URL input = new URL(url);
Image imagen = ImageIO.read(input);
public void paintComponent(Graphics g) {
    ...

    // Dibujo imagen
    g.drawImage(imagen, x, y, null);
    ...
}
class LaminaConImagen extends JPanel {
	private Image imagen;

	public LaminaConImagen() {
		File input = new File("src/icono.jpg");
		try {
			imagen = ImageIO.read(input);
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("No se encuentra la imagen");
		}
	}

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

		// Dibujo imagen
		g.drawImage(imagen, 0, 0, null);

		int ancho = imagen.getWidth(this);
		int alto = imagen.getHeight(this);

		// Copio imagen
		for (int i = 0; i * ancho <= getWidth(); i++)
			for (int j = 0; j * alto <= getHeight(); j++)
				if (i + j > 0)
					g.copyArea(0, 0, ancho, alto, i * ancho, j * alto);

	}
}

Ejercicio 4

Repaso

Constructor

  • Tiene el mismo nombre que la clase.
  • Se ejecuta cuando se instancian objetos de la clase.
  • Una clase puede tener más de una constructor.
  • Puede tener cero o más parámetros.
  • Los constructores siempre se invocan mediante el operador new.

Beneficios de la encapsulación

  • Se puede modificar la implementación interna sin afectar ningún código, salvo el de los métodos de clase.
    • Ejemplo: si el almacenamiento de nombre pasa a ser nombrePila y apellido, entonces en el método getNombre se puede modificar para que proporcione nombrePila+" "+apellido. 
  • Los métodos de set pueden efectuar una comprobación de errores, mientras que los de get no sería necesario.
  • Si un campo es public y el valor es incorrecto, el culpable de estropear el valor podría haber estado en cualquier lugar. Con private, solamente sería necesario depurar ese método.

Ver: http://programmers.stackexchange.com/questions/143736/why-do-we-need-private-variables

Campos estáticos

  • Se declaran utilizando la palabra static.
  • Son las "variables de clase". Pertenece a una clase y no a ningún objeto en particular.
  • Ocupan un solo lugar en memoria por más que se generen muchas instancias.
  • Deben declararse en la cabecera de la clase.
  • Aún cuando no existieran instancias de esa clase en memoria, el campo static estaría presente.
  • La palabra static no puede aplicarse a una clase.

Constantes

  • Se declaran utilizando la palabra "final".
  • Si no se las declara static, ocupan lugar en memoria por cada instancia de la clase.
  • No se puede modificar su valor.
  • Por convención se las suele declarar en mayúscula.
  • Se inicia en el mismo momento de declararla.
  • La palabra final también puede aplicarse a clases, lo que indica que esa clase no puede ser heredada.

Métodos estáticos

  • Pueden ser invocados sin existir una instancia de la clase, ya que no operan sobre objetos.
  • No pueden acceder a campos de instancia. Se los puede considerar como métodos que no tienen el parámetro this.
  • Pueden acceder a los campos static de su clase.
  • No pueden invocar a métodos de instancia.
  • Ejemplo: método main.
  • Se utiliza cuando:
    • Un método no necesita acceder al estado del objeto porque todos los parámetros necesarios se proporcionan como parámetros explícitos.
    • Un método no necesita acceder a campos de instancia pero si a campos de clase.

Herencia

  • Se utiliza la palabra reservada extends.
  • Una clase puede extender de una clase concreta o una clase abstracta
  • Una clase solo puede heredar una superclase. Java no admite herencia múltiple.
  • Al extender una clase
    • se heredan todas las operaciones del padre  
    • se puede añadir nuevas operaciones
  • La nueva clase puede elegir para las operaciones heredadas:
    • redefinir la operación: se vuelve a escribir
    • la nueva operación puede usar la del padre y hacer más cosas (super)
    • puede ser totalmente diferente • dejarla como está: no hacer nada

Clase abstracta

  • No se puede instanciar.
  • Puede contenter métodos abstractos y métodos concretos.
  • Se utiliza cuando no es necesario instanciar objetos de una clase. Por ejemplo: si tenemos dos clases ProfesorInterino y ProfesorTitular, ambas heredan de Profesor. Pero si todas las instancias de Profesor corresponderán a uno de los dos tipos, no sería necesario nunca instanciar Profesor.

Métodos abstractos.

  • No tiene cuerpo, solo se declaran.
  • La signatura termina con ; .
  • Solo pueden existir en una clase abstracta.
  • Deben estar obligatoriamente sobreescritos en la subclase. Si no se sobreescriben, la subclase tendría un método abstracto por lo tanto seriía una clase abstracta.

Interfaces

  • Se utilizan las palabras reservadas interface y implements.
  • Conjunto de directrices, las cuales las clases que la implentan deben cumplir.
  • Si una clase cumple con las especificaciones de una interfaz la puede implementar.
  • No se instancian.
  • Solo tienen métodos public y abstract. Si no se aclara se toman por defecto.
  • Ejemplo: interfaz List -> la implementan ArrayList, LinkedList, Stack, etc.

Diferencia entre clase abstracta e interfaz

  • Las interfaces posibilitan implementar la herencia múltiple. Una clase puede implementar varias interfaces pero no extender de varias superclases.

Polimorfismo

Se refiere a la propiedad por la que es posible enviar mensajes sintácticamente iguales a objetos de tipos distintos. El único requisito que deben cumplir los objetos que se utilizan de manera polimórfica es saber responder al mensaje que se les envía.

Empleado e;
e = new Empleado(...);
e = new Administrador(...);
Empleado e1;
e1 = new Secretaria(...);

El polimorfismo en Java consiste en dos propiedades:

  • Una referencia a una superclase puede apuntar a un objeto de cualquiera de sus subclases
  • La operación se selecciona en base a la clase del objeto, no a la de la referencia
e.calcularSueldo();
e1.calcularSueldo();

Ejercicios

  1. Dibujar un rectángulo que tenga un color de fondo y un color de línea. Dibujar una elipse inscripta en el rectángulo con otro color de fondo. Dibujar una línea con un color RGB. La lámina de contenido, debe repetar el color de fondo de las ventanas del sistema de interfaz nativo.
  2. Detectar fuentes instaladas y imprimirlas en consola.
  3. Escribir un texto en una lámina, cambiarle la fuente al texto y centrarlo en la pantalla.
  4. Cubrir una lámina con una imagen en forma de mosaico.

Ejercicio Repaso

  1. Construir una clase empleado que contenga nombre, sueldo y fecha de contrato. También contendrá una constante de clase que se llame aumento. Su valor será de 5.
  2. Esta clase cuenta con 2 constructores: un constructor sin parámetros y otro con 3 parámetros ( nombre, sueldo, fecha de contrato).
  3. Esta clase contiene un método subirSueldo que aumenta el sueldo de los empleados en un 5%.
  4. Construir otra clase PruebaEmpleado.java que implemente el método main. Dentro del main, crear una lista de objetos de tipo Empleado. Agregar a esa lista 3 empleados utilizando los 2 constructores definidos. Recorrer la lista y subirle el sueldo a cada empleado en un 5%. Por último mostrar en consola la información completa de cada empleado.
  5. Crear otra clase PruebaEmpleadoGrafica.java que realice lo mismo que PruebaEmpleado pero el lugar de mostrar los resultados por consola, los muestre sobre una lámina de contenido. Utilizar lo visto hasta el momento de Programación gráfica.
Made with Slides.com