jueves, 12 de diciembre de 2013

NODO

Los nodos son elementos de tipo abstracto de dato que guarda un objeto con sus atributos de manera individual, pero dentro de un grupo de objetos, contiene un enlace o puntero quien indica cual será el nodo que le proceda, es un elemento básico en las listas, pilas, colas y arboles (hablaremos de ellos en las siguientes publicaciones).

Nota: Si en lugar de enlace el puntero indicara null, que significa vacío, quiere decir que ese es el último o único nodo de el grupo de nodos registrados.






Al registrar un dato éste inicia con el puntero indicando null, lo que significa que es el único o último nodo registrado, como ya lo había mencionado. Al registrar otro nodo, el puntero de la clase que se había registrado se convertirá en un enlace quien va a indicar que es el segundo nodo, y así sucederá con los demás nodos que se registren, y el nodo nuevo registrado tendrá el puntero con null.

Este tema será la base para crear las siguientes publicaciones que serán listas, pilas, colas y árboles.


  • Diagrama de UML











  • Programa
Creamos un nuevo proyecto o paquete que llamamos NODO y creamos una clase que se llame Nodo, posteriormente declaramos las variables que usaremos una que guarda los datos, en este caso la declaramos de tipo String, y otra que guardará el puntero de el nodo, de tipo Nodo...

package NODO;
import javax.swing.JOptionPane;
public class Nodo {
  private String dato
    private Nodo enlace;

...encapsulamos las variables...


   public Nodo getEnlace() {

        return enlace;  }

   public void setEnlace(Nodo enlace) {
        this.enlace = enlace;   }
   public String getDato() {
        return dato;    }
   public void setDato(String dato) {
        this.dato = dato; }

... creamos los constructores de clase...
¿Que es esto y para que nos sirve?  Un constructor de clase es un método especial que se llama automáticamente siempre que se declara un objeto de esa clase.

Su función es inicializar el objeto y sirve para asegurarnos de que estos siempre contengan valores válidos.

Cuando se crea un objeto en Java se realizan las siguientes operaciones de forma automática:
  1. Se asigna memoria para el objeto.
  2. Se inicializan los atributos de ese objeto con los valores predeterminados por el sistema.
  3. Se llama al constructor de la clase que puede ser uno entre varios.
El constructor de una clase tiene las siguientes características:
  • Tiene el mismo nombre que la clase a la que pertenece.
  • En una clase puede haber varios constructores con el mismo nombre y distinto número de argumentos (se puede sobrecargar).
  • No se hereda.
  • No puede devolver ningún valor (incluyendo void).
  • Debe declararse público (salvo casos excepcionales) para que pueda ser invocado desde cualquier parte donde se desee crear un objeto de su clase.
 public Nodo(String x){
        dato=x;
        enlace=null;
    }
    public Nodo(String x, Nodo n){
        dato=x;
        enlace=n;
    }
}
 ... y termina la clase.

Conclusión:
Los nodos son la base de muchos programas para almacenar más de un dato ya que con este le damos cierto enfoque o trato individual a cada uno de ellos, y estos lo guardaran con sus respectivos atributos, pero no olvidemos los vectores que igualmente guardan más de un dato, con la desventaja de que estos guardan los datos con un único atributo: el tipo de dato.

Autor: Guadalupe Jiménez Gerónimo


martes, 8 de octubre de 2013

PEAJE DE CAMIONES

Haremos un programa que calcule cuanto tiene que pagar de peaje un camión. Teniendo como información los ejes que tiene un camión y su peso en toneladas. Nos referimos con eje de un camión a las lineas imaginarias de unión transversal, que coinciden con el lugar donde se encuentran las ruedas del camión ya que este es quien une las parejas de ruedas de manera paralela.

Problema:
Calcular el costo de peaje de camiones. Los camiones que llegan a una estación de peaje deben pagar $50.00 por cada eje, mas $100.00 por cada tonelada de peso total del camión.

Nota:  Y como en el programa anterior, usaremos dos clases, en la primera realizaremos el calculo y en la segunda haremos uso del programa.


1ra. Clase: PeajeDeCamiones

  • Diagrama UML











  • Diagrama de Flujo

  • Programa


