Está en la página 1de 5

2.

2 Estructura general de una aplicación en JAVA

Para escribir un programa en Java orientado a objetos se requiere por lo menos


de dos clases:
 La primera clase en este caso llamada Uno contiene la lógica de los
procesos o tareas a realizar siendo esta un tipo de dato creada por el
usuario y es utilizada por el programa principal.
Cabe destacar que se pueden construir varias clases para la lógica
de procesos.

 La segunda clase en este caso llamada Principal que contiene el


método main ( ) e identifica el programa principal. En el momento
de ejecutar el programa esta es la clase que se le da la orden para
que sea ejecutada por el computador.

import ... //Sección de sentencias de IMPORTACION de paquetes o


librerías
class Uno // Sección de declaración de las clases deseadas (puede no
haber ninguna)
{ declaración datos o atributos de la clase
Los datos o atributos (constantes o variables)
métodos ( ) son globales a la clase, se pueden utilizar en
{ variables cualquier método perteneciente a la clase.

bloque de sentencias
: Las variables son locales al método, se crean cuando
se ejecuta el método y se destruyen al finalizar de
ejecutar el método.
}
}
class Principal //Declaración de la clase que contiene el método main( )
{ public static void main (String arg[ ]) La clase que tiene el main
{ declaración de variables constituye el punto de partida del
: programa.
La clase Uno está definida
por el programador que
contiene los datos o Uno obj = new Uno( ); //creación del objeto
bloque sentencias
: Método constructor de la clase
Uno. Método por defecto y
} tiene el mismo nombre de la
} clase
Problema Resuelto

Definición o dominio del Problema:

Leer los datos de un triángulo, calcular la hipotenusa

h = √ (cat12 + cat22) y presentar el resultado.

Metodología de Trabajo POO

Análisis

Entrada de datos flotante cat1, cat2

Proceso Métodos: asignar_val ()


calcular_hip ()
~ Hipotenusa ()

Salida h

Identificar las abstracciones (clases)


Nombre de la clase: Hipotenusa

Diseño de clases en (UML)

Hipotenusa
Nombre de la clase
- flotante cat1
- flotante cat2
Datos o atributos

+ flotante calcular_hip()
+asignar_val (flotante a flotante b)
Métodos
~ Hipotenusa ()
/* Algoritmo */

clase Hipotenusa {

privado flotante cat1, cat2

publico asignar_val ( flotante a, flotante b) {


cat1 = a
cat2 = b }

publico flotante calcular_hip ( )


{ flotante h
h =√ cat1 ** 2 + cat2 **2
retornar h }
}

INICIO.
/* Declaración de variables */
flotante a, b , res
/* se crea el objeto de la clase */
Hipotenusa obj_hip

Imprimir (“ENTRAR EL VALOR DE A :”)


Leer (a)
Imprimir (“ENTRAR EL VALOR DE B :”)
Leer (b)

/* Activación de mensajes */
obj_hip.asignar_val( a, b)
res = obj_hip.calcular_hip()
Imprimir (“HIPOTENUSA ES:”, res)
FIN
/* Programación en: Java */

import java.io.*;
class Hipotenusa
{ private float cat1,cat2;

public void asignar_val(float a, float b)


{ cat1=a;
cat2=b; }

public double calcular_hip()


{double h;
h=Math.sqrt(Math.pow(cat1,2) + Math.pow(cat2,2));
return (h);
}
}

//Programa Principal
class Hipotenusapp
{ public static void main (String [] arg) throws IOException {
//Se recomienda utilizar try/catch para control
//adecuado de Exception
BufferedReader br =
new BufferedReader (new InputStreamReader (System.in));
float a,b;
double res;

/* se crea el objeto */
Hipotenusa obj_hip = new Hipotenusa();

System.out.println("Entrar el valor de a:");


a= Float.parseFloat(br.readLine());
System.out.println("Entrar el valor de b:");
b= Float.parseFloat(br.readLine());

//Activación de mensajes o llamado de métodos a ejecutar


obj_hip.asignar_val(a,b);
res=obj_hip.calcular_hip();
System.out.println("Hipotenusa es = "+res);
}
}

Desarrollar el problema siguiente en salón de clases por la profesora:

Leer dos números, calcular e imprimir la suma.


Cuando se explica el try/catch , se debe desarrollar el programa con try/catch