package Peaje;
import javax.swing.JOptionPane;
public class PeajeDeCamiones {

    private int Ejes;
    private int Toneladas;
    private int PagoPorEje=50;
    private int PagoPorTonelada=100;
    private int PagoTotal;
    //encapsulamos nuestras variables
    public int getEjes() {
        return Ejes;
    }
    public void setEje(int Ejes) {
        this.Ejes = Ejes;
    }
    public int getToneladas() {
        return Toneladas;
    }
    public void setToneladas(int Toneladas) {
        this.Toneladas = Toneladas;
    }
    public int getPagoPorEje() {
        return PagoPorEje;
    }
    public void setPagoPorEje(int PagoPorEje) {
        this.PagoPorEje = PagoPorEje;
    }
    public int getPagoPorTonelada() {
        return PagoPorTonelada;
    }
    public void setPagoPorTonelada(int PagoPorTonelada) {
        this.PagoPorTonelada = PagoPorTonelada;
    }
    public int getPagoTotal() {
        return PagoTotal;
    }
    public void setPagoTotal(int PagoTotal) {
        this.PagoTotal = PagoTotal;
    }
    public void Captura(){
    Ejes=Integer.parseInt(JOptionPane.showInputDialog("¿CUANTOS EJES TIENE EL CAMION?:"));
    Toneladas=Integer.parseInt(JOptionPane.showInputDialog("¿CUANTAS TONELADAS PESA?:"));
    }
    public void Calculo(){
    PagoTotal=(Ejes*PagoPorEje)+(Toneladas*PagoPorTonelada);    
    }
    public void Imprime(){
       JOptionPane.showMessageDialog(null,"***PEAJE DE CAMIONES***\n\n   EJES DEL CAMION: "+Ejes
               +"\n   PESO POR TONELADAS: "+Toneladas+"\n   PAGO TOTAL: "+PagoTotal); // concatenamos los resultados
    }
}

2da. Clase: Usar



  • Programa


package Peaje;

import javax.swing.JOptionPane;
public class Usar {
    public static void main(String arg[]){
    PeajeDeCamiones P;
    P=new PeajeDeCamiones();
    
    P.Captura();
    P.Calculo();
    P.Imprime();
    }
}


Ejecutar programa

Ejecutamos el programa y la primero ventana nos pide los ejes que tiene el camión...



       
                        .... posteriormente nos pide su peso en toneladas...



... y por último nos envía los resultados, mostrandonos los datos capturados y el total a pagar.






Conclusión:
Este programa no requiere de mucha explicación. Realizamos el calculo del Peaje de camiones tomando en cuenta los ejes que pudiera tener el camión y su peso en toneladas, dando como resultado el total a pagar.

lunes, 7 de octubre de 2013

SALARIO DIARIO

Para demostrar la eficiencia de la Estructura de datos bajo el paradigma Orientado a objetos realizaremos el siguiente problema:

Problema:
Calcular el salario diario de un empleado con base a lo siguiente:
  1. Por cada hora trabajada recibe $17.50 para las primeras 8 hrs.
  2. Por cada hora extra trabajada recibe 1.5 veces el costo de la hora de trabajo dentro del horario normal.
Nota: Usaremos dos clases, la primera hará el calculo de el salario por medio de la captura de las horas trabajadas; y la segunda hará uso de la primera clase.

1ra. Clase: Calcular_Salario

  • Diagrama UML













  • Diagrama de Flujo
Recurriremos esta vez a un diagrama de flujo para entender de mejor manera el calculo de el salario diario.

El diagrama nos permite apreciar las condiciones que llevará el programa. Ya que el problema dado dice que una vez pasadas las primeras 8 horas de trabajo, las horas extras se pagarán al 1.5 veces de el pago normal. El diagrama nos indica cierta condición, para realizar los procedimientos correspondientes.
  • Programa
package Salario_Diario;
import javax.swing.JOptionPane;
public class Calcular_Salario {
    private String nombre; // agregamos el nombre de el empleado por simple estética
    private int HorasTrabajadas;
    private float SubSalario;
    private float SalarioTotal;
    private float PagoPorHora=17.50f;
    
    public String getNombre() {
        return nombre;
    }
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    public int getHorasTrabajadas() {
        return HorasTrabajadas;
    }
    public void setHorasTrabajadas(int HorasTrabajadas) {
        this.HorasTrabajadas = HorasTrabajadas;
    }
    public float getSubSalario() {
        return SubSalario;
    }
    public void setSubSalario(float SubSalario) {
        this.SubSalario = SubSalario;
    }
    public float getSalarioTotal() {
        return SalarioTotal;
    }
    public void setSalarioTotal(float SalarioTotal) {
        this.SalarioTotal = SalarioTotal;
    }
    public float getPagoPorHora() {
        return PagoPorHora;
    }
    public void setPagoPorHora(float PagoPorHora) {
        this.PagoPorHora = PagoPorHora;
    }
    public void Captura(){
    nombre=JOptionPane.showInputDialog("NOMBRE:");
    HorasTrabajadas=Integer.parseInt(JOptionPane.showInputDialog("¿CUANTAS HORAS TRABAJÓ?"));//pedimos las horas trabajadas
    }
    public void CalcularSalario(){
        if (HorasTrabajadas>8){ //si la el empleado trabajó mas de ocho horas se realaizará el siguiente procedimiento
                SubSalario=(HorasTrabajadas-8)*(PagoPorHora*1.5f); //cuando se escribe un número con decimal se le agrega una f
                                                                   //de lo contrario nos marcará error
                SalarioTotal=(8*PagoPorHora)+SubSalario;
        }
        else{ // si la primera condición no se cumple entonces se realizará el siguiente procedimiento
                SalarioTotal=HorasTrabajadas*PagoPorHora
        }
    }
    public void ImprimirSalario(){
    JOptionPane.showMessageDialog(null,"***SALARIO DIARIO***\n\n"
                                  +"NOMBRES: "+nombre+"\n HORAS TRABAJADAS: "+HorasTrabajadas
                                  +"\nSALARIO DIARIO TOTAL: "+SalarioTotal);// imprimimos los resultados con una cadena
    }
}

2da. Clase: Usar

  • Programa
package Salario_Diario;
import javax.swing.JOptionPane;
public class Usar {
    public static void main (String arg[]){
        Calcular_Salario d;
        d=new Calcular_Salario();
        
        d.Captura(); //mandamos a llamar a los métodos
        d.CalcularSalario();
        d.ImprimirSalario();
    }
}

Ejecutar el Programa

Ejecutamos el programa....


...insertamos el nombre de el empleado....



                                     

                                     .... ahora insertamos las horas trabajadas...



... y estos son los resultados.







Conclusión:
En los problemas hay ciertos valores de algunas variables que se necesitan ser insertadas, pero hay otras, en las que su valor está definido, citamos los dos ejemplos en este problema. La mejor manera de organizar esto es estructurando lo datos y separar las clases en métodos.

TORRES DE HANOI

El segundo ejemplo más usado para la recursividad, es el juego de las Torres de Hanoi.
¿En que consiste el juego?
Representación Gráfica del juego
El juego tiene como elementos un base que contiene tres torres o varillas, en la primera, se encuentra una cierta cantidad de discos de diferentes tamaños ordenados de mayor a menor, de abajo hacia arriba. El juego consiste en llevar todos los discos a la tercera torre usando la segunda como auxiliar, tomando en cuenta las siguientes reglas:
  1. Solo se puede mover un disco a las vez, por lo tanto soló se moverá el disco que está arriba de cualquiera de las torres
  2. No se puede colocar un disco sobre otro mas pequeño
Este juego está basado en un leyenda muy antigua, aquí la tienen:

La leyenda...
“En el gran templo de Benarés, debajo de la cúpula que marca el centro del mundo, yace una base de bronce, en donde se encuentran acomodadas tres agujas de diamante, cada una del grueso del cuerpo de una abeja y de una altura de 50 cm aproximadamente. En una de estas agujas, Dios, en el momento de la Creación, colocó sesenta y cuatro discos de oro -el mayor sobre la base de bronce, y el resto de menor tamaño conforme se va ascendiendo-. Día y noche, incesantemente, los sacerdotes del templo se turnan en el trabajo de mover los discos de una aguja a otra de acuerdo con las leyes impuestas e inmutables de Brahma, que requieren que siempre haya algún sacerdote trabajando, que no muevan más de un disco a la vez y que deben colocar cada disco en alguna de las agujas de modo que no cubra a un disco de radio menor. Cuando los sesenta y cuatro discos hayan sido transferidos de la aguja en la que Dios los colocó, en el momento de la Creación, a otra aguja, el templo y los brahmanes se convertirán en polvo y, junto con ellos, el mundo desaparecerá...

.... y siguiendo con el tema....

Problema: 
  • Realizar un programa que muestre indicaciones para resolver el juego de las Torres de Hanoi, con n discos.
Nota: Usaremos dos clases, Torres De Hanoi y Jugar, en  la primera se harán las operaciones correspondientes y en el segundo se hará uso de la primera clase.


1ra. Clase: Torres.

  • Diagrama UML:










  • Programa:
package Torres_de_Hanoi;
import javax.swing.JOptionPane;
public class TorresDeHanoi {
    private int NumeroDeDiscos; // Esta variable nos indicará                                        cuantos discos van a usarse.
    private int NumeroDeMovimientos;
// Indicará el total de movimientos hechos para resolver el juego
    public int getNumeroDeDiscos(){//encapsulamiento de variables
        return NumeroDeDiscos;
    }
    public void setNumeroDeDiscos(int NumeroDeDiscos) {
        this.NumeroDeDiscos = NumeroDeDiscos;
    }
    public int getNumeroDeMovimientos() {
        return NumeroDeMovimientos;
    }
    public void setNumeroDeMovimientos(int NumeroDeMovimientos) {
        this.NumeroDeMovimientos = NumeroDeMovimientos;
    }
    public void Captura(){
    NumeroDeDiscos=Integer.parseInt(JOptionPane.showInputDialog("¿CUANTOS DISCOS SON?:"));
    }
    public void Intercambio(int NumDiscos, char A, char B, char C){ 
//Los parámetros se envían a la segunda clase
/*Tomemos en cuenta que el parámetro A, tomará el lugar de la torre inicio, la que inicialmente contiene todos los discos; el parámetro B, será la torre auxiliar; y el parámetro C será la torre destino, donde quedarán al final de juego todas las fichas*/      
       if (NumDiscos==1){
/*si el número de discos es igual a uno, lógicamente se moverá el disco de la torre inicio directamente a la de destino*/ 
           setNumeroDeMovimientos(getNumeroDeMovimientos()+1);
           JOptionPane.showMessageDialog(null, "Mover disco "+NumDiscos+" de la torre "+A+" a la torre "+C+"\nMOVIMIENTOS: "+NumeroDeMovimientos);
           }
        else{/*si la condicion primera no se cumple, quiere decir que se realizarán mas movimientos y serán los siguientes*/
            Intercambio(NumDiscos-1,A,C,B); 
/*... y entonces el método se llama a sí mismo, moviendo primero, el disco de la torre A, inicio, a la torre C, destino*/
            setNumeroDeMovimientos(getNumeroDeMovimientos()+1);
//se suman los movimientos efectuados
            JOptionPane.showMessageDialog(null,"Mover disco "+NumDiscos+" de la torre "+A+" a la torre "+C+"\nMOVIMIENTOS: "+NumeroDeMovimientos);
            Intercambio(NumDiscos-1,B,A,C);
/*... el método vuelve a llamarse a sí mismo, esta vez los parámetros donde de se encontraba la variable A ahora estará la variable B, para indicar el siguiente movimiento*/
           }
    }
    public void Movimientos() {
    JOptionPane.showMessageDialog(null,"TOTAL DE MOVIMIENTOS: "+NumeroDeMovimientos);
    }
}
    

2da. Clase: Jugar.

Nos vamos directamente con el programa...
  • Programa
package Torres_de_Hanoi;
import javax.swing.JOptionPane;
public class Jugar {
    public static void main(String arg[]){
     TorresDeHanoi k;
     
     k=new TorresDeHanoi(); 
// se declara y crea la variable que llama a la primera clase  
     k.Captura();                        
     k.Intercambio(k.getNumeroDeDiscos(),'A','B','C'); 
// se reciben los parámetros de el método Intercambio
     k.Movimientos();
    }
}

Ejecutar el programa

Aparte de los objetos corridos por el programa le acompañaré con una representación paso a paso de el juego.

Corremos el programa, desde la clase jugar, y la primera ventana nos pide el numero de discos a usar, en este caso, usaremos tres, y entonces nuestros elementos quedarán así...



y los movimientos serán de la siguiente manera.....


...movimiento #1...









.... movimiento #2...










.... movimiento #3....








.... movimiento #4....








.... movimiento #5....








.... movimiento #6....








.... movimiento #7....








... y finalmente.








Conclusión:
Las torres de Hanoi es uno de los ejemplos usados para el tema de recursividad, debido a que este juego forma parte de los problemas que se resuelven usando este termino. Se podría explicar la recursividad como un procedimiento que se usa cuando se requiere de que cierta acción, se tenga que hacer repetidas veces hasta cumplir con cierto límite, tenemos el ejemplo de las Torres de Hanoi, aquí se tiende a realizar la misma acción, misma que consiste en sacar una ficha de una torre y colocarla en otra, la veces necesarias hasta que todos los discos queden en la torre destino. 

viernes, 20 de septiembre de 2013

FACTORIAL DE UN NUMERO

RECURSIVIDAD

Es una técnica utilizada en programación para realizar una función o procedimiento llamándose a sí misma. Para hacer más ententdible esta técnica realizaremos el siguiente problema:

Problema:
Calcular el factorial de un número.

Recordemos que para obtener el factorial de un número este se multiplica por todos los números naturales anteriores o iguales a el. Por ejemplo: 

5!= 1x2x3x4x5=120
4!= 1x2x3x4= 24

Nota: Para realizar este algoritmo usaremos dos clases: una que realice el factorial y otra que la ejecute.

1ra. Clase: Factorial.

  • Diagrama UML:











  • Programa
package FactorialDeUnNumero;
import javax.swing.JOptionPane;
public class Factorial {
    private int fact;//se declaran variables
    private int numero;
    //se encapsulan las variables
    public int getFactorial() {
        return fact;
    }
    public void setFactorial(int factorial) {
        this.fact = fact;
    }
    public int getNumero() {
        return numero;
    }
    public void setNumero(int numero) {
        this.numero = numero;
    }
    public void Captura(){
    numero=Integer.parseInt(JOptionPane.showInputDialog("NUMERO A CALCULAR: "));//se captura el numero a calcular
    }
    public int CalcularFactorial(int num){//utilizaremos un parámetro de tipo entero
     if(num==1 || num==0) /* como lo dice la regla de factorial: si numero es igual a cero o a 1, entonces su factorial es igual a 1*/
          {
            return 1; //si se cumple la condición se 1
          }
     else // si no se cumple, se realizara la operación siguiente
          {
/* y aquí es donde se encuentra la técnica recursiva, consiste en multiplicar el valor dado por el mismo menos 1; por ejemplo, si el valor es 5, entonces multiplicará 5 por 5-1, osea 5 por 4, y posteriormente el resultado se multiplicará por 4-1, osea, 3; y así sucesivamente hasta que el resultado se multiplique por 2-1, osea 1. */
            fact=num*CalcularFactorial(num-1);
            return fact;                      
          }                                   
    }                                        
    public void ImprimirFactorial(){          
    JOptionPane.showMessageDialog(null,"EL FACTORIAL DE "+numero+" ES "+fact);    
    }
}

2da. Clase: Solución.

  • Diagrama UML:













  • Programa
package FactorialDeUnNumero;
import javax.swing.JOptionPane;
public class Solucion {
    public static void main(String arg[]){
     Factorial n;// se declaran las variables
     n= new Factorial();//se crean las variables
    
     n.Captura(); // los objetos hacen el llamado a los métodos
     n.CalcularFactorial(n.getNumero());
     n.ImprimirFactorial();
     
    }
}

Ejecutar el programa


Insertamos el número a calcular....

.. en otra ventana nos mostrara el resultado.





Conclusión:
La técnica recursiva es un poco complicada de entender, basta con un poco de práctica para entenderla en su totalidad.  Hemos aprendido a realizar el factorial de un número por medio de un programa estructurado, una vez más demostramos que dividiendo las clases en diferentes métodos, el entendimiento de el mismo es más sencillo.

CALCULAR ÁREAS Y PERÍMETROS (triángulos y rectángulos)

Problema:
  • Elaborar un programa que calcule el área y perímetro de tres rectángulos y tres triángulos.
Nota: Dividiremos el programa en tres clases: triángulo, rectángulo y solución.

1ra. Clase: Triangulo.

Esta primera clase la construiremos para que haga el cálculo de el área y perímetro de los triángulos, misma clase que después será llamada desde la clase Solución.

  • Diagrama UML:
El diagrama UML es uno de los elementos principales para la solución de problemas en la estructura de datos orientada a objetos, este diagrama facilita el entendimiento del problema, ya que divide en tres partes el mismo, la primera parte es quien lleva el nombre que identifica a la clase; la segunda parte contiene los atributos que tendrá el objeto identificado de nuestra clase, esto acompañado del tipo de dato que tendrá; y por último la tercera parte contiene el nombre de los procedimientos o más bien métodos que se realizarán.

Para facilitar la construcción del diagrama, recomiendo usar ArgoUML, lo pueden descargar desde este link http://argouml.tigris.org/, aquí podemos apoyarnos para aprender a usarlo http://www.youtube.com/watch?v=mHfw4Q5xubU.

Y el diagrama queda así:

Nuestro objeto es el tríangulo, tiene una base, una altura, y porsteriormente serán calculadas su área y su perímetro, para llegar a esto primero capturaremos los datos, después se calcula área, siguiendo con perímetro y se imprimiran los resultados.

  • Programa:
Nota: para construir el programa estoy usando NetBeans, es gratuito y muy recomendable, si no lo tienes puedes descargarlo desde aquí https://netbeans.org/downloads/.

package Areas_Perímetros; // identificamos el paquete en el que se encuentra nuestra clase
import javax.swing.JOptionPane; // Aqui mandamos a llamar la libreria que vamos a usar
public class Triangulo // el nombre de nuestra clase
{ //inicia la clase
    private int base; // se declaran las variables a usar
                       //(atributos que fueron mostrados en el diagrama UML)
    private int altura;
    private int área;
    private int perimetro
        /*vamos a encapsular nuestras variables con get y set se utiliza get para que
        lea o guarde el valor de la variable y set para que se pueda cambiar el valor 
        de la variable. Esto se puede realizar de manera directa simplemente dando click
        derecho en  Refactor/Encapsulate Fields, seleccionas todas las fichas de get y set
        y despues en Refactor, y creara los métodos con set y get.
        */
    public int getBase() { 
        return base; // manda la variable
    }
    public void setBase(int base) { //recibe la variable
        this.base = base; 
    }
    public int getAltura() {
        return altura;
    }
    public void setAltura(int altura) {
        this.altura = altura;
    }
    public int getÁrea() {
        return área;
    }
    public void setÁrea(int área) {
        this.área = área;
    }
    public int getPerimetro() {
        return perimetro;
    }
    public void setPerimetro(int perimetro) {
        this.perimetro = perimetro;
    }
    
    public void Captura(){ // se piden los valores de base y altura de el triangulo
        base=Integer.parseInt(JOptionPane.showInputDialog("BASE:"));
        altura=Integer.parseInt(JOptionPane.showInputDialog("ALTURA:"));
    }
    public void CalcularArea() { 
     área=(base*altura)/2; 
    }
    public void CalcularPerimetro(){
     perimetro=(base*3);//suponiendo que es un triángulo equilátero
    }
    public void Imprimir(){  
    JOptionPane.showMessageDialog(null,"EL ÁREA ES: "+área+"\nEL PERÍMETRO ES: "+perimetro);
    }
}// termina la clase

2da. Clase: Rectangulo

De la misma forma que con la clase triangulo, construiremos la clase Rectángulo:

  • Diagrama UML













  • Programa
package Areas_Perímetros;
import javax.swing.JOptionPane;
public class Rectángulo 
{
    private int base;
    private int altura;
    private int área;
    private int perimetro;
   
    public int getBase() {
        return base;
    }
    public void setBase(int base) {
        this.base = base;
    }
    public int getAltura() {
        return altura;
    }
    public void setAltura(int altura) {
        this.altura = altura;
    }
    public int getÁrea() {
        return área;
    }
    public void setÁrea(int área) {
        this.área = área;
    }
    public int getPerimetro() {
        return perimetro;
    }
    public void setPerimetro(int perimetro) {
        this.perimetro = perimetro;
    }
    
    public void Captura(){
        base=Integer.parseInt(JOptionPane.showInputDialog("BASE:"));
        altura=Integer.parseInt(JOptionPane.showInputDialog("ALTURA:"));
    }
    public void CalcularArea() {
     área=(base*altura);
    }
    public void CalcularPerimetro(){
     perimetro=base+base+altura+altura;
    }
    public void Imprimir(){  
    JOptionPane.showMessageDialog(null,"EL ÁREA ES: "+área+"\n EL PERÍMETRO ES: "+perimetro);
    }
}

3ra. Clase: Solucion

En esta clase se dará uso a las clases anteriores, se le asignan los métodos a los objetos correspondiente a su clase. Para ello deberán declararse y crearse los objetos.

  • Diagrama UML:












  • Programa:
package Areas_Perímetros;
import javax.swing.JOptionPane;
public class Solución {
   
    public static void main (String arr[]){ 
    //se declaran objetos
        Rectángulo rect1, rect2, rect3;
        // se crean los objetos
        rect1=new Rectángulo();
        rect2=new Rectángulo();
        rect3=new Rectángulo();
        
        JOptionPane.showMessageDialog(null,"CALCULO DE AREAS Y PERIMETROS DE LOS RECTANGULOS");
        JOptionPane.showMessageDialog(null,"RECTANGULO #1");
        rect1.Captura(); //el objeto mando a llamar al método que va a usar
        rect1.CalcularArea();
        rect1.CalcularPerimetro();
        rect1.Imprimir();
        
        JOptionPane.showMessageDialog(null,"RECTANGULO #2");
        rect2.Captura();
        rect2.CalcularArea();
        rect2.CalcularPerimetro();
        rect2.Imprimir();
        
        JOptionPane.showMessageDialog(null,"RECTANGULO #3");
        rect3.Captura();
        rect3.CalcularArea();
        rect3.CalcularPerimetro();
        rect3.Imprimir();
   
        Triangulo tri1, tri2, tri3;
        
        tri1=new Triangulo();
        tri2=new Triangulo();
        tri3=new Triangulo();
        
        JOptionPane.showMessageDialog(null,"CALCULO DE AREAS Y PERIMETROS DE LOS TRIANGULOS");
        JOptionPane.showMessageDialog(null,"TRIANGULO #1");
        tri1.Captura();
        tri1.CalcularArea();
        tri1.CalcularPerimetro();
        tri1.Imprimir();
        
        JOptionPane.showMessageDialog(null,"TRIANGULO #2");
        tri2.Captura();
        tri2.CalcularArea();
        tri2.CalcularPerimetro();
        tri2.Imprimir();
        
        JOptionPane.showMessageDialog(null,"TRIANGULO #3");
        tri3.Captura();
        tri3.CalcularArea();
        tri3.CalcularPerimetro();
        tri3.Imprimir();
        
        
    }
}

Ejecutar el programa


Al ejecutarse el programa aparecerá la primera ventana que indica que se realizará el calculo de las áreas y perímetros de los rectángulos...
...después indicará a que número de rectángulo se le realizará el calculo. Recordando que el problema pedía el calculo para tres triángulos y tres rectángulos...

 ... enseguida se realizará la captura de la base de el rectangulo.....
                                    .... lo mismo con la altura...
 .... y por último mostrará los resultados...





.... lo mismo será para los triángulos.











Conclusión:
Una manera mas ordenada, sencilla y entendible de realizar un programa , es dividiéndolo en métodos y clases, recordando siempre que un problema puede dividirse en clases, cada clase tiene un objeto, a su vez, cada objeto tiene atributos o propiedades, unos serán capturados, otros, serán calculados en la clase, para realizar esto basta con crear métodos que hagan las actividades o procedimientos que se necesitan para resolver el problema.