Texto de Tecnicas de Programacion

Texto para el curso de
Técnicas de Programa-
ción del II ciclo de la es-
cuela de Ingeniería de
Sistemas de la ULADECH
Programación orientado a
objetos
Contiene el uso de las clases de Java y sus métodos, creación de métodos,
recursividad y sobrecarga de métodos, arreglos, miembros de una clase,
relaciones de clases, niveles de acceso de los miembros de una clase, operador
this, herencia de clases, clases abstractas, interfaces, polimorfismo, paquetes y
excepciones
Elaborado por:
Ing. Martín Salcedo

Quiñones
TECNICAS DE PROGRAMACION
Universidad Católica los Angeles de Chimbote
INDICE
Página
CAPITULO I: Uso y creación de métodos. 03
Métodos de clases de Java 04
Creación de métodos 22
Recursividad y sobrecarga de métodos 34
Arreglos unidimensionales en métodos 45
CAPITULO II:Programación orientada a objetos 59
Clases y sus miembros 60
Relaciones entre clases 79
Modificadores de acceso a los miembros de una clase 92
Métodos constructores y la referencia this 107
CAPITULO III: Herencia, clases abstractas, interfaces y polimorfismo 119
Herencia de clases 120
Clases abstractas 137
Interfaces y herencia múltiple 149
Polimorfismo 163
CAPITULO IV: Paquetes, excepciones y desarrollo de un proyecto 179
Paquetes 180
Manejo de excepciones e hilos 185
Proyecto Tienda 193
Docente: Ing. Martín Salcedo Quiñones Pagina: 2

CAPITULO I
USO Y CREACION DE METODOS

METODOS DE CLASES DE JAVA
ESTRUCTURA DE UNA APLICACIÓN DE JAVA SENCILLA

public class HolaMundo{
public static void main(String args[])
{
System.out.println(“! Hola Mundo ! “);
}
}
Al escribir una aplicación sencilla de Java se debe definir un método main, que
se procesa cuando el programa inicia su ejecución. En el método main se
especifican las funciones que realiza el programa.
Toda aplicación se comienza declarando una clase con la palabra public class
y un nombre, y este nombre tiene que ser idéntico al nombre del archivo que se
va a grabar pero con extensión Java.
En el ejemplo al colocar public class HolaMundo se esta declarando la clase
llamada HolaMundo.
El archivo se debe grabar como HolaMundo.java igual que el nombre de la
clase.
Dentro de main, la aplicación utiliza el metodo System.out.println para
desplegar el mensaje “¡Hola Mundo!” en la consola del Sistema.
Para compilar un programa de Java se hace lo siguiente

C:\JDK1.3\BIN>javac HolaMundo.java <Intro>
Al hacer esto se crea un archivo llamado HolaMundo.class que es un archivo

que se encuentra en bytecode
Después de esto se utiliza el comando java para interpretar y ejecutar el

bytecode de la aplicación.
C:\JDK1.3\BIN>java HolaMundo <Intro>

¡ Hola Mundo !
- Las instrucciones en un programa Java se escriben en minúsculas

- El símbolo de punto y coma (;) se utiliza para separar una instrucción de
la siguiente.
- Un bloque de código es una serie de instrucciones y/o declaraciones de
Java rodeadas por un par de llaves {}
Por ejemplo para comenzar la clase comienza con { y termina con }. Asi
mismo el método main comienza con un { y termina con un }. El uso de
los bloque de código es importante para indicar que se van a realizar un
conjunto de instrucciones.
La clase BufferedReader para entrada de datos

La E/S básica por terminal con formato se lleva a cabo mediante readLine y
println . La entrada estándar es System.in y la salida estándar es System.out.
El mecanismo básico para E/S con formato utiliza el tipo String. En la salida +
combina dos valores de tipo String. Si el segundo argumento no es un valor de
tipo String, se crea un valor temporal de tipo String para el, siempre que sea de
tipo primitivo. Estas conversiones al tipo String se pueden definir también para
objetos.
Ejemplo:
System.out.println(“El resultado es “+R);

Un modo sencillo de realizar una lectura de la entrada es leer una sola línea
almacenándola en un objeto de tipo String, para lo que se emplea el método
readLine. Este método lee hasta que encuentra un final de línea o el final del
fichero. Los caracteres leídos salvo el final de Línea (en el caso de que se
encuentre), se devuelven como un nuevo String. Para emplear readLine, se
debe construir un objeto BufferedReader sobre un objeto InputStreamReader
que a su vez se crea a partir de System.in.
Ejemplo:
BufferedReader in = new BufferedReader( new

InputStreamReader(System.in));
String nombre;
System.out.println(“Introduzca una nombre : “);
nombre = in.readLine();
En este ejemplo se ha declarado una variable nombre de tipo String y se esta

leyendo desde la consola utilizando un objeto llamado in el cual llama al
método readLine para leer una cadena y asignarle a la variable nombre.
La clase Math
La clase Math representa la librería matemática de Java. Las funciones que

contiene son las de todos los lenguajes, parece que se han metido en una
clase solamente a propósito de agrupación, por eso se encapsulan en Math, y
lo mismo sucede con las demás clases que corresponden a objetos que tienen
un tipo equivalente (Character, Float, etc.). El constructor de la clase es
privado, por los que no se pueden crear instancias de la clase. Sin embargo,
Math es public para que se pueda llamar desde cualquier sitio y static para que
no haya que inicializarla.
Math tiene una referencia a las dos constantes más utilizadas en matemática
con una precisión de 15 decimales (suficiente para la mayoría de los mortales).
Si ejecutamos:
System.out.println("e = " + Math.E);

System.out.println("pi = " + Math.PI);
veremos:
e = 2.718281828459045
pi = 3.141592653589793
Los métodos que tiene la clase Math son:

Math.abs( x ) para int, long, float y double
Math.sin( double )
Math.cos( double )
Math.tan( double )
Math.asin( double )
Math.acos( double )
Math.atan( double )
Math.atan2( double,double )
Math.exp( double )
Math.log( double )
Math.sqrt( double )
Math.ceil( double )
Math.floor( double )
Math.rint( double )
Math.pow( a,b )
Math.round( x ) para double y float
Math.random() devuelve un double
Math.max( a,b ) para int, long, float y double
Math.min( a,b ) para int, long, float y double
Math.E para la base exponencial
Math.PI para PI
La clase Integer
Cada tipo numérico tiene su propia clase de objetos. Así el tipo int tiene el
objeto Integer. Se han codificado muchos métodos útiles dentro de la clase
Integer como son:
 String Integer.toString( int i,int base );

 String Integer.toString( int i );
Por ejemplo:
int valor=38;
String cadena;

cadena=Integer.toString(valor); //no colcarle base se assume que es base 10
 int I.parseInt( String s,int base );

 int I.parseInt( String s );
Por ejemplo:
String dato=”20”;
int valor;
valor=Integer.parseInt(dato); //no colcarle base se assume que es base 10
 Integer Integer.valueOf( String s,int base );

 Integer Integer.valueOf( String s );
 int I.intValue();
 long I.longValue();
 float I.floatValue();
 double I.doubleValue();
 String I.toString();
La clase Character
Al trabajar con caracteres se necesitan muchas funciones de comprobación y

traslación. Estas funciones están empleadas en la clase Character . De esta
clase sí que se pueden crear instancias, al contrario que sucede con la clase
Math .
Declaraciones
La primera sentencia creará una variable carácter y la segunda un objeto

Character:
char c;
Character C;
Comprobaciones booleanas

Character.isLowerCase(c) //devuelve verdadero si el character está en minúscula

Character.isUpperCase(c) //devuelve verdadero si el character está en mayúscula
Character.isDigit(c) // devuelve verdaero si el carácter es un dígito numérico
Character.isSpace(c) //devuelve verdaero si el character es un espacio y falso todo lo
contrario
En este caso, si tuviésemos un objeto Character C , no se podría hacer

C.isLowerCase , porque no se ha hecho un new de Character. Estas funciones
son estáticas y no conocen al objeto, por eso hay que crearlo antes.
Traslaciones de caracteres
char c2 = Character.toLowerCase( c );
char c2 = Character.toUpperCase( c );
Traslaciones de carácter/dígito
int i = Character.digit( c,base );

char c = Character.forDigit( i,base );
Métodos de la clase Character
C = new Character( 'J' );

char c = C.charValue();
String s = C.toString();
La clase Float
Cada tipo numérico tiene su propia clase de objetos. Así el tipo float tiene el
objeto Float. De la misma forma que con la clase Character , se han codificado
muchas funciones útiles dentro de los métodos de la clase Float .
Declaraciones
La primera sentencia creará una variable float y la segunda un objeto Float:
float f;
Float F;

Conversiones de Clase/Cadena
String s = Float.toString( f );
f = Float.valueOf( "3.14" );
Comprobaciones
boolean b = Float.isNaN( f );
boolean b = Float.isInfinite( f );
La función isNaN() comprueba si f es un No-Número . Un ejemplo de no-

número es raiz cuadrada de -2.
Conversiones de Objetos
Float F = new Float( Float.PI );
String s = F.toString();
int i = F.intValue();
long l = F.longValue();
float F = F.floatValue();
double d = F.doubleValue();
La clase Double
Cada tipo numérico tiene su propia clase de objetos. Así el tipo double tiene el
objeto Double . De la misma forma que con la clase Character , se han
codificado muchas funciones útiles dentro de los métodos de la clase Double .
Declaraciones
La primera sentencia creará una variable double y la segunda un objeto

Double:
double d;
Double D;
Métodos más usados en Double

boolean D.equals();
String D.toString();
int D.intValue();
long D.longValue();
float D.floatValue();
double D.doubleValue();
Double V.valueOf( String s );
Clase String
Esta clase almacena una cadena de caracteres. Una cadena es una serie de caracteres que
se trata como una unidad. Una cadena puede incluir letras, dígitos y diversos caracteres
especiales como +,-,*,/,$ y otros.
Una cadena en Java es un objeto de la clase String.
Los literales de cadena o constantes de cadena en Java se escriben como una secuencia
de caracteres cerrada entre comillas.
Ejemplo:
“Computación”, “Java es fácil”,
Los métodos mas utilizados son:
cadena.length() : El método length Devuelve el numero de Caracteres de una cadena.

Ejemplo:
String nombre = “Francisco”;
int n;
n = cadena.length();
System.out.println(“El nombre : “+ nombre + “tiene “+ n + ”Caracteres”);
cadena1.equals(cadena2) : El método equals devuelve true si las dos cadenas son

iguales y false en caso contrario..
cadena1.equalsIgnoreCase(cadena2) : El método equalsIgnoreCase no toma en cuenta

la diferencia entre letras mayúsculas y minúsculas de cada String al realizar la
comparación.
cadena1.compareTo(cadena2) : El método compareTo devuelve un numero entero:

> 0 Si cadena1 es mayor que cadena2
= 0 Si las cadenas son exactamente iguales

< 0 Si cadena1 es menor que cadena2

Este método emplea una comparación lexicográfica.
cadena1.compareToIgnoreCase(cadena2) : El método compareToIgnoreCase no toma

en cuenta la diferecia entre las mayúsculas y minúsculas de cada String al realizar la
comparación.
cadena.charAt(indice) : El método charAt delvuelve el carácter que indica el indice.

Ejemplo:
String nombre = “Felipe”;
Char x;
X=nombre.charAt(3); // x toma el valor del carácter i.
Los indices de una cadena comienzan en 0.
cadena.toUpperCase() : Convierte la cadena a mayúsculas
cadena.toLowerCase() : Convierte la cadena en minúsculas
cadena.trim() : Elimina los espacios al inicio y al final de la cadena.
cadena1.startsWith(cadena2) : Devuelve verdadero si cadena1 comienza con cadena2.
cadena1.endsWith(cadena2) : Devuelve verdadero si cadena1 finaliza con cadena2.
cadena.indexOf(caracter) : Devuelve el índice de la primera ocurrencia del carácter.
cadena.indexOf(carácter,posicion) : Devuelve el índice de la primera ocurrencia del

carácter , comenzando la búsqueda a partir de posición.
cadena1.indexOf(cadena2) : devuelve el índice de la primera ocurrencia de cadena2 en

cadena1.
cadena1.indexOf(cadena2,posición): Devuelve el índice de la primera ocurrencia de la

cadena2 en cadena1, comenzado la búsqueda a partir de posición.
cadena.lastIndexOf(caracter) : Devuelve el índice de la ultima ocurrencia del carácter.
cadena.lastIndexOf(carácter,posicion) : Devuelve el índice de la ultima ocurrencia del

carácter , comenzando la búsqueda a partir de posición.
cadena1.lastIndexOf(cadena2) : devuelve el índice de la ultima ocurrencia de cadena2

en cadena1.
cadena1.lastIndexOf(cadena2,posición): Devuelve el índice de la ultima ocurrencia de

la cadena2 en cadena1, comenzado la búsqueda a partir de posición.
cadena.substring(indice) : Devuelve una subcadena que esta conformada por todos los
caracteres que comienzan en indice e incluye todos los caracteres siguientes hasta el fin
de la cadena.
cadena.substring(indiceInicial, indiceFinal) : Devuelve una subcadena que esta

conformada por todos los caracteres cuyo indice comienza en indiceInicial e incluye
todos los caracteres hasta el IndiceFinal-1.
String.valueOf() : Convierte tipos primitivos a cadenas. La clase String sobrecarga el

método valueOf para soportar cada uno de los tipos primitivos de Java.
Ejemplo:
String cad1 = String.valueOf(12);
String cad2 = String.valueOf(true);
String cad3 = String.valueOf(‘T’);
String cad4 = String.valueOf(12.9867);
Aquí presentaremos algunas aplicaciones sencillas.
PROGRAMAS RESUELTOS
1) Hacer un programa para calcular el area de un triangulo dada la base y

la altura
import java.io.*;
public class AreaTriangulo{

public static void main(String arg[]) throws IOException

{
float base,altura,area;
BufferedReader in = new BufferedReader(new
System.out.print("Ingrese base del triangulo :");
base=Float.parseFloat(in.readLine());
System.out.print("Ingrese altura del triangulo :");
altura=Float.parseFloat(in.readLine());
area=base*altura/2;
System.out.println("El area del triangulo es : "+area);
}
}
Interpretación de la programación:
Al usar import.java.io.*; importamos el paquete io (input output) que permitirá
luego para el ingreso y salida de datos. Tenemos la clase AreaTriangulo que
tienen al método estático llamado main que al colocar (String args[]) indica que
no hay argumento alguno para el método y al colocar throws IOException son
nuestra indicación al compilador de que estamos conscientes del hecho de que
puede ocurrir una excepción (intercepción de error) de entrada/salida cuando el
programa intente leer del teclado y que deliberadamente estamos haciendo
caso omiso de tales excepciones de entrada/salida en nuestro programa.
Luego se declara las variables base, altura y area de tipo float. Posteriormente
se declara la variable in del tipo BufferedReader y se crea el objeto in con el
operador new usando el método constructor BufferedReader, la misma que
usa el InputStreamReader, clase o interfaz que permite la lectura de entrada a
través del teclado, es decir, la variable objeto in es la permitirá luego lograr
ingresar datos. Luego con el método print usado a partir de System.out permite
imprimir una expresión como por ejemplo “Ingrese la base del triángulo:”. En la
línea de la programación base= Float.parseFloat(in.readLine()); se busca el
ingreso de un dato que se lee con el método readLine() a partir del objeto in

previamente creado. Dado que el dato ingresado es de tipo String o cadena es

necesario la conversión a un dato del tipo de la variable que almacenará dicho
dato, por lo que es necesario usar un método de conversión como es el caso
de parseFloat() que hace que el dato ingresado sea convertido al tipo de dato
Float y luego asignado a la variable base. Lo mismo se hace con respecto a la
variable altura. En la variable área se hace el cálculo del área del triángulo
para luego imprimir el área del triángulo con la instrucción
System.out.println("El area del triangulo es : "+area); donde se observa el uso
del método println() que permite imprimir una expresión y luego la impresión
continuará en la siguiente línea. Observa dentro del paréntesis el uso del
operador + que se usa como concatenación (no como operador de suma), es
decir, imprime la expresión “El área del triángulo es” con el contenido de la
variable area.
2) Calcular el perimetro, el area y la diagonal de un rectangulo si se

ingresan los lados.
import java.io.*;
public class Rectangulo{

{
double lado1,lado2,perimetro,area,diagonal;
System.out.print("Ingrese valor del primer lado :");
lado1=Double.parseDouble(in.readLine());
System.out.print("Ingrese valor del segundo lado :");
lado2=Double.parseDouble(in.readLine());
perimetro=2*(lado1+lado2);
area=lado1*lado2;
diagonal=Math.sqrt(Math.pow(lado1,2)+Math.pow(lado2,2));

System.out.println("El perimetro es : "+perimetro);

System.out.println("El area es : "+area);
System.out.println("La diagonal es : "+diagonal);
}
}
La novedad en la segunda aplicación es el uso del método pow() que permite
calcular la potencia dado la base y el exponente, así por ejemplo
Math.pow(lado1,2) calcula el cuadrado del contenido de la variable lado1. Con
el método sqrt() se logra calcular la raíz cuadrada del un número, así por
ejemplo Math.sqrt(4) calula la raíz cuadrada de 4.
3) Calcular el salario neto de un trabajador. Se debe leer el nombre, horas

trabajadas, precio de la hora y sabiendo que los impuestos aplicados son
el 10 por ciento sobre el salario bruto.
import java.io.*;
public class Trabajador{

{
String nombre;
double sb,sn,ph,ht;
System.out.print("Ingrese nombre del trabajador :");
nombre=in.readLine();
System.out.print("Ingrese numero de horas trabajadas :");
ht=Double.parseDouble(in.readLine());
System.out.print("Ingrese precio de la hora :");

ph=Double.parseDouble(in.readLine());
sb=ph*ht;
sn=sb-0.10*sb;
System.out.println("El Salario neto del trabajador : "+nombre+ " es : "+sn);
}
}
4) Hacer un programa para convertir metros a pies y pulgadas

1 metro = 39.37 pulgadas 1 metro = 3.2 pies
public class Conversion{

{
double metros,pies,pulgadas;
System.out.print("Ingrese valor en Metros :");
metros=Double.parseDouble(in.readLine());
pies=metros*3.2;
pulgadas=metros*39.37;
System.out.println("El valor en pies es : "+pies);
System.out.println("El valor en pulgadas es : "+pulgadas);
}
}
5) Ingresar una letra entre a y e y reportar el mensaje de acuerdo a:

a excelente
b bueno
c regular
d malo
e pesimo
import java.io.*;
public class p403{

{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String cadena;
char letra;
System.out.print("Ingrese letra (a-e) : ");
cadena=br.readLine();
letra=cadena.charAt(0);
switch(letra)
{
case 'a': case 'A':
System.out.println("EXCELENTE");
break;
case 'b': case 'B':
System.out.println("BUENO");
break;
case 'c': case 'C':
System.out.println("REGULAR");
break;
case 'd': case 'D':
System.out.println("MALO");
break;
case 'e': case 'E':
System.out.println("PESIMO");
break;
default :
System.out.println("letra equivocada");
}
}
}
EJECUTANDO LA PRIMERA APLICACION
1. Crea un proyecto denominado: Sesion01_Aplicaciones

Observa que debes crear la clase principal AreaTriangulo dentro del

paquete sesion01_aplicaciones. Luego dar clic en el botón de comando
Terminar.
2. Ahora se observa el entorno de NetBeans listo para colocar la programación

de la primera aplicación.
3. Asi debe quedar luego de colocar las instrucciones de la primera aplicación.

4. Luego proceder a ejecutar la aplicación.
Posteriormente dar clic en Ejecutar archivo

Ingresar el valor de la base y luego de la altura y se logrará observar lo

siguiente:

CREACION DE METODOS
Los métodos en java permiten modularizar sus programas. Todas las variables
declaradas en las definiciones de métodos son variables locales es decir solo
se conocen en el método que se definen. Casi todos los métodos tienen una
lista de parámetros que permiten comunicar información entre métodos. Los
parámetros de un método también son variables locales.
La sintaxis para declarar un método es la siguiente:
tipo_de_valor_devuelto nombre_del_método ( lista_de_parámetros)

{
Declaraciones e instrucciones
}
Donde:
tipo_de_valor_devuelto: Indica el tipo de valor que se devuelve al método
invocador. Si un método no devuelve un valor, el tipo_de_valor_devuelto se
declara como void.
nombre_del_método: Es cualquier identificador válido
lista_de_parámetros: Es una lista separada por comas que contiene las
declaraciones de las variables que se pasarán al método. Si un método no
recibe parámetros las lista_de_parámetros se deja vacía.
El cuerpo del método es el conjunto de declaraciones e instrucciones que

constituyen el método.
Cuando un programa encuentra una llamada a un método, se transfiere el
control desde el punto de invocación al método invocado, se ejecuta el método
y el control regresa al invocador.
Un método invocado puede devolver el control al invocador de tres maneras.
Si el método no devuelve valor, el control se devuelve al llegar a la llave
derecha que termina el método o ejecutando la sentencia
return;
Si el método devuelve un valor, la sentencia
return expresión
Devuelve el valor de Expresión.
Por ejemplo si se desea calcular la suma de dos números enteros. Se podría

definir el siguiente método:
int suma(int x, int y)

{
return x+y;
}
el tipo_de_valor_devuelto es int, tiene dos parámetros enteros x e y.
Supongamos que deseamos un método para mostrar el mensaje “Java es fácil

de aprender”. Se podría definir el método de la siguiente manera
void mensaje()
{
System.out.println(“Java es fácil de Aprender”);
}
En este caso el método no devuelve un valor, por eso el

tipo_de_valor_devuelto es void. Lo que hace solamente el método es mostrar
un mensaje.

PROGRAMAS RESUELTOS
1) Hacer un programa para calcular el factorial de un número.
import java.io.*;
public class Metodos01

{
public static int factorial(int n)
{
int f=1,i;
for(i=1;i<=n;i++)
f=f*i;
return f;
}
public static void main(String args[]) throws IOException

{
int n;
do{
System.out.print("Ingrese numero :");
n=Integer.parseInt(br.readLine());
}while(n<0);
System.out.println("el Factorial es : "+factorial(n));
}
}
Se tiene el método factorial que tiene un solo parámetro de tipo entero llamado
n y que devuelve o retorna un valor de tipo entero. Es un método estático por lo
que no será necesario crear o instanciar un objeto (recuerda que para
instanciar un objeto se usa el operador new). En el método main se inicia con
crear el objeto br del tipo BufferedReader (para lectura de datos), luego se
declara una variable n de tipo n (recuerda que esta variable no es el mismo del
paramétro del método factorial ya que se declara en otro método). A través de

la sentencia repetitiva do se busca validar el ingreso del valor para la variable n

que debe ser un valor positivo, si es negativo volverá a solicitar el ingreso de
otro valor para la variable n. Finalmente la instrucción System.out.println("el
Factorial es : "+factorial(n)); imprimirá el factorial de n haciendo uso del método
factorial.
2) Calcular el MCD de dos números enteros.
import java.io.*;
class Metodos02{
public static int mcd(int a, int b)
{
int d=2,p=1;
while(d<=a && d<=b)
if(a%d==0 && b%d==0)
{
p=p*d;
a=a/d;
b=b/d;
}
else
d++;
return p;
}
{
int x,y,m;
do{
System.out.print("Ingrese primer numero :");
x=Integer.parseInt(br.readLine());
}while(x<0);
do{
System.out.print("Ingrese el segundo numero : ");
y=Integer.parseInt(br.readLine());
}while(y<0);
m=mcd(x,y);
System.out.println("El m.c.d de "+x+" y "+y+" es : "+m);

}
}
3) Programa para reportar todos los divisores de un número entero N
import java.io.*;
class Metodos03{
public static void reporteDivisores(int n)
{
int d;
System.out.println("Los divisores del numero son :");
for(d=1;d<=n;d++)
if(n%d==0) System.out.print(d+" ");
System.out.println();
}

{
int num;
do{
num=Integer.parseInt(br.readLine());
}while(num<=0);
reporteDivisores(num);
}
}
4) Programa para ingresar un numero y se reporte si es primo
import java.io.*;
class Metodos05{
public static boolean esPrimo(int n)
{
int d=1;
do{
d=d+1;
}while( n%d!=0 && d*d<=n);

if(d*d>n) return true;
else return false;
}

{
int num;
do{
}while(num<=0);
if(esPrimo(num))
System.out.println("El numero es primo");
else
System.out.println("El numero no es primo");
}
}
Cuando una clase tiene métodos estáticos se puede invocar a esos métodos de la
siguiente manera: NombreClase.nombreMetodo, como se hace con los métodos de
la clase Math, para la raiz cuadrada se coloca Math.sqrt(x), para la potencia
Math.pow(x,n).
Por ejemplo crearemos una clase llamada Aritmética que contenga métodos estaticos
esPrimo (que verifica si un numero es primo), factorial, mcd(Calcula el m.c.d. de dos
números) , reporteDivisores y reporteFactoresPrimos.
Estos métodos como son estáticos pueden ser llamados como:
Aritmética.nombre_metodo(parámetros)
Como se ve en el programa que sigue a la clase Aritmetica
class Aritmetica{
public static boolean esPrimo(int n)

{
int d=1;
do{
d=d+1;
}while(n%d!=0 && d*d<=n);
if(d*d>n) return true;
else return false;

}

{
int f=1,i;
for(i=1;i<=n;i++)
f=f*i;
return f;
}
public static int mcd(int a, int b)
{
int d=2,p=1;
while(d<=a && d<=b)
if(a%d==0 && b%d==0)
{
p=p*d;
a=a/d;
b=b/d;
}
else
d++;
return p;
}
public static void reporteDivisores(int n)
{
int d;
System.out.println("Los divisores del numero son :");
for(d=1;d<=n;d++)
if(n%d==0) System.out.print(d+" ");
}
public static void reporteFactoresPrimos(int n)

{
int d=2;
while(n>1)
{
while(n % d !=0) d=d+1;
System.out.print(d+" ");
n=n/d;
}
}
}
Programa que usa la clase Aritmética
class PruebaAritmetica{
{
int n;
do{
}while(n<0);
System.out.println("el Factorial es : "+Aritmetica.factorial(n));
if(Aritmetica.esPrimo(n))
System.out.println("El numero es primo");
else
System.out.println("El numero no es primo");
}
}
Duración y alcance de un identificador

La duración de un identificador determina cuando dicho identificador existe en
la memoria.
El alcance de un identificador es la porción del programa en la que se puede
hacer referencia a dicho identificador.
Los identificadores que representan variables locales de un método (esto es,

los parámetros y la variables declaradas en el cuerpo del método) tienen
duración automática. Las variables de duración automática se crean cuando
se ingresa en el bloque en el que se declaran, existen mientras dicho bloque
está activo y se destruyen cuando se sale del bloque.
Java también tiene métodos de duración estática. Las variables y métodos de

duración estática existen desde el momento en el que la clase en la que se
definen se carga en la memoria para ejecutarse, hasta que el programa
termina. El espacio de almacenamiento para las variables de duración estática
se asigna e inicializa una vez cuando su clase se carga en la memoria. En el
caso de los métodos de duración estática comienza a existir cuando su clase
se carga en la memoria.
Los alcances para un identificador son alcance de clase y alcance de bloque.

Una variable de ejemplar declarada fuera de cualquier método tiene alcance de
clase. El identificador correspondiente se “conoce” en todos los métodos de la
clase.
Los identificadores declarados de un bloque tienen alcance de bloque. El
alcance de bloque termina en la llave derecha que cierra el bloque.
Los variables locales declaradas al principio de un método tienen alcance de
bloque, lo mismo que los parámetros del método, que se consideran variables
locales en ese método.
Cualquier bloque puede contener declaración de variables.

Observa que debes crear la clase principal Metodos01 dentro del paquete
sesion02_aplicaciones. Luego dar clic en el botón de comando Terminar.

3. Asi debe quedar luego de colocar las instrucciones de la primera aplicación

4. Luego a proceder a ejecutar la aplicación.
Posteriormente dar clic en Ejecutar archivo.

Ingresar el valor de un número y luego se mostrará lo siguiente:

RECURSIVIDAD Y SOBRECARGA DE METODOS
RECURSIVIDAD
Un método es recursivo cuando se llama a si mismo ya sea directamente e
indirectamente.
Si un método recursivo se invoca con un caso base, simplemente devuelve un
resultado. Si el método se invoca con un problema más complejo, divide el
problema en dos o más partes conceptuales: una parte del método sabe cómo
resolver y una versión un poco más pequeña del problema original. Dado que
este nuevo problema se asemeja al problema original, el método emite una
llamada recursiva para trabajar con el problema reducido.
Para que la recursividad termine, cada vez que el método recursivo se llama a
si mismo con una versión un poco más sencilla del problema original, la
secuencia de problemas cada vez menores debe convergir hacia el caso base.
Cuando el método reconoce el caso base, devuelve el resultado a la llamada
de método previa, y se inicia una secuencia de devoluciones que termina
cuando la llamada del método original devuelve el resultado final.

Recursividad vs Iteración
Tanto la iteración como la recursión se basan en una estructura de control.: La
iteración usa una estructura de repetición; la recursión una estructura de
selección.
Tanto la iteración como la recursión implican repetición: la iteración emplea

explícitamente una estructura de repetición; la recursión logra la repetición
mediante llamadas de métodos repetidas
Tanto la iteración como la recursión incluyen una prueba de terminación; la

iteración termina cuando deja de cumplirse la condición para continuar el ciclo;
la recursión termina cuando se reconoce el caso base.
PROGRAMAS RESUELTOS
1) Hacer un programa para calcular el factorial de un número.
import java.io.*;
public class Recursividad01{

{
if(n==0) return 1;
else return n*factorial(n-1);
}

{
int num;
do{
}while(num<=0);
System.out.println("El factorial es : "+factorial(num));

}
}
El método recursivo llamado factorial tiene un perímetro de tipo entero llamado
n. Se evalúa su valor si es igual cero usando la sentencia IF, si es falso se
retorna el valor de n multiplicado con lo que retornará el método factorial al
darle el valor de n disminuido en 1. Si observamos la figura que se coloca al
inicio de esta sesión:
En la figura se observa el método Fact (que en nuestro programa se llama

factorial) calcula el factorial de 3. En la primera llamada retorna 3 * Fact(3-1), el
Fact(3-1) en la segunda llamada del método retorna 2 * Fact(2-1) y así
sucesivamente hasta que en la última llamada al aplicar Fact(1-1) devolverá el
valor de 1.
En el método main se crea el objeto br de tipo BufferedReader (para lectura de
datos), luego se declara la variable num de tipo entero. A través de la sentencia
repetitiva se pide el ingreso del número para la variable num y si es un valor
negativo se volverá a solicitar nuevamente el ingreso de dicho número.
Finalmente a través del método println se muestra el cálculo del método
recursivo factorial teniendo como valor de entrada el contenido de la variable
num.
2) Calcular la potencia de x elevado a la n en forma recursiva. x real y n entero

positivo

import java.io.*;
class recursividad02{
public static double potencia(double x, double n)

{
if(n==0) return 1;
else return x*potencia(x,n-1);
}

{
int n;
double x;
System.out.print("Valor de x :");
x= Double.parseDouble(br.readLine());
do{
System.out.print("valor de n : ");
}while(n<=0);
System.out.println(x+" elevado a la "+n+" es igual a "+potencia(x,n));
}
}
3) Hacer un programa para que reporte los n términos de la serie de Fibonacci
import java.io.*;
public static int fibonacci(int n)

{
if(n==1) return 1;
else
if(n==2)
return 1;
else
return fibonacci(n-1) + fibonacci(n-2);
}

{
int n,i ;
do{
System.out.print("Número de terminos de la serie : ");
}while(n<=0);
for(i=1;i<=n;i++)
System.out.print(fibonacci(i) + " ");
}
}
4) Programa para calcular el máximo común divisor de dos números.
import java.io.*;
public static int mcd(int a,int b)

{
if(a%b==0) return b;
else return mcd(b,a%b);
}

{
int x,y;
do{
System.out.print("Ingrese primer numero :");
x=Integer.parseInt(br.readLine());
}while(x<=0);
do{
System.out.print("Ingrese segundo numero :");

y=Integer.parseInt(br.readLine());
}while(y<=0);
System.out.println("El mcd de "+x+" y "+y+" es : "+mcd(x,y));
}
}
5) Programa para reportar un numero al reves
import java.io.*;
public static void reves(int n)

{
System.out.print(n % 10);
if( n/10 !=0 ) reves(n/10);

{
int num;
do{
}while(num<=0);
System.out.print("Numero al reves :");
reves(num);
}
}
6) Programa para convertir un número de base 10 a base b (entre 2 y 9)
import java.io.*;

public static void conversionBase(int n, int b)

{
if(n<b)
System.out.print(n);
else
{
conversionBase(n/b,b);
System.out.print(n%b);
}
}

{
int num,b;
do{
}while(num<=0);
do{
System.out.print("Base a la que quiere convertir : ");
b=Integer.parseInt(br.readLine());
}while(b<2 || b>9);
System.out.print("El numero "+num+" en base "+b+" es : ");
conversionBase(num,b);
}
}
SOBRECARGA DE METODOS
Java permite definir varios métodos con el mismo nombre en tanto dichos
métodos tengan diferentes juegos de parámetros (con base en el número y el
orden de los parámetros). Esto se denomina sobrecarga de métodos. Cuando
se invoca un método sobrecargado, el compilador de Java selecciona el
método adecuado examinando el número, los tipos y el orden de los
argumentos en la llamada. La sobrecarga de métodos suele utilizarse para

crear varios métodos con el mismo nombre que realizan tareas similares, pero
sobre datos de diferentes tipos.
import java.io.*;
class sobrecarga01{
public static int cuadrado(int x)

{
return x*x;
}
public static float cuadrado(float x)

{
return x*x;
}
public static double cuadrado(double x)

{
return x*x;
}

{
int a=3;
float b=3.4f;
double c=12.5;
System.out.println("El cuadrado de "+a+ " es : "+cuadrado(a));
System.out.println("El cuadrado de "+b+" es : "+cuadrado(b));
System.out.println("El cuadrado de "+c+" es : "+cuadrado(c));
}
}

Observa que debes crear la clase principal Recursividad01 dentro del

Terminar


3. Así debe quedar luego de colocar las instrucciones de la primera aplicación.

Ingresar el valor numérico y se visualizará el factorial.

ARREGLOS UNIDIMENSIONALES EN METODOS
ARREGLOS
Un arreglo es un grupo contiguo de posiciones de memoria relacionadas entre
sí. Estas posiciones están relacionadas por el hecho de que todas tienen el
mismo nombre y el mismo tipo. Para referirnos a una posición o elemento en
particular dentro del arreglo, especificamos el nombre del arreglo y el subíndice
del elemento.
Un subíndice puede ser un entero o una expresión entera. Si un programa
emplea una expresión como subíndice, la expresión se evalúa para determinar
el elemento específico del arreglo.
Los arreglos de Java siempre comienzan con el elemento 0.
Declaración de un arreglo
En java existen 2 formas de declarar arreglos.
Tipo de dato identificador[];

ó
Tipo de dato []identificador;
Por ejemplo si se desea declarar un arreglo de enteros, se podría hacer de

esta manera:
int numeros[]; ó int []numeros;

Creación de un Arreglo
Después de declarar un arreglo, se tiene que crearlo. Para crearlo se coloca la
palabra clave new seguida del tipo de dato y del tamaño del arreglo entre
corchetes..
Ejm:
numeros = new int[100]; // se esta creando un arreglo de 100 elementos
enteros
También se puede declarar y crear un arreglo en una sola instrucción. Por

ejemplo:
double promedios[] = new double[50];
Se está declarando y creando 50 elementos de tipo double
Inicialización de un arreglo
En Java se pueden inicializar arreglos al declararlos. Cuando se especifica
valores iniciales dentro de la declaración de un arreglo, Java realiza la
operación new y define el tamaño del arreglo de forma automática.
Ejemplo:
int arreglo1 [] = { 1, 2, 3, 4, 5};
boolean arreglo[] = { true, false, true};
String meses[] = { “Enero”, ”Febrero”, ”Marzo”, ”Abril”, ”Mayo”, “Junio”};
Acceso a los arreglos

Cada valor dentro de un arreglo se conoce como elemento del arreglo. Para
acceder a un elemento de un arreglo especifique el nombre del arreglo con el
índice del elemento entre corchetes [].

Ejemplo:
int numeros = { 12, 20, 60, 80, 100 };
for(int indice = 0; indice < 5 ; indice++)

System.out.println(numeros[indice]);
En este ejemplo el tamaño del arreglo es 5. En java el índice del primer

elemento del arreglo es cero y la última posición es el tamaño del arreglo.
Debido a esto, para iterar todos los elementos del arreglo, el programa utiliza
loa valores 0 a 4 para la variable del ciclo.
Como obtener la longitud de un arreglo

En java un arreglo es un objeto. La única variable miembro de un objeto arreglo
es la variable length (longitud), que contiene el tamaño del arreglo.
La variable length es de solo lectura, ya que el tamaño del arreglo no puede
cambiar después de crearlo aquel.
Ejemplo : El siguiente código muestra cómo utilizar la variable length dentro de
un ciclo for que itera por todos los elementos del arreglo.
int arreglo[] = {12, 20, 60, 80, 90};
for(indice = 0; indice<arreglo.length; indice++)

System.out.println(arreglo[indice]);
Referencias a arreglos
Java utiliza referencias para apuntar a los arreglos.
Por ejemplo:
Las siguientes instrucciones utilizan la referencia arreglo para acceder a dos
arreglos distintos.
import java.io.*;
class ReferenciaArreglo{

{
int primero[] = {1, 2, 3, 4};
int segundo[] = {5, 6, 7, 8, 9, 10};
int arreglo[];
arreglo=primero;
System.out.println("Primer Arreglo ");
for(int indice=0;indice<arreglo.length;indice++)
arreglo=segundo;
System.out.println("Segundo Arreglo ");
for(int indice=0;indice<arreglo.length;indice++)
}
}
PROGRAMAS RESUELTOS
1) Hacer un programa para ingresar n valores reales en un arreglo y los muestre

en la pantalla, además reportar el mayor, el menor y el promedio.
import java.io.*;
public class Arreglo01{
public static void main(String arg[])throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
double x[],mayor,menor,promedio,suma=0;
int n,i;
do{
System.out.print("Cantidad de elementos del arreglo : ");
}while(n<=0 || n>100);
x=new double[n];
for(i=0; i<n;i++)
{
System.out.print("x["+i+"]: ");
x[i]=Double.parseDouble(br.readLine());
}
System.out.println("Elementos del arreglo");

for(i=0; i<n;i++)
System.out.println("x["+i+"]: "+x[i]);
// Calculo del mayor y menor
mayor=menor=x[0];
for(i=1; i<n; i++)
if (x[i]>mayor) mayor=x[i];
else
if(x[i]<menor) menor=x[i];
// Calculo de la suma de los elementos

for(i=0; i<n; i++)
suma=suma+x[i];
promedio=suma/n;
System.out.println("El mayor es " +mayor);
System.out.println("El menor es:"+ menor);
System.out.println("El promedio es : "+ promedio);
}
}
En el método main se inicia creando el objeto br del tipo BuffreredReader,
luego se declara variables de memoria de tipo double. Se aprecia la variable
x[] que es una arreglo o vector que todavía no se define el tamaño o el número
de elementos. Luego se declara dos variables enteras n, i. A través de la
sentencia repetitiva se valida el valor de n dentro de un rango de 1 a 100, es
decir, no se acepta un valor menor o igual a 0 ni un número mayor de 100.

Posteriormente se crea el arreglo x con la instrucción x=new double[n]; ya que
se define el tamaño del arrglo x con el valor de la variable n. A continuación se
usa la sentencia for que permite leer los datos para cada elemento del arreglo,
la misma va desde un valor de 0 hasta i<n, es decir, si n es igual a 10 entonces
la variable i irá desde 0 hasta 9. En cada interacción solicitará el ingreso de un
número, la misma que se almacenará en el elemento correspondiente del
arreglo. Cabe señalar que el objeto br con su método readLine() lee el dato
como cadena (String) entonces existe la necesidad de hacer la conversión,
para ello se usa el método parseDouble de la clase Double que permite
convertir el dato ingresado en valor numérico double. Luego se imprime los
valores ingresados usando nuevamente la sentencia for. Para el cálculo del
mayor y menor número ingresados en el arreglo vector se inicializa las
variables con la instrucción mayor=menor=x[0]; donde la variable mayor y la
variable menor recibe el valor del primer elemento del arreglo x. A continuación
con la sentencia for se recorre por cada elemento del arreglo x desde el
segundo elemento hasta el último elemento del arreglo. En cada interacción se
usa la sentencia IF para evaluar si el elemento es mayor a la variable mayor, si
es verdadero se cambia el valor contenido en la variable mayor por el valor del
elemento en evaluación, si es falso se cambia el valor del contenido en la
variable menor. Posteriormente a través de otra sentencia for se procede a
realizar la suma de todos los números contenidos en el arreglo y se va
acumulando en la variable suma, que previamente se inicializó con el valor de
cero. A continuación, se calcula el promedio y se muestra los resultados
obtenidos.
2) Programa para ingresar n valores reales en un arreglo y calcular la desviación

standard.
import java.io.*;
public class arre02{


{
double x[],suma=0,p,ds;
int n,i;
do{
}while(n<=0);
x=new double[n];
for(i=0; i<n;i++)
{
}

for(i=0; i<n;i++)
for(i=0; i<n; i++)

suma=suma+x[i];
p=suma/n;
suma=0;
for(i=0;i<n;i++)
suma=suma + Math.pow(x[i]-p,2);
ds=Math.sqrt(suma/(n-1));
System.out.println("La desviacion standard es : "+ds);
}
}
3) Programa para ingresar n valores reales en un arreglo y luego invierta el

arreglo.

import java.io.*;

{
double x[],temp;
int n,i,j;
do{
}while(n<=0 || n>100);
x=new double[n];
for(i=0; i<n;i++)
{
}
System.out.println("Arreglo Ingresado");
for(i=0; i<n;i++)
for(i=0,j=n-1;i<n/2;i++,j--)
{
temp=x[i];
x[i]=x[j];
x[j]=temp;
}
System.out.println("Arreglo Invertido");
for(i=0; i<n;i++)
}
}
4) Programa para ingresar 2 vectores de n elementos reales cada uno y reportar el

producto escalar de ellos
import java.io.*;

{
double x[],y[],pe;
int n,i;
do{
System.out.print("Numero de elementos de los vectores : ");
}while(n<=0);
x=new double[n];
y=new double[n];
System.out.println("Ingreso de datos del primer vector");

for(i=0; i<n;i++)
{
}
System.out.println("Ingreso de datos del segundo vector");

for(i=0; i<n;i++)
{
System.out.print("y["+i+"]: ");
y[i]=Double.parseDouble(br.readLine());
}
System.out.println("Elementos del primer vector");

for(i=0; i<n;i++)

System.out.println("Elementos del Segundo vector");

for(i=0; i<n;i++)
System.out.println("y["+i+"]: "+y[i]);
pe=0;
for(i=0;i<n;i++)
pe=pe+x[i]*y[i];
System.out.println("El Producto escalar es : " +pe);
}
}
5) Programa para ingresar n nombres en un arreglo y luego Ingresar un Nombre y

buscar si este se encuentra en el arreglo ingresado.
import java.io.*;

{
String nombres[],nombus;
int n,i,pos;
do{
System.out.print("Cantidad de nombres a ingresar : ");
}while(n<=0);
nombres=new String[n];
for(i=0; i<n;i++)
{
System.out.print("Nombre["+i+"]: ");
nombres[i]=br.readLine();
}

for(i=0; i<n;i++)
System.out.println("Nombre["+i+"]: "+nombres[i]);
System.out.print("nombres a buscar : ");

nombus=br.readLine();
pos=-1;
for(i=0;i<n ; i++)
if(nombres[i].compareToIgnoreCase(nombus)==0)
{
pos=i;
break;
}
if(pos!=-1)
System.out.println("Nombre se encuentra en la posición"+pos);
else
System.out.println("Nombre no se encuentra en el arreglo");
}
}
Observa que debes crear la clase principal Arreglo01 dentro del paquete


3. Posteriormente colocar la programación de la primera aplicación.

Ingresar el valor de la base y luego de la altura y se logrará observar lo

siguiente:

AUTOEVALUACION
a) Responde a las siguientes preguntas:

1. Clase que pertenece al paquete java.io y permite hacer lectura de datos desde el
teclado: ___________________
2. Método que permite calcular la potencia dado la base y el exponente: ______________
3. Método que devuelve el número de caracteres o la longitud de caracteres de una
cadena de texto: ___________________
4. Método que permite evaluar si una cadena 1 es igual a una cadena 2 sin importar las
mayúsculas o minúsculas: _________________
5. Los métodos que no retornan valor usan la instrucción return (verdadero o falso):
_____________
b) Desarrolla las siguientes aplicaciones:

1. Construye una aplicación que permita el ingreso de una cantidad de segundos y
muestre su equivalencia en días, horas, minutos y segundos. Posteriormente
construye una aplicación que permita ingresar una cantidad de soles y muestre su
equivalencia en billetes de 200 soles, de 100 soles, 50 soles, 20 soles, 10 soles y en
monedas de 5 soles, 2 soles y de 1 sol.
2. Construye una aplicación que permita el ingreso de una cantidad de segundos y
muestre su equivalencia en días, horas, minutos y segundos. Esta vez lo haces
creando un método.
3. Construye una aplicación que permita sumar los digitos de un numero entero
usando recursividad de métodos.
4. Construye una aplicación que permita el ingreso de 5 numeros en unvector A y 5
numeros en un vector B. Luego coloque todos los números tanto del vector A y del
vector B en un vector C. Finalmente muestre la suma y el promedio de todos los
número.

CAPITULO II
PROGRAMACION ORIENTADA A OBJETOS

CLASES Y SUS MIEMBROS
CLASE
Una clase es una plantilla o prototipo que define las variables y los métodos
comunes a todos los objetos de cierto tipo. Las clases definen estado
(variables) y comportamiento (métodos) de todos los objetos.
Las clases son el mecanismo por el que se pueden crear nuevos Tipos en
Java. Las clases son el punto central sobre el que giran la mayoría de los
conceptos de la Orientación a Objetos.
Una clase es una agrupación de datos y de código (métodos) que actúa sobre
esos datos, a la que se le da un nombre.
Una clase contiene:

Datos (se denominan Datos Miembro). Estos pueden ser de tipos primitivos o
referencias.
Métodos (se denominan Métodos Miembro).
La sintaxis general para la declaración de una clase es:
modificadores class nombre_clase {

declaraciones_de_miembros ;
Los modificadores son palabras clave que afectan al comportamiento de la

clase.
Por ejemplo crearemos la clase Rectangulo cuyos atributos son base y altura,
ademas queremos calcular el area, perímetro y diagonal del Rectangulo
import java.io.*;
class Rectangulo{
private double base;
private double altura;
public Rectangulo(double b, double h) // Constructor
{
base = b;
altura=h;
}
public void setBase(double b)
{
base=b;
}
public void setAltura(double h)
{
altura=h;
}
public double getBase()
{
return base;
}
public double getAltura()
{
return altura;
}
public double area()
{
return base*altura;
}
public double perimetro()

{
return 2*base+2*altura;
}
public double diagonal()

{
return Math.sqrt(Math.pow(base,2)+Math.pow(altura,2));
}
public String toString()

{
return "base = "+base+" "+altura;
}
}
La clase Rectángulo tiene 2 atributos base y altura los cuales son privados esto
quiere decir que estas 2 variables son visibles en la clase Rectángulo.
El primer método que se ha implementado es el constructor, este método se
llama igual que la clase y no devuelve ningún valor y permite inicializar los
atributos de la clase. Este método se llama en el momento de crear un objeto.
Como los atributos base y altura son privados, para que los usuarios que usan
los objetos puedan modificar los atributos se crean los métodos
setBase(double b) y setAltura(double h). Y si deseamos obtener los valores de
los atributos creamos los métodos getBase() y getAltura().
Además se han creado los métodos area(), perímetro() y diagonal() que
permiten calcular el area, perímetro y diagonal del rectangulo.
En el método toString() (a cadena) se crea una cadena con la información de
los atributos de la clase. En realidad podemos colocar cualquier información.
public class pruebaRectangulo{

{
double b, h;
Rectangulo R;
System.out.print("Ingrese base : ");
b=Double.parseDouble(br.readLine());

System.out.print("Ingrese altura : ");

h=Double.parseDouble(br.readLine());
R = new Rectangulo(b,h);
System.out.println("Rectangulo : "+R);
System.out.println("Area : "+R.area());
System.out.println(“Perimetro : “+R.perimetro());
System.out.println("Diagonal : "+R.diagonal());
}
}
Dentro del método main de la clase PruebaRectangulo se ha declarado dos

variables de tipo primitivo b,h y una variable R que es de tipo Rectangulo.
Al colocar :
Rectangulo R;
Se está declarando a R como un Objeto de la Clase Rectangulo.
La declaración no crea nuevos objetos. En la declaración (Rectangulo R) se
declara una variable llamada R la cual será usada para referirnos a un Objeto
Rectangulo. La referencia está vacía. Una referencia vacía es conocida como
referencia nula.
Al colocar :
R = new Rectangulo(3,4);
Con el operador new creamos un objeto de la clase Rectangulo.El operador
new instancia una clase asignando memoria para el nuevo Objeto.
El operador new requiere una llamada a un constructor de la clase a
instanciar. El constructor inicializa el nuevo objeto.El operador new retorna una
referencia al objeto creado.
Una vez creado el objeto para poder llamar a sus métodos usamos lo siguiente
objeto.nombredeMétodo. Por ejemplo para calcular el area usamos R.area(),
para calcular el perímetro R.perimetro() y para calcular la diagonal R.diagonal().
Al escribir System.out.println(“Rectangulo : “+R); en realidad se esta llamando
tácitamente al método toString de la clase R.
Si se deseara modificar el atributo base del Objeto se debe usar el método
setBase por ejemplo si después de crear el objeto queremos que base tenga el

valor 10, se colocaría la siguiente instrucción: R.setBase(10); lo mismo se hace

si se quiere modificar la altura.
Si se desea saber el valor de algún atributo del objeto se usa los métodos get,
por ejemplo si quisiera imprimir el valor de la base del objeto R se tendría que
escribir lo siguiente :
System.out.println(“La base es : “+R.getBase());
PROGRAMAS RESUELTOS
1) Crear la clase Cilindro con atributos radio y altura y que se pueda calcular el
area y el volumen del cilindro.
import java.io.*;
class Cilindro{
private double radio;
private double altura;
public Cilindro(double r, double a)

{
radio=r;
altura=a;
}
public void setRadio(double r)

{
radio=r;
}
public void setAltura(double a)

{
altura=a;
}
public double getRadio()

{
return radio;
}

{
return altura;
}

{
return 2*Math.PI*Math.pow(radio,2)+2*Math.PI*radio*altura;
}
public double volumen()

{
return Math.PI*Math.pow(radio,2)*altura;
}

{
return "Radio = "+radio+" Altura = "+altura;
}
}
public class PruebaCilindro

{
{
BufferedReader br = new BufferedReader(new
double r, h;
Cilindro C;
System.out.print("Ingrese radio: ");
r=Double.parseDouble(br.readLine());
System.out.print("Ingrese altura : ");
h=Double.parseDouble(br.readLine());

C = new Cilindro(r,h);
System.out.println("Cilindro : "+C);
System.out.println("Area : "+C.area());
System.out.println("Volumen : "+C.volumen());
}
}
Se crea clase Cilindro con los atributos radio y altura de tipo double. Luego se
crea el método constructor Cilindro (los métodos constructores se verá en la
octava sesión) que permite establecer los valores de los dos atributos a través
de los parámetros r y a. Luego se construye los métodos setRadio() y
setAltura() que permite cambiar el valor del atributo radio y altura
respectivamente. Con los métodos getRadio() y getAltura() se obtiene el
contenido del atributo radio y altura respectivamente. Con los métodos area() y
volumen() se calcula el área y el volumen del cilindro. El método toString()
permite imprimir el radio y la altura del cilindro según el contenido de los
atributos.
Con la clase PruebaCilindro, en el método main se crea la variable objeto br
del tipo BufferedReader, se declara las variables de memoria r y h de tipo
double y se declara la variable C del tipo de la clase Cilindro. Se ingresa los
valores del radio y de la altura. Luego en la instrucción C = new Cilindro(r,h); se
crea el objeto C (que previamente había sido declarado) con el método
constructor Cilindro pasando los valores ingresados del radio y la altura a
través de las variables de memoria r y h. A continuación con la instrucción
System.out.println("Cilindro : "+C); se imprime la expresión “Cilindro:” con lo
programado en el método toString(), es decir, es lo mismo colocar C que
colocar C.toString(). Finalmente se imprime el área y el volumen del cilindro
usando los métodos area() y volumen() invocados desde el objeto C.
2) Crear la clase numeros que tenga como atributos dos numeros y se calcule su
suma, resta, multiplicación, división.

import java.io.*;
class Numeros{
private double numero1;
private double numero2;
public Numeros(double n1,double n2)
{
numero1=n1;
numero2=n2;
}
public void setNumero1(double n1)

{
numero1=n1;
}
public void setNumero2(double n2)

{
numero2=n2;
}
public double getNumero1()

{
return numero1;
}
public double getNumero2()

{
return numero2;
}
public double suma()

{
return numero1+numero2;
}
public double resta()

{
return numero1-numero2;
public double multiplicacion()

{
return numero1*numero2;
}
public double division()

{
return numero1/numero2;
}

{
return "numero1 = "+numero1+" numero2 = "+numero2;
}
}
public class PruebaNumeros

{
{
double n1,n2;
Numeros A;
System.out.print("Ingrese primero Numero : ");
n1=Double.parseDouble(br.readLine());
System.out.print("Ingrese segundo Numero: ");
A = new Numeros(n1,n2);
System.out.println("Numeros : "+A);
System.out.println("suma : "+A.suma());
System.out.println("resta : "+A.resta());
System.out.println("Multiplicacion : "+A.multiplicacion());
System.out.println("Division : "+A.division());
}
}

3) Crear la clase Alumno que tenga como atributos nombre, nota1 y nota2 y
permita calcular el promedio y su condicion (aprobado o desaprobado)
import java.io.*;
class Alumno{
private String nombre;
private double nota1;
private double nota2;
public Alumno(String nom, double n1, double n2)

{
nombre=nom;
nota1=n1;
nota2=n2;
}
public void setNombre(String nom)

{
nombre=nom;
}
public void setNota1(double n1)

{
nota1=n1;
}
public void setNota2(double n2)

{
nota2=n2;
}
public String getNombre()

{
return nombre;
}
public double getNota1()

{
return nota1;
}
public double getNota2()

{
return nota2;
}
public double promedio()

{
return (nota1+nota2)/2;
}
public String condicion()

{
if(promedio()>=10.5)
return "aprobado";
else
return "desaprobado";
}

{
return "nombre : "+nombre +"nota1 = "+nota1+" nota2 = "+nota2;
}
}
public class PruebaAlumno{

{
String nom;
double n1,n2;
Alumno A;
System.out.print("Ingrese nombre : ");
nom= br.readLine();
System.out.print("Ingrese nota1 : ");
System.out.print("Ingrese nota2 : ");
A = new Alumno(nom,n1,n2);
System.out.println("Alumno : "+A);
System.out.println("Promedio : "+A.promedio());
System.out.println("Condicion : "+A.condicion());
}
}
4) Crear la clase Trabajador que tenga como atributos nombre, preciHora y

horasTrabajadas y se calcule salario Bruto, impuestos( 10% del Salario Bruto) y
salario Neto (Salario Bruto – Impuestos)
import java.io.*;
class Trabajador{
private double horasTrabajadas;
private double precioHora;
public Trabajador(String nom, double ht, double ph)

{
nombre=nom;
horasTrabajadas=ht;
precioHora=ph;
}
public void setNombre(String nom)

{
nombre=nom;
}
public void setHorasTrabajadas(double ht)

{
horasTrabajadas=ht;
}
public void setPrecioHora(double ph)

{
precioHora=ph;
}

{
return nombre;
}
public double getHorasTrabajadas()

{
return horasTrabajadas;
}
public double getPrecioHora()

{
return precioHora;
}
public double salarioBruto()

{
return precioHora*horasTrabajadas;
}
public double impuestos()

{
return 0.10*salarioBruto();
}
public double salarioNeto()

{
return salarioBruto()-impuestos();
}

{
return "nombre : "+nombre+ " Horas Trabajadas : "+horasTrabajadas+" Precio Hora :
"+precioHora;
}
}

public class PruebaTrabajador

{
{
String nom;
double ph,ht;
Trabajador T;
System.out.print("Ingrese nombre : ");
nom= br.readLine();
System.out.print("Ingrese numero de horas Trabajadas : ");
ht=Double.parseDouble(br.readLine());
System.out.print("Ingrese precio de la Hora : ");
ph=Double.parseDouble(br.readLine());
T = new Trabajador(nom,ht,ph);
System.out.println("Trabajador : "+T);
System.out.println("Salario Bruto : "+T.salarioBruto());
System.out.println("Impuestos : "+T.impuestos());
System.out.println("Salario Neto : "+T.salarioNeto());
}
}
5) Crear la clase Móvil con atributos velocidad Inicial, aceleración y tiempo y se

pueda calcular el espacio recorrido por el móvil
import java.io.*;
class Movil{
private double velocidadInicial;
private double aceleracion;
private double tiempo;
public Movil(double vi, double a, double t)

{
velocidadInicial=vi;
aceleracion=a;
tiempo=t;
public void setVelocidadInicial(double vi)

{
velocidadInicial=vi;
}
public void setAceleracion(double a)

{
aceleracion=a;
}
public void setTiempo(double t)

{
tiempo=t;
}
public double getVelocidadInicial()

{
return velocidadInicial;
}
public double getAceleracion()

{
return aceleracion;
}
public double getTiempo()

{
return tiempo;
}

{
return "Velocidad Inicial = "+velocidadInicial+" Aceleracion =
"+aceleracion+"Tiempo = "+tiempo;
}
public double espacioRecorrido()

{
return
velocidadInicial*tiempo+(1.0/2.0)*aceleracion*Math.pow(tiempo,2);
}
}
public class PruebaMovil

{
{
double vi,a,t;
Movil M;
System.out.print("Ingrese velocidad Inicial : ");
vi=Double.parseDouble(br.readLine());
System.out.print("Ingrese aceleracion : ");
a=Double.parseDouble(br.readLine());
System.out.print("Ingrese tiempo : ");
t=Double.parseDouble(br.readLine());
M = new Movil(vi,a,t);
System.out.println("Movil : "+M);
System.out.println("Espacio Recorrido : "+M.espacioRecorrido());
}
}

Observa que debes crear la clase principal PruebaCilindro dentro del

Terminar.
2. Ahora se observa el entorno de NetBeans listo para colocar la

programación de la primera aplicación.


Ingresar el valor de la radio y la altura y se logrará observar lo siguiente:

RELACIONES ENTRE CLASES
Un conjunto de objetos aislados tiene escasa capacidad de resolver un

problema. En una aplicación útil los objetos colaboran e intercambian
información, mantienen distintos tipos de relaciones entre ellos.
A nivel de diseño podemos distinguir entre 5 tipos de relaciones básicas entre
clases de objetos: dependencia, asociación, agregación, composición y
herencia. La dependencia es la relación menos importante, simplemente refleja
que entre dos clases de objetos existe una posible colaboración temporal con
algún propósito. Una dependencia puede indicar la utilización de un objeto de
una clase como argumento de una operación o en su implementación.
En cambio, la asociación es la relación más importante y más común. Refleja
una relación entre dos clases independientes que se mantiene durante la
vidade los objetos de dichas clases o al menos durante un tiempo prolongado.
En UML suele indicarse el nombre de la relación, el sentido de dicha relación y
las cardinalidades en los dos extremos.
Veamos el siguiente diagrama de clases:

Diagrama de clases Nº 1
Se observa la clase Pedido que tiene como atributos a numero (de tipo entero),
fecha (de tipo cadena) y cliente (de tipo cadena). Tiene como operaciones o
métodos a Pedido(), adicionarDetalle(), obtenerDetalle() y
calcularTotalPedido(). La segunda clase llamada DetallePedido tiene como
atributos a cantidad (de tipo entero) y precio (de tipo flotante), como único
método tiene a DetallePedido(). Existe una relación entre la clase de Pedido y
DetallePedido que consiste que cada Pedido debe estar compuesto de uno a
muchos Detalle de Pedidos.
Veamos otro diagrama de clases:

Diagrama de clases Nº 2
Se observa la clase Almacen que tiene como único atributo nombre (de tipo
cadena) y sus métodos son: Almacen(), adiconarProducto(), obtenerProducto(),
adicionarEmpleado() y obtenerEmpleado(). La segunda clase llamada Producto
tiene como atributos a nombre (de tipo cadena), stock (de tipo entero) y precio
(de tipo flotante) y como único método Producto(). Existe una relación entre la
clase mAlmacen y la clase Producto que consiste que cada Almacen puede
tener uno o muchos productos.
Una asociación se implementa en Java introduciendo referencias a objetos de

la clase destino de la relación como atributos de la clase origen. Si la relación
tiene una cardinalidad superior a uno entonces será necesario utilizar un
arreglo o una estructura de datos. Normalmente la conexión entre los objetos
se realiza recibiendo la referencia de uno de ellos en el constructor u otro
operación similar del otro.
Veamos el siguiente código escrito en Java:

3 4
Se tiene la clase Cliente con los atributos nombre, apellidos, direccion,

localidad y fNacimiento (ver en la llave correpondiente a 1). Tenemos como
métodos a Cliente(), nombreCompleto() y direccionCompleta() (ver en 2). Se
tiene la clase Cuenta que tiene como atributos a numero, titular (de tipo Cliente
– ver flecha anaranjada), saldo e interesAnual (ver en la llave correpondiente a
3) . Como métodos tiene a Cuenta y a leerTitular() (ver en 4). La mayor
novedad en este ejemplo es que la Clase Cuenta tiene un atributo llamado
titular que es de tipo Cliente, es decir, que este atributo titular es un objeto de la
Clase Cliente y por lo tanto contiene a su vez a los atributos de Cliente y con la
posibilidad de usar sus métodos.
PROGRAMAS RESUELTOS
3) Crear la clase Facultad con los atributos codigofac y nombre y luego la clase
EscuelaPropfesional con los atributos codigoesc, nombre, facultad. Luego
procede a ingresar los datos de dos escuelas profesionales.
import java.io.*;
class Facultad
{
String codigofac;
String nombre;
public Facultad(String cod, String nom)

{
codigofac=cod;
nombre=nom;
}
}
class EscuelaProfesional
{
String codigoesc;
String nombre;
Facultad facultad;
public EscuelaProfesional(String cod, String nom, Facultad f)

{
codigoesc=cod;
nombre=nom;
facultad=f;
}

{
return "La escuela profesional "+nombre+" pertenece a la facultad de
"+facultad.nombre;
}
}

public class RelacionClases01 {

public static void main(String[] args)throws IOException
{
String codesc, nomesc, codfac, nomfac;
int i;
System.out.println("DATOS DE LA PRIMERA ESCUELA
PROFESIONAL");
System.out.print("Ingrese el codigo de la escuela profesional : ");
codesc=br.readLine();
System.out.print("Ingrese el nombre de la escuela profesional : ");
nomesc=br.readLine();
System.out.print("Ingrese el codigo de facultad : ");
codfac=br.readLine();
System.out.print("Ingrese el nombre de facultad : ");
nomfac=br.readLine();
Facultad F1=new Facultad(codfac,nomfac);
EscuelaProfesional EP1=new EscuelaProfesional(codesc,nomesc,F1);
System.out.println("");
System.out.println("DATOS DE LA SEGUNDA ESCUELA
PROFESIONAL");
System.out.print("Ingrese el codigo de la escuela profesional : ");
codesc=br.readLine();
System.out.print("Ingrese el nombre de la escuela profesional : ");
nomesc=br.readLine();
System.out.print("Ingrese el codigo de facultad : ");
codfac=br.readLine();
System.out.print("Ingrese el nombre de facultad : ");
nomfac=br.readLine();
Facultad F2=new Facultad(codfac,nomfac);
EscuelaProfesional EP2=new EscuelaProfesional(codesc,nomesc,F2);
System.out.println(EP1);
System.out.println(EP2);
}

4) Tomando el diagrama de clases Nº 2 proceder a ingresar datos de productos.

Hacer uso de arreglos o vectores.
Crear un archivo Almacen.java y colocar el siguiente código:

public class Almacen
{
//Atributos propios de la clase
//Atributos resultado de la relacion con la clase Producto
private int nproductos;
private Producto[] productos;
public Almacen(String nom)

{
nombre=nom;
//Creacion del arreglo de objetos producto
nproductos = 0;
productos = new Producto[100];
}
public String adicionarProducto(Producto prod)

{
//Variable que nos mostrará si realmente se registró el producto
String rpta;
//Consulta si el arreglo tiene menos de 100 items
if (nproductos < 100) {
//Si tiene menos de 100 items lo agrega al arreglo
productos[nproductos] = prod;
//Incremente la cantidad de elementos que tiene el arreglo
nproductos++;
//Un mensaje diciendo que se registro el producto
rpta = "Se registro el producto";
} else {
//Un mensaje diciendo que no se pudo registrar
rpta = "No se registro el producto";
}
return rpta;
}

public Producto obtenerProducto(int indice)

{
//El indice tiene que ser menor a la cantidad de elementos que tenemos en el arreglo
if (indice < 0 || indice >= nproductos) {
//Si el indice esta fuera del rango
return null;
} else {
//Retorma el elemento en la posicion que deseamos
return productos[indice];
}
}
public int getNproductos() {

return nproductos;
}
public String getNombre() {
return nombre;
}
}
Crear un archivo Producto.java y colocar el siguiente código:

public class Producto
{
//Atributos de la clase
private float precio;
private int stock;
public Producto(String nom, int cant,float pre ) {

nombre = nom;
precio = pre;
stock = cant;
}
//Metodos Set y Get

return nombre;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}
public int getStock() {

return stock;
}
public void setStock(int s) {

stock = s;
}
public float getPrecio() {

return precio;
}
public void setPrecio(float p) {

precio = p;
}
public String toString() {

return "Producto{" + "Nombre=" + nombre + ", Precio=" + precio + ", Stock="
+ stock + '}';
}
}
Crear el archivo OperacionesProductos.java y colocar el siguiente código:

import java.io.*;
public class OperacionesProductos

{
public static void main(String args[])throws IOException
{
String nomalmacen, nompro;
int rpta=1, cant;
float pre;
Almacen oA= null;
System.out.print("Ingrese el nombre del almacen: ");

nomalmacen=br.readLine();
oA= new Almacen(nomalmacen);
Producto p;
if(oA!=null)
System.out.println("Almacen creado ...");
System.out.println("INGRESO DE PRODUCTOS");
do
{
System.out.print("NOMBRE: ");
nompro=br.readLine();
System.out.print("STOCK: ");
cant=Integer.parseInt(br.readLine());
System.out.print("PRECIO: ");
pre=Float.parseFloat(br.readLine());
System.out.print("¿Desea ingresar los datos de otro producto? (Si=1, No=0):
");
rpta=Integer.parseInt(br.readLine());
//Creacion del Objeto
p=new Producto(nompro, cant, pre);
//Adiciona el Obj al Arreglo de Productos
//Nota: Para acceder a los metodos del Arreglo de Objs que esta en Almacen
//se realiza mediante la Variable de Clase que se encuentra en IUAlmacen
oA.adicionarProducto(p);
}while(rpta==1);
System.out.println("LISTA DE PRODUCTOS");
int total,i;
total=oA.getNproductos();
if (total>0)
for(i=0;i<total;i++)
{
p=oA.obtenerProducto(i);
System.out.println(p.getNombre()+"\t"+p.getStock()+"\t"+p.getPrecio());
}
}
}

Observa que debes crear la clase principal RelacionClases01 dentro del

Terminar.



Ingresar los datos solicitados y se logrará observar lo siguiente:

MODIFICADORES DE ACCESO A LOS

MIEMBROS DE UNA CLASE
Los modificadores de acceso, como su nombre indica, determinan desde qué

clases se puede acceder a un determinado elemento. En Java tenemos 4 tipos:
public, private, protected y el tipo por defecto, que no tiene ninguna palabra
clave asociada, pero se suele conocer como default o package-private.
Si no especificamos ningún modificador de acceso se utiliza el nivel de acceso

por defecto, que consiste en que el elemento puede ser accedido sólo desde
las clases que pertenezcan al mismo paquete.
El nivel de acceso public permite a acceder al elemento desde cualquier clase,

independientemente de que esta pertenezca o no al paquete en que se
encuentra el elemento.
private, por otro lado, es el modificador más restrictivo y especifica que los
elementos que lo utilizan sólo pueden ser accedidos desde la clase en la que
se encuentran. Este modificador sólo puede utilizarse sobre los miembros de
una clase y sobre interfaces y clases internas, no sobre clases o interfaces de
primer nivel, dado que esto no tendría sentido.
Es importante destacar también que private convierte los elementos en

privados para otras clases, no para otras instancias de la clase. Es decir, un
objeto de una determinada clase puede acceder a los miembros privados de
otro objeto de la misma clase.
El modificador protected, por último, indica que los elementos sólo pueden ser
accedidos desde su mismo paquete (como el acceso por defecto) y desde
cualquier clase que extienda la clase en que se encuentra, independientemente
de si esta se encuentra en el mismo paquete o no. Este modificador, como
private, no tiene sentido a nivel de clases o interfaces no internas.
Los distintos modificadores de acceso quedan resumidos en la siguiente tabla:
Static
A pesar de lo que podría parecer por su nombre, heredado de la terminología
de C++, el modificador static no sirve para crear constantes, sino para crear
miembros que pertenecen a la clase, y no a una instancia de la clase. Esto
implica, entre otras cosas, que no es necesario crear un objeto de la clase para
poder acceder a estos atributos y métodos. Este es el motivo por el cual es
obligatorio que main se declare como static; de esta forma no tenemos que
ofrecer un constructor vacío para la clase que contiene el método, o indicar de
alguna forma a la máquina virtual cómo instanciar la clase.
Un uso del modificador static sería, por ejemplo, crear un contador de los
objetos de la clase que se han creado, incrementando la variable estática en el
constructor:

Como es de esperar, dado que tenemos acceso a los atributos sin necesidad
de crear un objeto, los atributos estáticos como usuarios no se inicializan al
crear el objeto, sino al cargar la clase.
Podemos acceder a estos métodos y atributos bien desde la propia clase
o bien desde una instancia cualquiera de la clase:
Otro uso sería el de crear una recopilación de métodos y atributos relacionados

a los que poder acceder sin necesidad de crear un objeto asociado, que podría
no tener sentido o no ser conveniente, como es el caso de la clase Math.

Una característica no muy conocida que se introdujo en Java 1.5 son los static
imports, una sentencia similar al import habitual, con la salvedad de que esta
importa miembros estáticos de las clases, en lugar de clases de los paquetes,
permitiendo utilizar estos miembros sin indicar el espacio de nombres en el que
se encuentran. El ejemplo anterior podría haberse escrito también de la
siguiente forma utilizando esta característica:
Si por algún motivo requerimos cualquier tipo de computación para inicializar nuestras
variables estáticas, utilizaremos lo que se conoce como bloque estático o inicializador
estático, el cuál se ejecuta una sola vez, cuando se carga la clase.
Por último, una curiosidad relacionada que podéis utilizar para romper el hielo con una
programadora Java es que podemos utilizar un bloque static para escribir un programa
sencillo sin necesidad de un main, añadiendo una llamada a System.exit para que el
programa termine tras cargar la clase sin intentar llamar al método main

Final
Indica que una variable, método o clase no se va a modificar, lo cuál puede ser
útil para añadir más semántica, por cuestiones de rendimiento, y para detectar
errores.
Si una variable se marca como final, no se podrá asignar un nuevo valor a la

variable. Si una clase se marca como final, no se podrá extender la clase. Si es
un método el que se declara como final, no se podrá sobreescribir.
Algo muy a tener en cuenta a la hora de utilizar este modificador es que si es

un objeto lo que hemos marcado como final, esto no nos impedirá modificar el
objeto en sí, sino tan sólo usar el operador de asignación para cambiar la
referencia. Por lo tanto el siguiente código no funcionaría:
Pero, sin embargo, este si:
Miembros de clase Estaticos

Cada objeto de una clase tiene su propia copia de todas las variables de
ejemplar de clase. En ciertos casos, una sola copia de la variable en particular
debe ser compartida por todos los objetos de la clase. Por esta y otras razones
utilizamos las variables de clase static (estáticas). Una variable de clase static
representa información “que abarca toda la clase”. La declaración de un
método estático comienza con la palabra clave static.

PROGRAMAS RESUELTOS
5) Crear una clase Empleado que haga uso del modificador static y luego crea dos
objetos de Empleados.
import java.io.*;
class Empleado{
private String nombres;
private String apellidos;
private static int contador;
public Empleado(String nom, String ape)

{
nombres=nom;
apellidos=ape;
contador++;
}
public void finalize()

{
--contador;
}
public void setNombres(String nom)

{
nombres=nom;
}
public void setApellidos(String ape)

{
apellidos=ape;
}
public static void setContador(int cont)

{
contador=cont;
}

public String getNombres()

{
return nombres;
}
public String getApellidos()

{
return apellidos;
}
public static int getContador()

{
return contador;
}

{
return apellidos+" "+nombres;
}
}
public class PruebaEmpleadoVariableEstatica{

{
System.out.println(“Numero de objetos creados :
“+Empleado.getContador());
Empleado e1= new Empleado("Torres","Fidel");
System.out.println(e1);
System.out.println("Número de objetos creados : "+e1.getContador());
Empleado e2= new Empleado("Villanueva","Nelsa");
System.out.println(e2);
System.out.println("Número de objetos creados :
"+Empleado.getContador());
}
}

En el programa anterior usamos un atributo private static y un método public

static.
El atributo contador se inicializa en cero por omisión. Esta variable va contando
el numero de Objetos de la Clase Empleado que se van creando, esta variable
se va incrementando en el constructor cada vez que se crea un objeto.
Para saber cuántos objetos hemos creados llamamos al método estatico
getContador() que devuelve el valor de la variable contador.
Un método declarado static no puede acceder a miembros de clase no
estáticos. Un método static no tiene referencia this porque las variables de
clase static y los métodos static existen independientemente de que existan o
no objetos de clase.
En la primera linea del Programa colocamos llamamos
Empleado.getContador() pues como es un método extático no es necesario
usar un objeto de la clase par llamar al método, solo se usa el nombre de la
Clase y luego el método getContador().
6) Crea una clase denominada FigurasGeometricas y calcula el área y el

perímetro del cuadrado, rectángulo y del triangulo. Hacerlo con métodos
estáticos y métodos no estáticos.
Respuesta con métodos estáticos:
import java.io.*;
class FigurasGeometricas
{
public static double areaCuadrado(int lado1)
{
return lado1*lado1;
}
public static double areaRectangulo(int lado1, int lado2)

{
return lado1*lado2;
}
public static double areaTriangulo(int lado1, int lado2, int lado3)
{
double p, r;

p=(lado1+lado2+lado3)/2.0;
r=p*(p-lado1)*(p-lado2)*(p-lado3);
if (r>0)
return Math.sqrt(r);
else
return 0.0;
}
public static int perimetroCuadrado(int lado1)
{
return 4*lado1;
}
public static int perimetroRectangulo(int lado1, int lado2)
{
return 2*lado1+2*lado2;
}
public static int perimetroTriangulo(int lado1, int lado2, int lado3)
{
return lado1+lado2+lado3;
}
}
public class CalculoAreaPerimetro
{
{
int opcion, l1,l2,l3;
System.out.println("CALCULO DEL AREA Y PERIMETRO");
System.out.print("Ingrese 1: cuadrado, 2:rectangulo, 3:triangulo -> ");
opcion=Integer.parseInt(br.readLine());
if (opcion==1)
{
System.out.print("Ingrese el valor del lado del cuadrado: ");
l1=Integer.parseInt(br.readLine());
System.out.println("El area del cuadrado es:
"+FigurasGeometricas.areaCuadrado(l1));
System.out.println("El perimetro del cuadrado es:
"+FigurasGeometricas.perimetroCuadrado(l1));
}
if (opcion==2)
{
System.out.print("Ingrese el valor del lado 1 del rectangulo: ");
System.out.println("El area del rectangulo es:
"+FigurasGeometricas.areaRectangulo(l1,l2));
System.out.println("El perimetro del rectangulo es:
"+FigurasGeometricas.perimetroRectangulo(l1,l2));
}
if (opcion==3)
{
System.out.print("Ingrese el valor del lado 1 del triangulo: ");
System.out.println("El area del triangulo es:
"+FigurasGeometricas.areaTriangulo(l1,l2,l3));
"+FigurasGeometricas.perimetroTriangulo(l1,l2,l3));
}
}
}
Respuesta con métodos no estáticos:

import java.io.*;
class FigurasGeometricas
{
public double areaCuadrado(int lado1)
{
return lado1*lado1;
}
public double areaRectangulo(int lado1, int lado2)

{
return lado1*lado2;
}
public double areaTriangulo(int lado1, int lado2, int lado3)

{
double p, r;
p=(lado1+lado2+lado3)/2.0;
r=p*(p-lado1)*(p-lado2)*(p-lado3);
if (r>0)
return Math.sqrt(r);
else
return 0.0;
}
public int perimetroCuadrado(int lado1)

{
return 4*lado1;
}
public int perimetroRectangulo(int lado1, int lado2)

{
return 2*lado1+2*lado2;
}
public int perimetroTriangulo(int lado1, int lado2, int lado3)

{
return lado1+lado2+lado3;
}
}
public class CalculoAreaPerimetro

{
{
int opcion, l1,l2,l3;
FigurasGeometricas F=new FigurasGeometricas();
System.out.println("CALCULO DEL AREA Y PERIMETRO");
System.out.print("Ingrese 1: cuadrado, 2:rectangulo, 3:triangulo -> ");

opcion=Integer.parseInt(br.readLine());
if (opcion==1)
{
System.out.print("Ingrese el valor del lado del cuadrado: ");
System.out.println("El area del cuadrado es: "+F.areaCuadrado(l1));
System.out.println("El perimetro del cuadrado es: "+F.perimetroCuadrado(l1));
}
if (opcion==2)
{
System.out.println("El area del rectangulo es: "+F.areaRectangulo(l1,l2));
"+F.perimetroRectangulo(l1,l2));
}
if (opcion==3)
{
System.out.println("El area del triangulo es: "+F.areaTriangulo(l1,l2,l3));
"+F.perimetroTriangulo(l1,l2,l3));
}
}
}
5. Crea un proyecto denominado: Sesion07_Aplicaciones.

Observa que debes crear la clase principal

PruebaEmpleadoVariableEstatica dentro del paquete

7. Asi debe quedar luego de colocar las instrucciones de la primera aplicación.



METODOS CONSTRUCTORES Y LA
REFERENCIA THIS
Un Constructor es una función, método, etc, de las clases, la cual es llamada

automáticamente cuando se crea un objeto de esa clase.
Por ser métodos, los constructores también aceptan parámetros. Cuando en
una clase no especificamos ningún tipo de constructor, el compilador añade
uno público por omisión sin parámetros, el cual NO hace nada.
Características de los Constructores
1. Un constructor, tiene el mismo nombre de la clase a la cual pertenece.
2. No puede ser Heredado.
3. No retorna ningún valor (Ni void), por lo cual no debe especificarse
ningún tipo de dato.
4. Debe declararse como public, sólo en casos realmente extraordinarios
será de otro tipo.
Supongamos una clase llamada Datos

public class Datos
{

//declaracion de atributos
public Datos();//constructor sin parametros
public Datos(int Edad)
{//Constructor con parámetros
EdadM=Edad;
}
}
Por ejemplo:
Sobrecarga
Cuando en una clase, se definen un mismo método, con diferente número de
parámetros, o bien con el mismo número de parámetros pero diferenciándose
en la definición, en la cual, al menos un parámetro sea de diferente tipo,
cuando esto sucede, se dice que el método está sobrecargado.
Por ejemplo:
public class Arboles {
public Arboles() {
System.out.println("Un árbol genérico");
}
public Arboles(String tipo) {

System.out.println("Un árbol tipo " + tipo);
}
public Arboles(int altura) {

System.out.println("Un árbol de " + altura + " metros");
}
public Arboles(int altura,String tipo) {

System.out.println("Un " + tipo + " de " + altura + " metros");
}
public static void main(String args[]) {

Arboles arbol1 = new Arboles(4);
Arboles arbol2 = new Arboles("Roble");
Arboles arbol3 = new Arboles();
Arboles arbol4 = new Arboles(5,"Pino");
}
}
Explicación:
 Como en todo programa Java, primeramente se define la Clase a través del
vocablo class.

 Posteriormente son definidos 4 Constructores; nótese que cada uno recibe

el mismo nombre de la Clase y posee distintos argumentos de entrada.
 Dentro del método principal (main) son generadas cuatro instancias de la
Clase, como se puede observar, al ser generada la instancia a través del
vocablo new se pasa un parámetro, y es dependiendo de este parámetro
que es llamado el Constructor correspondiente, el cual a su vez invoca la
Clase System.out.println que imprime a pantalla.
Métodos y Parámetros por Referencia

Cuando son utilizados Constructores puede surgir la necesidad de inicializar
algún campo perteneciente a la Clase, esto trae consigo otro detalle en lo que
concierne la asignación de valores dentro de un método, la razón se debe a
que dentro de un método puede surgir el requerimiento de accesar campos
definidos en la Clase, observe:
public Class Cableado
{
int longitud;
String tipo;
public Cableado(String tipo, int longitud)

{
this.tipo = tipo
this.longitud = longitud;
}
....
....
}
En el caso anterior, dentro del constructor se desea asignar valores a los

campos de una Clase, sin embargo, dentro del constructor son utilizados como
parámetros de entrada los mismos valores, para tener acceso a los campos de
la Clase se utiliza el vocablo: this, al emplear esta sintaxis se esta haciendo
alusión a los campos de la Clase.
Aunque sería posible emplear distintos nombres para los valores de entrada,
evitando el uso del vocablo this, la sintaxis con el vocablo this es ampliamente
utilizada en el caso de Constructores mencionado anteriormente.

PROGRAMAS RESUELTOS
1) Se Desea crear un objeto del tipo Coordenadas, que indique, la posición de

un punto en el plano cartesiano, y permita calcular la distancia existente con
otro punto, además del punto medio entre ellos.
1 /*Archivo Coordenadas.java*/
2
3 public class Coordenadas {
4 private int x,y;//Atributos
5 public Coordenadas (int x1 , int y1)//constructor
6 {
7 //asignamos esos valores
8 x=x1;
9 y=y1;
10 }
11 public double Distancia (int x1, int y1)
12 {
13 //este método recibe como parametros
14 //las coordenadas del segundo punto
15 double D;
16 D=Math.sqrt((x-x1)*(x-x1)+(y-y1)*(y-y1));
17 return D;//Retornamops el valor de la distancia
18 }
19 public void Pmedio(int x1, int y1)
20 {
21 double p1, p2;
22 p1=(x+x1)/2;
23 p2=(y+y1)/2;
24 System.out.println("El puntomedio es: "+p1+","+p2);
25 }
26 }
1 /*Archivo UsaCoordenadas.java*/
2 public class UsaCoordenadas {
3 public static void main (String args []){
4 Coordenadas P=new Coordenadas (10,20);
5 //calculamos la Distancia:
6 System.out.println("La Distancia es: "+P.Distancia(5,6));
7 //Punto Medio
8 P.Pmedio(5,6);
9 }
10 }
Interpretación de la programación
Un método, si va a devolver algún valor, éste debe especificarse cuando se
hace la definición del mismo, para el caso, el método Distancia, devuelve el
valor de la distancia, es por ello que lo especificamos como public double.
Además que, cuando realizamos la llamada de ese método, es en ese
preciso lugar que aparecerá el valor que devuelve. Por otra parte, los
atributos, son de acceso privado, lo cual implica que, sólo podemos acceder
a ellos, en la clase Coordenadas.
2) Cree una aplicación en Java, que imprima un número imaginario. Nota, los
números imaginarios, poseen una parte real y otra imaginaria, acompañada
por la constante i.
1 class Imaginario {
2 private int real, imag;
3 public Imaginario()
4 {
5 real=0;
6 imag=0;
7 }
8 public Imaginario(int x, int y)
9 {
10 real=x;
11 imag=y;
12 }
13 public void Mostrar()
14 {
15 System.out.println("El Numero Imaginario es: "+real+" + "+imag+"i");
16 }
17 }
1 class UsaImaginario{
2 public static void main (String args []) {
3 Imaginario oI=new Imaginario(5,6);
4 oI.Mostrar();
5}
6}
Interpretación de la programación
En el ejemplo anterior puede notar que, los atributos, son esas variables
simples, es las cuales almacenaremos información relevante a los objetos
que, crearemos a partir de esa clase.
Además que, los estamos declarando como públicos, lo cual indica que
tenemos acceso directo desde cualquier otro archivo a los atributos. Los
métodos son del tipo public y no devuelven ningún valor, por tal razón son
declarados como void. Además que. El método EstablecerEdad y
EstablecerNota, reciben un argumento cada uno de ellos, el cual es
asignado al respectivo atributo.
3) Tomando el enunciado del segundo programa resuelto en la sesión

“Relaciones entre clases”, indicar los métodos constructores utilizados y
usar la referencia this.
Crear un archivo Almacen.java y colocar el siguiente código:

{
//Método constructor Almacen con un solo parametro

public Almacen(String nombre)
{
this.nombre=nombre;
nproductos = 0;
}

{
String rpta;
if (this.nproductos < 100) {
this.productos[this.nproductos] = prod;
this.nproductos++;
} else {
}
return rpta;
}

{
if (indice < 0 || indice >= this.nproductos) {
return null;

} else {
}
}

return nproductos;
}
return nombre;
}
}
Crear un archivo Producto.java y colocar el siguiente código:

{
private int stock;
//Método constructor con parametros

public Producto(String nombre, int stock,float precio ) {
this.precio = precio;
this.stock = stock;
}

return nombre;
}

}

return stock;
}

public void setStock(int stock) {

this.stock = stock;
}

return precio;
}
public void setPrecio(float precio) {

}

return "Producto{" + "Nombre=" + nombre + ", Precio=" + precio + ", Stock="
+ stock + '}';
}
}
//El archivo OperacionesProductos.java queda como está.

Observa que debes crear la clase principal UsaCoordenadas dentro del

Terminar.

7. Selecciona el paquete sesion08_aplicaiones y al dar clic con el botón

derecho del mouse y selecciona Clase Java.

8. Posteriormente crear la clase Coordenadas.
9. Colocar el código correspondiente a la clase Coordenadas.

10. Colocamos el código correspondiente a la clase UsaCoordenadas.
11. Como la clase UsaCoordenadas contiene al metodo main procedemos a

ejecutar este programa.
La ejecución arroja lo siguiente:

AUTOEVALUACION

1. Una clase tiene como miembros atributos y métodos (verdadero o falso):
_________________
2. Para crear o instanciar un objeto de la clase Rectangulo se debe
escribir: _____________________________________
3. Los elementos o miemvros que sólo pueden ser accedidos dentro una
clase, pertenecen al nivel de acceso __________________
4. Modificador que permite que un miembro pertenezca a la clase y no a un
objeto es: ____________________
5. Las relaciones entre clases permite conocer la asociación existentes
entre ellos (verdaero o falso): _________________

1. Construye una aplicación que permita crear la clase Trapecio con los
atributos con base mayor, base menor y la altura. Luego calcula el
perímetro y el área del trapecio.
2. Construye una aplicación que permita crear la clase Marca con los
atributos codigomar y nombremar. También crear la clase Bus con los
atributos codigobus, nroasientos, nroejes y nropisos. Luego proceder a
ingresar datos en Marca y en Bus y posteriormente visualizar los datos de
los buses ingresados. Hacer uso de arreglos.
3. Crea una clase denominada FigurasGeometricas y calcula el área y el
perímetro del cuadrado, rectángulo y del triangulo. Hacerlo con métodos
constructores sobrecargados y el operador this.

CAPITULO III
HERENCIA, CLASES ABSTRACTAS,
INTERFACES Y POLIMORFISMO

HERENCIA DE CLASES
A través de la herencia, una clase nueva hereda los atributos y métodos de una
superclase previamente definida. En este caso decimos que la nueva clase es
una subclase.
En la herencia simple, una clase se hereda de una superclase. Java no
reconoce la herencia múltiple, pero si maneja el concepto de interfaces. Las
interfaces ayudan a java a lograr muchas de las ventajas de la herencia
múltiple.
Una subclase normalmente agrega sus propios atributos y métodos. De modo
que una subclase generalmente es mayor que su superclase. Una subclase es
más específica que su superclase y representa un grupo más pequeño de
objetos. El verdadero valor de la herencia radica en la capacidad de definir en
la subclase adiciones a las características heredadas de la superclase o
sustituciones de estas.
Todo objeto de una subclase es también un objeto de la superclase de esa
subclase. Sin embargo no se cumple lo opuesto: los objetos de una superclase
no son objetos de las subclases de esa superclase.
Las relaciones de herencia forman estructuras jerárquicas similares a un árbol.
Una superclase existe en una relación Jerárquica con sus subclases. Sin duda,
una clase puede existir sola, pero es cuando una clase se emplea con el
mecanismo de herencia que se convierte ya sea en una superclase que
proporciona atributos y comportamientos a otras clases, o en una subclase que
hereda dichos atributos y comportamientos.
Ejemplos:
Persona
Empleado Estudiante Religiosos
Profesor Contador Universitario Instituto Colegio
Por ejemplo en una ciudad existen Personas las cuales pueden ser
Empleados, Estudiantes, Religiosos. Los Empleados pueden ser Profesor,
Contador. Los estudiantes pueden ser Universitarios, de Institutos y Colegios.
Las subclases heredan el estado y el comportamiento en forma de las variables y los
métodos de su superclase. La subclase puede utilizar los ítems heredados de su
superclase tal y como son, o puede modificarlos o sobreescribirlos. Por eso, según se va
bajando por el árbol de la herencia, las clases se convierten en más y más
especializadas.
Miembros Protected
Los miembros protected de una superclase sólo están accesibles para los
métodos de la superclase, los métodos de las subclases y los métodos de otras
clases del mismo paquete.
Relacion entre Objetos de superclase y objetos de subclase

Un objeto de una subclase se puede tratar como objeto de su superclase
correspondiente. Esto hace posible ciertas manipulaciones interesantes. Por
ejemplo, a pesar del hecho de que los objetos de diversas clases derivadas de
una superclase en particular pueden ser muy diferentes entre sí, podemos
crear un arreglo de ellos, en tanto los tratemos como objetos de la superclase.
Lo contrario no se cumple un objeto de una superclase no es automáticamente
también un objeto de la subclase.
import java.io.*;
class Punto{
protected double x;
protected double y;
public Punto()
{
x=0;
y=0;
}
public Punto(double a, double b)

{
x=a;
y=b;
}
public void setX(double a)

{
x=a;
}
public void setY(double b)

{
y=b;
}
public double getX()

{
return x;
}
public double getY()

{
return y;
}


{
return "("+x+","+y+")";
}
}
class Circulo extends Punto{

protected double radio;
public Circulo()
{
super();
radio=0;
}
public Circulo(double a, double b, double r)

{
super(a,b);
radio=r;
}
public void setRadio(double a)

{
radio=a;
}

{
return radio;
}

{
return Math.PI*Math.pow(radio,2);
}

{
return "Centro = "+super.toString()+" Radio = "+radio;
}
public class HerenciaPuntoCirculo{

{
Punto P= new Punto(3,4);
Circulo C=new Circulo(6,9,12);
System.out.println(P);
System.out.println(C);
System.out.println("Area del Circulo : "+C.area());
}
}
La clase Circulo hereda de la clase Punto esto se especifica en:

La palabra clave extends (extiende) de la definición de clase indica herencia.
Todos los miembros (no private) de la clase Punto se heredan en la clase
Circulo.
Los constructores de Circulo deben invocar al constructor de Punto para
inicializar la porción de superclase de un objeto de la clase Circulo. La primer
línea del cuerpo de cada constructor invoca al constructor de Punto mediante la
referencia a super.
Una subclase pude redefinir un método de superclase empleando el mismo
nombre, esto se denomina supeditar un método de superclase. Se puede usar
la referencia super seguida por el operador punto para acceder a la versión de
superclase de ese método desde la subclase.
Veamos un ejemplo gráfico:

Trabajador es una clase genérica que sirve para almacenar datos como el
nombre, la dirección, el número de teléfono o el número de la seguridad social
de un trabajador.
Empleado es una clase especializada para representar los empleados que
tienen una nómikna mensual (encapsula datos como su salario anual)
Consultor es una clase especializada para representar a aquellos trabajadores
que cobran por horas (por ejemplo, registra el número de horas que ha
trabajado un consultor y su tarifa horaria).

Las clases Empleado y Consultor, además de los atributos y de las

operaciones que definen, heredan de Trabajador todos sus atributos y
operaciones.

Un empleado concreto tendrá, además de sus atributos y operaciones como

Empleado, todos los atributos correpondientes a la superclase Trabajador.
El diagrama indicado se debe escribir en programacion en Java de la siguiente
manera:
import java.util.Date;
class Trabajador
{
private String puesto;
private String direccion;
private String telefono;
private Date fecha_nacimiento;
private Date fecha_contrato;
private String NSS;
//constructor
public Trabajador (String nombre,String NSS)
{
this.nombre=nombre;
this.NSS=NSS;
}
//comparación de objetos
Public boolean equals (Trabajador t)
{
return this.NSS.equals(t.NSS);
}
//conversión en una cadena de caracteres

{
return nombre + “ (NSS “ + NSS + “ ) “;
}
}
class Empleado extends Trabajador

{
double sueldo;
private double impuestos;
private final int PAGAS=14;
//constructor
public Empleado(String nombre, String NSS, double sueldo)
{
super(nombre, NSS);
this.sueldo=sueldo;
this.impuestos=0.2 * sueldo;
}
public double calcularPaga()

{
return (sueldo - impuestos) / PAGAS;
}

{
return “Empleado “+super.toString();
}
}
Con la palabra reservada extends indicamos que Empleado es una subclase

de Trabajador. Con la palabra super accedemos a miembros de la superclase
desde la subclase.
Generalmente, en un método constructor, lo primero que nos encontramos es
una llamada al constructor de la clase padre con super(…). Si no ponemos
nada, se llama al constructor por defecto de la superclase antes de ejecutar el
constructor de la subclase.
class Consultor extends Trabajador

{
private int horas;
private double tarifa;

//constructor
public Consultor(String nombre, String NSS, int horas, double tarifa)
{
super(nombre, NSS);
this.horas=horas;
this.tarifa=tarifa;
}
public double calcularPaga()

{
return horas * tarifa;
}

{
return “Consultor ”+super.toString();
}
}
La clase Consultor también define un método llamado calcularPaga(), si bien

en este caso el cálculo se hace de una forma diferente por tratarse de un
trabajador de un tipo distinto.
Tanto la clase Empleado como la clase Consultor redefinen el método
toString() que convierte un objeto en una cadena de caracteres. De hecho,
Trabajador también redifine éste método, que se hereda de la clase Object, la
clase base de la que heredan todas las clases de Java.
Redifinición de métodos
Como hemos visto en el ejemplo con el método toString(), cada subclase
hereda las operaciones de su superclase pero tiene la posibilidad de modificar
localmente el comportamiento de dichas operaciones (redifiniendo métodos).
Continuamos con el caso Trabajador, Empleado y Consultor.
public class UsandoHerencia

{

public static void main(String args[ ])

{
//Declaracion de variables
Trabajador trabajador;
Empleado empleado;
Consultor consultor;
//Creación de objetos
trabajador = new Trabajador(“Juan”,”456”);
empleado = new Empleado(“Jose”,”123”,24000.0);
consultor = new Consultor(“Juan”,”456”, 10, 50.0);
System.out.println(trabajador);
System.out. println(empleado);
System.out.println(consultor);
System.out.println(trabajador.equals(empleado));
System.out.println(trabajador.equals(consultor));
}
}
EJECUTANDO LA APLICACIÓN EN NETBEANS

Observa que debes crear la clase principal UsandoHerencia dentro del

Terminar

programación de la reciente aplicación.
3. Selecciona el paquete sesion09_aplicaciones y dar clic el botón derecho del

mouse y selecciona Clase Java.

4. Procede a crear la clase Trabajador.
5. Colocar el código corresponidente a la clase Trabajador.

6. Luego, procede a crear la clase Empleado desde el paquete

sesion09_aplicaciones tal como se hizo con la clase Trabajador.
7. Colocar el código correspondiente a la clase Empleado.

8. Luego, procede a crear la clase Consultor desde el paquete

sesion09_aplicaciones tal como se hizo con la clase Trabajador.
9. Colocar el código correspondiente a la clase Consultor.

10. Posteriormente colocar la programación en la clase UsandoHerencia.
11. Como la clase UsandoHerencia contiene al metodo main procedemos a

ejecutar este programa.

La ejecución arroja lo siguiente:

CLASES ABSTRACTAS
Java proporciona un tipo especial de clase, llamada clase abstracta, que

pueden ayudar a la organización de clases basadas en métodos comunes. Una
clase abstracta permite colocar los nombres de los métodos comunes en una
sola clase (sin tener que escribir el código que los implemente). Después, al
crear nuevas clases, éstas pueden derivar de una clase abstracta que contiene
una serie de métodos requeridos.
Los métodos abstractos contienen sólo el nombre del método seguido de una
lista de parámetros. No contiene el código que implementa el método (esto se
deja para las clases derivadas.
 Las clases que contienen métodos abstractos se conocen como clases
abstractas
 Un programa no puede crear instancias de una clase abstracta de forma
directa, es necesario crear instancias de sus subclases.

 Las clases abstractas pueden contener una mezcla de métodos

abstractos y no abstractos (concretos). Los métodos concretos
contienen la instrumentación del método
 Cualquier subclase que extienda a la clase abstracta debe proporcionar
la instrumentación de todos los métodos abstractos. En caso contrario,
la subclase misma se convierte en clase abstracta.
Vamos a proceder a dar un ejemplo tomando en cuenta el diagrama de clases

que se encuentra dibujado al incio de esta sesión.
Imaginemos que en nuestra casa tenemos dos mascotas. Una es un perro y la

otra un gato. Cuando acariciamos a nuestro perro, éste baja las orejas como
respuesta a nuestra acción a nuestro gato, éste reacciona levantando su cola.
Cuando los alimentamos les damos de comer una cantidad de algún alimento
apropiado para ellos, y la respuesta de las dos mascotas es que se acercan al
recipiente donde tienen la comida y se la comen como podemos observar,
parece predecible que la respuesta habitual de todas las mascotas cuando se
les da de comer es que se acerquen al plato y se coman el contenido de éste,
pero no podemos decir lo mismo de la respuesta que nos pueden dar todas las
mascotas cuando las acariciamos. Si alguien nos preguntara cómo reacciona
una mascota cuando la acarician nosotros responderíamos que depende. ¿Y
de qué depende?. Pues depende de la mascota en concreto que nos estemos
refiriendo, es decir, si hablamos más concretamente de un perro diremos que
éste baja las orejas y si hablamos más concretamente de un gato, diremos que
levanta la cola, pero si no nos preguntan de que mascota en concreto estamos
hablando nuestra respuesta será abstracta, es decir, no tenemos una
respuesta general que sea válida para la mayoría de las mascotas.
Si extrapolamos este planteamiento al mundo de los Objetos, podemos decir

que tenemos
 una Superclase llamada Mascota con dos métodos

o un método acariciar() que es abstracto (abstract)

o y otro método alimentar(...) que no es abstracto

 y dos Subclases llamadas Perro y Gato
 Mascota
o es una Superclase abstracta (abstract)
 es abstracta por que contiene un método llamado
acariciar() que es abstracto
 una Clase abstracta no puede ser instanciada
 en UML se sabe que una Clase es abstracta por que el
nombre de la Clase está en cursiva
 -nombre: String
o Nota: Convención sobre los métodos de acceso getters y setters
 así pues siguiendo la convención, los métodos
+setNombre(nombre: String): void y +getNombre(): String
no están en la Clase de diseño Mascota
 -fechaNacimiento: Date
o Date es una Clase Java que como su nombre indica, representa
una fecha
 +acariciar():void
o como este método está escrito en cursiva, esto significa que
abstract
Vamos a crear las Clases Mascota, Perro, Gato y Aplicación en código de

Java.
import java.util.Date;
public abstract class Mascota {

private Date fechaNacimiento;
public abstract void acariciar();

public void alimentar(String nombreAlimento){

System.out.println("Mascota - alimentar(...): me acerco al " +
nombreAlimento + ", y me lo como");
}

}
public String getNombre(){

return nombre;
}
public void setFechaNacimiento(Date fechaNacimiento) {

this.fechaNacimiento = fechaNacimiento;
}
public Date getFechaNacimiento(){

return fechaNacimiento;
}
}
 import java.util.Date;
Hay una Clase que se llama Date que está incluida en el paquete java.util para
que el entorno de ejecución Java sepa donde encontrar esta Clase, nosotros
se lo tenemos que indicar con la palabra clave import
 public abstract class Mascota {
En Java se sabe que una Clase es abstracta porque se utiliza la palabra

reservada abstract en la declaración de la Clase
 Date fechaNacimiento;

A menudo los entornos de desarrollo cuando nos generan código

automáticamente a través de sus Asistentes nos escriben la signatura
completa de la Clase, es decir el nombre de la Clase y al paquete al cual
pertenece. De esta forma la declaración de esta Clase se vería así:
java.util.Date fechaNacimiento y no incluiría la palabra clave import
 public abstract void acariciar();
Como este método es abstracto y por lo tanto no está implementado, no tiene

la llaves {} de abrir y cerrar típica de todos los métodos
 public void setNombre(String nombre) {
En Java además de las variables de instancia que están visibles desde

cualquier punto de la Clase, también existen las variables locales que sólo
tienen visibilidad dentro de su ámbito, es decir, sólo se puede llegar a ellas si
se está dentro del mismo bloque un bloque se delimita por los corchetes {},
cómo pueden ser los corchetes de la definición de un método a la variable
nombre que se encuentra en la declaración del método setNombre(String
nombre) también se le considera una variable local a pesar de que no está
entre dos corchetes {}
 this.nombre = nombre;
La palabra clave this se está utilizando en esta ocasión para distinguir una
variable de instancia de una variable local.
Este es el código correspondiente a la Clase Perro

public class Perro extends Mascota {
public void acariciar() {

System.out.println("Perro - acariciar(): agacho las orejas");
}
}
 System.out.println("Perro - acariciar(): agacho las orejas");

Como ahora nos estamos refiriendo a una mascota concreta, ésta enviará el
mensaje de que está agachando las orejas.
Este es el código correspondiente a la Clase Gato

public class Gato extends Mascota {
public void acariciar() {

System.out.println("Gato - acariciar(): levanto la cola");
}
}
Ahora le añadimos el siguiente código a la Clase Aplicación

public class Aplicacion {
public static void main(String[] args) {

// Mascota m1 = new Mascota();
Perro p1 = new Perro();
p1.alimentar("Dog Chow");
p1.acariciar();
Gato g1 = new Gato();
g1.alimentar("Cat Chow");
g1.acariciar();
}
}
 Perro p1 = new Perro();
Creamos una instancia de la Clase Perro que engloba a la Clase Mascota y

a la Clase Perro en una sola instancia que es referenciada a través de la
variable de referencia p1
 p1.alimentar("Dog Chow");
Fijémonos que en la salida provocada como respuesta a la invocación de

este método quien está respondiendo es la Mascota acercándose al Dog
Chow

 p1.acariciar();

este método quien está respondiendo es el Perro agachando las orejas
 Gato g1 = new Gato();
Creamos una instancia de la Clase Gato que engloba a la Clase Mascota y

a la Clase Gato en una sola instancia que es referenciada a través de la
variable de referencia g1
 g1.alimentar("Cat Chow");

este método quien está respondiendo es la Mascota acercándose al Cat
Chow
 g1.acariciar();

este método quien está respondiendo es el Gato levantando la cola
Y esta es la salida
Veamos a continuación otro ejemplo, para lo cual se visualiza el siguiente

diagrama:

Figura es una clase abstracta porque no tienen sentido calcular su área, pero si
del cuadrado o un círculo. Si una subclase de Figura no redefine área(), deberá
declararse también como clase abstracta.
De acuerdo al diagrama de clases, la programación en Java sería:
abstract class Figura

{
protected doublé x;
protected doublé y;
public Figura(double x, double y)
{
this.x=x;
this.y=y;
}
public abstract double area();
}
class Circulo extends Figura

{
public Circulo(double x, double y, double radio)
{

super(x,y);
this.radio=radio;
}
{
return Math.PI * radio * radio;
}
}
class Cuadrado extends Figura

{
private double lado;
public Cuadrado(double x, double y, double lado)
{
super(x,y);
this.lado=lado;
}
public double area( )
{
return lado * lado;
}
}
public class FigurasGeometricas

{
public static void main(String[] args)throws IOException
{
int tipo;
double radio, lado;
System.out.println("AREA DE UNA FIGURA GEOMETRICA");
System.out.println("-----------------------------");
System.out.print("Ingrese 1 si es circulo ó 2 si es cuafdrado: ");
tipo=Integer.parseInt(br.readLine());
if(tipo==1)
{
System.out.print("Ingrese el valor del radio: ");
radio=Double.parseDouble(br.readLine());

Circulo Cir=new Circulo(0,0,radio);

System.out.println("El area del circulo es: "+Cir.area());
}
if(tipo==2)
{
System.out.print("Ingrese el valor del lado: ");
lado=Double.parseDouble(br.readLine());
Cuadrado Cua=new Cuadrado(0,0,lado);
System.out.println("El area del cuadrado es: "+Cua.area());
}
}


14. Asi debe quedar luego de escribir las instrucciones de la última aplicación

15. Luego a proceder a ejecutar la aplicación
Indicar por ejemplo 1 que es círculo.luego te solcitará el valor del radio.

Finalmente se observará el valor del área del circulo.

INTERFACES Y HERENCIA MULTIPLE
El concepto de interface lleva un paso más adelante la idea de las clases

abstractas. En Java una interface es una clase abstracta pura, es decir una
clase donde todos los métodos son abstractos (no se implementa ninguno).
Permite al diseñador de clases establecer la forma de una clase (nombres de
métodos, listas de argumentos y tipos de retorno, pero no bloques de código).
Una interface puede también contener datos miembro, pero estos son siempre
static y final. Una interface sirve para establecer un 'protocolo' entre clases.
Para crear una interface, se utiliza la palabra clave interface en lugar de class.
La interface puede definirse public o sin modificador de acceso, y tiene el
mismo significado que para las clases. Todos los métodos que declara una
interface son siempre public.

Para indicar que una clase implementa los métodos de una interface se utiliza
la palabra clave implements. El compilador se encargará de verificar que la
clase efectivamente declare e implemente todos los métodos de la interface.
Una clase puede implementar más de una interface.
Una interface se declara:
interface nombre_interface {
tipo_retorno nombre_metodo ( lista_argumentos ) ;
...
}
Por ejemplo:
interface InstrumentoMusical {
void tocar();
void afinar();
String tipoInstrumento();
}
Y una clase que implementa la interface:
class InstrumentoViento extends Object implements InstrumentoMusical {

void tocar() { . . . };
void afinar() { . . .};
String tipoInstrumento() {}
}
class Guitarra extends InstrumentoViento {

String tipoInstrumento() {
return "Guitarra";
}
}

La clase InstrumentoViento implementa la interface, declarando los métodos y

escribiendo el código correspondiente. Una clase derivada puede también
redefinir si es necesario alguno de los métodos de la interface.
Referencias a Interfaces
Es posible crear referencias a interfaces, pero las interfaces no pueden ser
instanciadas. Una referencia a una interface puede ser asignada a cualquier
objeto que implemente la interface. Por ejemplo:
InstrumentoMusical instrumento = new Guitarra();

instrumento.play();
System.out.prinln(instrumento.tipoInstrumento());
InstrumentoMusical i2 = new InstrumentoMusical(); //error.No se puede instanciar
Extensión de interfaces
Las interfaces pueden extender otras interfaces y, a diferencia de las clases,
una interface puede extender más de una interface. La sintaxis es:
interface nombre_interface extends nombre_interface , . . . {

tipo_retorno nombre_metodo ( lista_argumentos ) ;
...
}
Agrupaciones de constantes
Dado que, por definición, todos los datos miembros que se definen en una
interface son static y final, y dado que las interfaces no pueden instanciarse
resultan una buena herramienta para implantar grupos de constantes. Por
ejemplo:
public interface Meses {

int ENERO = 1 , FEBRERO = 2 . . . ;
String [] NOMBRES_MESES = { " " , "Enero" , "Febrero" , . . . };
}

Esto puede usarse simplemente:
System.out.println(Meses.NOMBRES_MESES[ENERO]);
Un ejemplo casi real

El ejemplo mostrado a continuación es una simplificación de cómo funciona
realmente la gestión de eventos en el sistema gráfico de usuario soportado por
el API de Java (AWT o swing). Se han cambiado los nombres y se ha
simplificado para mostrar un caso real en que el uso de interfaces resuelve un
problema concreto.
Supongamos que tenemos una clase que representa un botón de acción en un

entorno gráfico de usuario (el típico botón de confirmación de una acción o de
cancelación). Esta clase pertenecerá a una amplia jerarquía de clases y tendrá
mecanismos complejos de definición y uso que no son objeto del ejemplo. Sin
embargo podríamos pensar que la clase Boton tiene miembros como los
siguientes.
class Boton extends . . . {

protected int x , y, ancho, alto; // posicion del boton
protected String texto; // texto del boton
Boton(. . .) {
...
}
void dibujar() { . . .}
public void asignarTexto(String t) { . . .}
public String obtenerTexto() { . . .)
...
}
Lo que aquí nos interesa es ver lo que sucede cuando el usuario, utilizando el
ratón pulsa sobre el botón. Supongamos que la clase Boton tiene un método,
de nombre por ejemplo click(), que es invocado por el gestor de ventanas

cuando ha detectado que el usuario ha pulsado el botón del ratón sobre él. El
botón deberá realizar alguna acción como dibujarse en posición 'pulsado' (si
tiene efectos de tres dimensiones) y además, probablemente, querrá informar a
alguien de que se ha producido la acción del usuario. Es en este mecanismo
de 'notificación' donde entra el concepto de interface. Para ello definimos una
interface Oyente de la siguiente forma:
interface Oyente {
void botonPulsado(Boton b);
}
La interface define un único método botonPulsado. La idea es que este método
sea invocado por la clase Boton cuando el usuario pulse el botón. Para que
esto sea posible en algún momento hay que notificar al Boton quien es el
Oyente que debe ser notificado. La clase Boton quedaría:
class Boton extends . . . {

...
private Oyente oyente;
void registrarOyente(Oyente o) {
oyente = o;
}
void click() {
...
oyente.botonPulsado(this);
}
}
El método registrarOyente sirve para que alguien pueda 'apuntarse' como

receptor de las acciones del usuario. Obsérvese que existe una referencia de
tipo Oyente. A Boton no le importa que clase va a recibir su notificación.
Simplemente le importa que implante la interface Oyente para poder invocar el
método botonPulsado. En el método click se invoca este método. En el ejemplo
se le pasa como parámetro una referencia al propio objeto Boton. En la
realidad lo que se pasa es un objeto 'Evento' con información detallada de lo
que ha ocurrido.

Con todo esto la clase que utiliza este mecanismo podría tener el siguiente
aspecto:
class miAplicacion extends . . . implements Oyente {

public static main(String [] args) {
new miAplicacion(. . .);
...
}
...
miAplicacion(. . .) {
...
Boton b = new Boton(. . .);
b.registrarOyente(this);
}
...
void botonPulsado(Boton x) {
// procesar click
...
}
}
Obsérvese en el método registrarOyente que se pasa la referencia this que en

el lado de la clase Boton es recogido como una referencia a la interface
Oyente. Esto es posible porque la clase miAplicacion implementa la interface
Oyente. En términos clásicos de herencia miAplicacion ES un Oyente.
Veamos el ejemplo que se hizo al final de la sesión anterior. Si no

estuviésemos interesados en conocer la posición de una Figura , podríamos
eliminar por completo su implementación y convertir Figura en una interfaz.

En la declaración de una interfaz, lo único que puede aparecer son

declaraciones de métodos (su nombre y signatura, sin su implementacion) y
definiciones de constantes simbólicas. Una interfaz no encapsula datos, sólo
define cuáles son los métodos que han de implementar los objetos de aquellas
clases que implementan interfaz.
public class Circulo implements Figura

{
public Circulo (double radio)
{
this.radio=radio;
}
{
}
}
public class Cuadrado implements Figura

{
public Cuadrado (double lado)
{
this.lado=lado;
}
{
return lado * lado;
}
}
La clase debe implementar todos los métodos definidos por la interfaz o

declararse.
HERENCIA MULTIPLE DE INTERFACES

Una clase puede implementar varios interfaces simultáneamente, pese a que,
en Java, una clase puede heredar de otra clase (herencia simple de
implementación, múltiple de interfaces).
public abstract class Figura

{
public abstract double area();

}
interface Dibujable
{
public void dibujar()
}
interface Rotable
{
public void rotar(double grados);
}
public class Circulo extends Figura implements Dibujable, Rotable

{
public Circulo(double x, double y, double radio)
{
super(x,y);
this.radio=radio;
}
{
}
{
System.out.println("Dibujaria un circulo");
}
public void rotar(double grados)
{
System.err.print("Se rotaría el circulo en "+grados);
}
public class Cuadrado extends Figura implements Dibujable, Rotable

{
public Cuadrado(double x, double y, double lado)
{
super(x,y);
this.lado=lado;
}
public double area( )
{
return lado * lado;
}
{
System.out.println("Dibujaria un cuadrado");
}
public void rotar(double grados)
{
System.out.println("Se rotaría el cuadrado en "+grados+ “grados”);
}
}
public class UsandoInterfaces

{
public static void main(String[] args) throws IOException
{
int tipo;

double radio, lado;

System.out.println(" AREA, DIBUJO Y ROTACION DE UNA FIGURA
GEOMETRICA");
System.out.println("------------------------------------------------");
System.out.print("Ingrese 1 si es circulo ó 2 si es cuafdrado: ");
tipo=Integer.parseInt(br.readLine());
if(tipo==1)
{
System.out.print("Ingrese el valor del radio: ");
radio=Double.parseDouble(br.readLine());
Circulo Cir=new Circulo(0,0,radio);
System.out.println("El area del circulo es: "+Cir.area());
Cir.dibujar();
Cir.rotar(45);
}
if(tipo==2)
{
System.out.print("Ingrese el valor del lado: ");
lado=Double.parseDouble(br.readLine());
Cuadrado Cua=new Cuadrado(0,0,lado);
System.out.println("El area del cuadrado es: "+Cua.area());
Cua.dibujar();
Cua.rotar(30);
}
}

Se crea por defecto la clase UsandoInterfaces.

3. Se procede a escribir el código de la programación, quedando así:


Indicar por ejemplo 2 que es cuadrado.luego te solcitará el valor del lado.

Finalmente se observará el valor del área del circulo, un mensaje sobre
dibujo y otro mensaje de rotación.

POLIMORFISMO
Mediante el polimorfismo, se pueden escribir programas que procesen

genéricamente – como objetos de superclase- objetos de todas las clases
existentes en una jerarquía. Las clases que no existen durante el desarrollo de
los programas se pueden agregar con poca o ninguna modificación de la parte
genérica del programa, en tanto esas clases formen parte de la jerarquía que
se está procesando genéricamente.
Ejemplos:
import java.io.*;
abstract class Empleado{

protected String apellidos;
protected String nombres;
public Empleado(String ape, String nom)

{
apellidos=ape;
nombres=nom;
}
public void setApellidos(String ape)

{
apellidos=ape;
}
public void setNombres(String nom)

{
nombres = nom;
}
public String getApellidos()

{
return apellidos;
}
public String getNombres()

{
return nombres;
}
abstract double ganancias();

}
final class Jefe extends Empleado{

public double salario;
public Jefe(String ape, String nom,double s)

{
super(ape,nom);
salario=s;
}
public void setSalario(double s)

{
salario=s;
public double getSalario()

{
return salario;
}
public double ganancias()

{
return salario;
}

{
return "Jefe : "+apellidos+" "+nombres;
}
}
final class EmpleadoPorComision extends Empleado

{
private double salarioBase; // salario Base
private double comisionPorArticulo; // comision por articulo vendido
private int cantidadDeArticulos; // cantidad de articulos vendidos
public EmpleadoPorComision(String ape, String nom,double sb, double com, int

cant)
{
super(ape,nom);
salarioBase=sb;
comisionPorArticulo=com;
cantidadDeArticulos=cant;
}
public void setSalarioBase(double sb)

{
salarioBase=sb;
}
public void setComisionPorArticulo(double com)

{
comisionPorArticulo=com;
}
public void setCantidadDeArticulos(int cant)

{
cantidadDeArticulos=cant;
}
public double getSalarioBase()

{
return salarioBase;
}
public double getComisionPorArticulo()

{
return comisionPorArticulo;
}
public int getCantidad()

{
return cantidadDeArticulos;
}

{
return "Empleado por Comision : "+apellidos+" "+nombres;
}

{
return salarioBase+comisionPorArticulo*cantidadDeArticulos;
}
}
final class EmpleadoADestajo extends Empleado{

private double salarioPorPieza;
private int cantidad;

public EmpleadoADestajo(String ape, String nom,double sp, int cant)

{
super(ape,nom);
salarioPorPieza=sp;
cantidad=cant;
}
public void setSalarioPorPieza(double sp)

{
salarioPorPieza = sp;
}
public void setCantidad(int cant)

{
cantidad=cant;
}
public double getSalarioPorPieza()

{
return salarioPorPieza;
}
public double getCantidad()

{
return cantidad;
}

{
return salarioPorPieza*cantidad;
}

{
return "Empleado a Destajo : "+apellidos+" "+nombres;
}
}
final class EmpleadoPorHora extends Empleado

{
protected double salarioPorHora;
protected double horasTrabajadas;
public EmpleadoPorHora(String ape, String nom, double sh, double ht)

{
super(ape,nom);
salarioPorHora= sh;
horasTrabajadas=ht;
}
public void setSalarioPorHora(double sh)

{
salarioPorHora=sh;
}
public void setHorasTrabajadas(double ht)

{
horasTrabajadas=ht;
}
public double getSalarioPorHora()

{
return salarioPorHora;
}
public double getHorasTrabajadas()

{
return horasTrabajadas;
}

{
return "Empleado por Hora : "+apellidos+" "+nombres;
}

{
return salarioPorHora*horasTrabajadas;
public class PruebaEmpleado{

{
Empleado E;
Jefe J=new Jefe("Torres","Marcelino",2500);
EmpleadoPorComision C=new EmpleadoPorComision("Zavaleta","Juan",300,4,200);
EmpleadoPorHora H = new
EmpleadoPorHora("Narvaez","Robinson",10,40);
EmpleadoADestajo D = new
EmpleadoADestajo("Marin","Alejandro",20,5);
E = J;
System.out.println(E.toString()+" gano "+E.ganancias());
E = C;
E = H;
E = D;
}
}
/*
La Linea
E = J;
Coloca en la referencia de la Superclase E una referencia al objeto J de la

subclase Jefe. Esto es precisamente lo que debemos hacer para lograr un
comportamiento Polimórfico.
La expresión:
E.toString()
Innvoca al método toString() del objeto al que E hace referencia.

El sistema invoca al método toString() del objeto de la subclase, precisamente
lo que se llama comportamiento polimórfico. Esta llamada de método es un
ejemplo de ligado dinámico de métodos; la decisión respecto a cuál método
invocar se aplaza hasta el momento de ejecución.
La llamada al Metodo
E.ganancias()
Invoca al método ganancias del objeto al que E hace referencia. El sistema

invoca el método ganancias del objeto de la subclase en lugar del método
ganancias de la superclase. Esto es otro ejemplo de ligado dinámico de
métodos.
import java.io.*;
abstract class Figura{

{
return 0;
}
{
return 0;
}
public abstract String getNombre();
}
class Punto extends Figura{

protected double x;

protected double y;
public Punto(double a, double b)

{
x=a;
y=b;
}
public void setX(double x)

{
this.x=x;
}
public void setY(double y)

{
this.y=y;
}
public double getX()

{
return x;
}
public double getY()

{
return y;
}

{
return "("+x+","+y+")";
}

{
return "Punto";
}
}

protected double radio;
public Circulo(double a, double b, double r)

{
super(a,b);
radio=r;
}
public void setRadio(double r)

{
radio=r;
}

{
return radio;
}

{
return Math.PI*Math.pow(radio,2);
}

{
return "Centro "+ super.toString()+", Radio = "+radio;
}

{
return "Circulo";
}
}
class Cilindro extends Circulo{

protected double altura;

public Cilindro(double a,double b, double r, double h)

{
super(a,b,r);
altura=h;
}
public void setAltura(double h)

{
altura=h;
}

{
return altura;
}

{
return 2*super.area()+2*Math.PI*radio*altura;
}

{
return super.area()*altura;
}

{
return super.toString()+ "; Altura = "+altura;
}

{
return "Cilindro";
}
}
public class PruebaFigura{


{
Punto p = new Punto(3,4);
Circulo c = new Circulo(12,20,10);
Cilindro k = new Cilindro (100,100,50,25);
Figura F[] = new Figura[3];
F[0]=p;
F[1]=c;
F[2]=k;
System.out.println(p.getNombre()+" : "+p);
System.out.println(c.getNombre()+" : "+c);
System.out.println(k.getNombre()+" : "+k);
// Procesamos ahora el arreglo de Figuras e imprimimos el nombre, area y

volumen
// de cada objeto
for(int i=0;i<3;i++)
{
System.out.println(F[i].getNombre()+" : "+F[i]);
System.out.println("Area ="+F[i].area());
System.out.println("Volumen"+F[i].volumen());
System.out.println("=============");
}
}
}


3. Se procede a escribir la programación de la última aplicación, quedando

así:


AUTOEVALUACION

1. Usando herencia de clases se logra heredar los atributos y métodos de
una superclase. (verdaero o falso): ___________________
2. Los miembros protected de una superclase sólo están accesibles para los
métodos de la superclase, los métodos de la subclases y los métodos de
otras clases del mismo paquete (verdadero falso): __________________
3. Se le denomina clase abstracta pura cuando todos sus métodos son
abstractos, éste concepto se refiere a: __________________
4. Se puede escribir programas que procesen genéricamente objetos de
todas las clases existentes en una jerarquía, se refiere a _______________

1. Crea una clase denominada Curso con los atributos codigocur y
nombrecur. Luego aplica herencia y crea la clase Curso_Extension a partir
de la clase Curso con los atributos horas_clase y costocur. También crea la
clase Curso_Carrera con los atributos nombrecarrera y ciclo. Luego crea
objetos a partir de las subclases
2. Una empresa vende equipos celulares, que puede ser utilizados
únicamente para CLARO o para MOVISTAR. Se desea tener información
de la marca, el modelo y el costo del equipo. Además se puede adquirir
adicionalmente el chip teniendo un descuento del 10% del costo del chip si

es comprado conjuntamente con el celular. Por la compra de cualquier

equipo, el cliente puede adquirir un seguro de pérdida o robo pagando el
15% del costo del equipo. El pago por el equipo celular puede ser en
efectivo o mcon tarjeta. Si el pago es con tarjeta se incrementa el costo del
equipo en un 2%. Utiliza una programación usando clases abstracta y
herencia para calcular el precio del equipo y el monto del pago del seguro
en caso decidiera acogerse. Usar clase abstracta.
3. Aplicando polimorfismo, implementar los atributos, métodos (con las
validaciones correspondientes) y constructores de las siguientes clases con
sus atributos indicados entre paréntesis: Figura (símbolo), Rectángulo (filas:
entero >1, columnas: entero>1), Triángulo (filas: entero>1) y Rombo (filas:
entero>2 e impar). Crear el método dibujar para cada caso. Crear la clase
TestFiguras, que pruebe los métodos y constructores implementados. Como
ejemplo de la ejecución del método dibujar para cada objeto creado, en
caso que se haya asignado como símbolo de la figura al asterisco (*) y los
valores para las filas y columnas indicados a continuación, se tendría:
Objeto Rectángulo: Filas=2 Columnas=6
******
******
Objeto Triángulo: Filas=3
*
***
*****
Objeto Rombo: Filas=7
*
***
*****
*******
*****
***
*

CAPITULO IV
PAQUETES, EXCEPCIONES Y DESARROLLO DE
UN PROYECTO

PAQUETES
Claúsula package
Un package es una agrupación de clases afines. Equivale al concepto de
librería existente en otros lenguajes o sistemas. Una clase puede definirse
como perteneciente a un package y puede usar otras clases definidas en ese o
en otros packages.
Los packages delimitan el espacio de nombres (space name). El nombre de
una clase debe ser único dentro del package donde se define. Dos clases con
el mismo nombre en dos packages distintos pueden coexistir e incluso pueden
ser usadas en el mismo programa.
Una clase se declara perteneciente a un package con la cláusula package,

cuya sintaxis es:
package nombre_package;
La clausula package debe ser la primera sentencia del archivo fuente.

Cualquier clase declarada en ese archivo pertenece al package indicado.
Por ejemplo, un archivo que contenga las sentencias:
package miPackage;
...
class miClase {
...
declara que la clase miClase pertenece al package miPackage.
La claúsula package es opcional. Si no se utiliza, las clases declaradas en el

archivo fuente no pertenecen a ningún package concreto, sino que pertenecen
a un package por defecto sin nombre.
La agrupación de clases en packages es conveniente desde el punto de vista

organizativo, para mantener bajo una ubicación común clases relacionadas que
cooperan desde algún punto de vista. También resulta importante por la
implicación que los packages tienen en los modificadores de acceso, que se
explican en un capítulo posterior.
Claúsula import
Cuando se referencia cualquier clase dentro de otra se asume, si no se indica
otra cosa, que ésta otra está declarada en el mismo package. Por ejemplo:
package Geometria;
...
class Circulo {
Punto centro;
...
}
En esta declaración definimos la clase Circulo perteneciente al package

Geometria. Esta clase usa la clase Punto. El compilador y la JVM asumen que
Punto pertenece también al package Geometria, y tal como está hecha la
definición, para que la clase Punto sea accesible (conocida) por el compilador,
es necesario que esté definida en el mismo package.

Si esto no es así, es necesario hacer accesible el espacio de nombres donde

está definida la clase Punto a nuestra nueva clase. Esto se hace con la
clausula import. Supongamos que la clase Punto estuviera definida de esta
forma:
package GeometriaBase;
class Punto {
int x , y;
}
Entonces, para usar la clase Punto en nuestra clase Circulo deberiamos poner:
package GeometriaAmpliada;
import GeometriaBase.*;
class Circulo {
Punto centro;
...
}
Con la claúsula import GeometriaBase.*; se hacen accesibles todos los

nombres (todas las clases) declaradas en el package GeometriaBase. Si sólo
se quisiera tener accesible la clase Punto se podría declarar: import
GeometriaBase.Punto;
También es posible hacer accesibles los nombres de un package sin usar la

clausula import calificando completamente los nombres de aquellas clases
pertenecientes a otros packages. Por ejemplo:
package GeometriaAmpliada;
class Circulo {
GeometriaBase.Punto centro;
...
}

Sin embargo si no se usa import es necesario especificar el nombre del

package cada vez que se usa el nombre Punto.
La claúsula import simplemente indica al compilador donde debe buscar clases

adicionales, cuando no pueda encontrarlas en el package actual y delimita los
espacios de nombres y modificadores de acceso. Sin embargo, no tiene la
implicación de 'importar' o copiar código fuente u objeto alguno. En una clase
puede haber tantas sentencias import como sean necesarias. Las cláusulas
import se colocan después de la cláusula package (si es que existe) y antes de
las definiciones de las clases.
Nombres de los packages

Los packages se pueden nombrar usando nombres compuestos separados por
puntos, de forma similar a como se componen las direcciones URL de Internet.
Por ejemplo se puede tener un package de nombre
misPackages.Geometria.Base. Cuando se utiliza esta estructura se habla de
packages y subpackages. En el ejemplo misPackages es el Package base,
Geometria es un subpackage de misPackages y Base es un subpackage de
Geometria.
De esta forma se pueden tener los packages ordenados según una jerarquía
equivalente a un sistema de archivos jerárquico.
El API de java está estructurado de esta forma, con un primer calificador (java o
javax) que indica la base, un segundo calificador (awt, util, swing, etc.) que
indica el grupo funcional de clases y opcionalmente subpackages en un tercer
nivel, dependiendo de la amplitud del grupo. Cuando se crean packages de
usuario no es recomendable usar nombres de packages que empiecen por java
o javax.
Ubicación de packages en el sistema de archivos

Además del significado lógico descrito hasta ahora, los packages también
tienen un significado físico que sirve para almacenar los módulos ejecutables
(ficheros con extensión .class) en el sistema de archivos del ordenador.
Supongamos que definimos una clase de nombre miClase que pertenece a un

package de nombre misPackages.Geometria.Base. Cuando la JVM vaya a
cargar en memoria miClase buscará el módulo ejecutable (de nombre
miClase.class) en un directorio en la ruta de acceso
misPackages/Geometria/Base. Está ruta deberá existir y estar accesible a la
JVM para que encuentre las clases. En el capítulo siguiente se dan detalles
sobre compilación y ejecución de programas usando el compilador y la
máquina virtural distribuida por SUN Microsystems (JDK).
Si una clase no pertenece a ningún package (no existe clausula package ) se

asume que pertenece a un package por defecto sin nombre, y la JVM buscará
el archivo .class en el directorio actual.
Para que una clase pueda ser usada fuera del package donde se definió debe
ser declarada con el modificador de acceso public, de la siguiente forma:
package GeometriaBase;
public class Punto {

int x , y;
}
Si una clase no se declara public sólo puede ser usada por clases que
pertenezcan al mismo package

MANEJO DE EXCEPCIONES E HILOS
El término excepción es un forma corta da la frase "suceso excepcional" y

puede definirse de la siguiente forma.
Definición:
Una excepción es un evento que ocurre durante la ejecución del programa que
interrumpe el flujo normal de las sentencias.
Muchas clases de errores pueden utilizar excepciones -- desde serios

problemas de hardware, como la avería de un disco duro, a los simples errores
de programación, como tratar de acceder a un elemento de un array fuera de
sus límites. Cuando dicho error ocurre dentro de un método Java, el método

crea un objeto 'exception' y lo maneja fuera, en el sistema de ejecución. Este

objeto contiene información sobre la excepción, incluyendo su tipo y el estado
del programa cuando ocurrió el error. El sistema de ejecución es el
responsable de buscar algún código para manejar el error. En terminología
java, crear una objeto exception y manejarlo por el sistema de ejecución se
llama lanzar una excepción.
Después de que un método lance una excepción, el sistema de ejecución entra

en acción para buscar el manejador de la excepción. El conjunto de "algunos"
métodos posibles para manejar la excepción es el conjunto de métodos de la
pila de llamadas del método donde ocurrió el error. El sistema de ejecución
busca hacia atrás en la pila de llamadas, empezando por el método en el que
ocurrió el error, hasta que encuentra un método que contiene el "manejador de
excepción" adecuado.
Un manejador de excepción es considerado adecuado si el tipo de la excepción

lanzada es el mismo que el de la excepción manejada por el manejador. Así la
excepción sube sobre la pila de llamadas hasta que encuentra el manejador
apropiado y una de las llamadas a métodos maneja la excepción, se dice que
el manejador de excepción elegido captura la excepción.
Si el sistema de ejecución busca exhaustivamente por todos los métodos de la

pila de llamadas sin encontrar el manejador de excepción adecuado, el sistema
de ejecución finaliza (y consecuentemente y el programa Java también).
import java.awt.*;
import java.applet.Applet;
public class HolaIte extends Applet {

private int i = 0;
private String Saludos[] = {
"Hola Mundo!",
"HOLA Mundo!",
"HOLA MUNDO!!"
};

public void paint( Graphics g ) {

g.drawString( Saludos[i],25,25 );
i++;
}
}
Normalmente, un programa termina con un mensaje de error cuando se lanza

una excepción. Sin embargo, Java tiene mecanismos para excepciones que
permiten ver qué excepción se ha producido e intentar recuperarse de ella.
Vamos a reescribir el método paint() de nuestra versión iterativa del saludo:
public void paint( Graphics g ) {

try {
g.drawString( Saludos[i],25,25 );
} catch( ArrayIndexOutOfBoundsException e ) {
g.drawString( "Saludos desbordado",25,25 );
} catch( Exception e ) {
// Cualquier otra excepción
System.out.println( e.toString() );
} finally {
System.out.println( "Esto se imprime siempre!" );
}
i++;
}
La palabra clave finally define un bloque de código que se quiere que sea
ejecutado siempre, de acuerdo a si se capturó la excepción o no. En el ejemplo
anterior, la salida en la consola, con i=4 sería:
Saludos desbordado
¡Esto se imprime siempre!
Cuando se produce un error se debería generar, o lanzar, una excepción. Para

que un método en Java, pueda lanzar excepciones, hay que indicarlo
expresamente.

void MetodoAsesino() throws NullPointerException,CaidaException
Se pueden definir excepciones propias, no hay por qué limitarse a las

predefinidas; bastará con extender la clase Exception y proporcionar la
funcionalidad extra que requiera el tratamiento de esa excepción.
También pueden producirse excepciones no de forma explícita como en el caso

anterior, sino de forma implícita cuando se realiza alguna acción ilegal o no
válida.
Las excepciones, pues, pueden originarse de dos modos: el programa hace

algo ilegal (caso normal), o el programa explícitamente genera una excepción
ejecutando la sentencia throw (caso menos normal). La sentencia throw tiene la
siguiente forma:
throw ObtejoExcepction;
El objeto ObjetoException es un objeto de una clase que extiende la clase

Exception.
El siguiente código de ejemplo origina una excepción de división por cero:
class melon {
public static void main( String[] a ) {
int i=0, j=0, k;
k = i/j; // Origina un error de division-by-zero

}
}
Si compilamos y ejecutamos esta aplicación Java, obtendremos la siguiente
salida por pantalla:
> javac melon.java
> java melon
java.lang.ArithmeticException: / by zero
at melon.main(melon.java:5)
Las excepciones predefinidas, como ArithmeticException, se conocen como

excepciones runtime. Actualmente, como todas las excepciones son eventos
runtime, sería mejor llamarlas excepciones irrecuperables. Esto contrasta con

las excepciones que generamos explícitamente, que suelen ser mucho menos
severas y en la mayoría de los casos podemos recuperarnos de ellas. Por
ejemplo, si un fichero no puede abrirse, preguntamos al usuario que nos
indique otro fichero; o si una estructura de datos se encuentra completa,
podremos sobreescribir algún elemento que ya no se necesite.
Los nombres de las excepciones indican la condición de error que representan.

Las siguientes son las excepciones predefinidas más frecuentes que se
pueden encontrar:
ArithmeticException
Las excepciones aritméticas son típicamente el resultado de una división por 0:
int i = 12 / 0;
NullPointerException
Se produce cuando se intenta acceder a una variable o método antes de ser
definido:
class Hola extends Applet {

Image img;
paint( Graphics g ) {
g.drawImage( img,25,25,this );
}
}
IncompatibleClassChangeException
El intento de cambiar una clase afectada por referencias en otros objetos,

específicamente cuando esos objetos todavía no han sido recompilados.
ClassCastException
El intento de convertir un objeto a otra clase que no es válida.

y = (Prueba)x; // donde
x no es de tipo Prueba
NegativeArraySizeException
Puede ocurrir si hay un error aritmético al intentar cambiar el tamaño de un
array.
OutOfMemoryException
¡No debería producirse nunca! El intento de crear un objeto con el operador
new ha fallado por falta de memoria. Y siempre tendría que haber memoria
suficiente porque el garbage collector se encarga de proporcionarla al ir
liberando objetos que no se usan y devolviendo memoria al sistema.
NoClassDefFoundException
Se referenció una clase que el sistema es incapaz de encontrar.
ArrayIndexOutOfBoundsException
Es la excepción que más frecuentemente se produce. Se genera al intentar
acceder a un elemento de un array más allá de los límites definidos
inicialmente para ese array.
THREADS Y MULTITHREADING
Considerando el entorno multithread, cada thread (hilo, flujo de control del
programa) representa un proceso individual ejecutándose en un sistema. A
veces se les llama procesos ligeros o contextos de ejecución. Típicamente,
cada thread controla un único aspecto dentro de un programa, como puede ser
supervisar la entrada en un determinado periférico o controlar toda la
entrada/salida del disco. Todos los threads comparten los mismos recursos, al
contrario que los procesos en donde cada uno tiene su propia copia de código
y datos (separados unos de otros). Gráficamente, los threads se parecen en su
funcionamiento a lo que muestra la figura siguiente:

Programas de flujo único

Un programa de flujo único o mono-hilvanado (single-thread) utiliza un único
flujo de control (thread) para controlar su ejecución. Muchos programas no
necesitan la potencia o utilidad de múltiples flujos de control. Sin necesidad de
especificar explícitamente que se quiere un único flujo de control, muchos de
los applets y aplicaciones son de flujo único.
Por ejemplo, en nuestra aplicación estándar de saludo:
public class HolaMundo {

static public void main( String args[] ) {
System.out.println( "Hola Mundo!" );
}
}
Aquí, cuando se llama a main(), la aplicación imprime el mensaje y termina.
Esto ocurre dentro de un único thread.
Programas de flujo múltiple

En nuestra aplicación de saludo, no vemos el thread que ejecuta nuestro
programa. Sin embargo, Java posibilita la creación y control de threads
explícitamente. La utilización de threads en Java, permite una enorme
flexibilidad a los programadores a la hora de plantearse el desarrollo de
aplicaciones. La simplicidad para crear, configurar y ejecutar threads, permite
que se puedan implementar muy poderosas y portables aplicaciones/applets
que no se puede con otros lenguajes de tercera generación. En un lenguaje
orientado a Internet como es Java, esta herramienta es vital.

Si se ha utilizado un navegador con soporte Java, ya se habrá visto el uso de

múltiples threads en Java. Habrá observado que dos applet se pueden ejecutar
al mismo tiempo, o que puede desplazar la página del navegador mientras el
applet continúa ejecutándose. Esto no significa que el applet utilice múltiples
threads, sino que el navegador es multithreaded.
Las aplicaciones (y applets) multithreaded utilizan muchos contextos de
ejecución para cumplir su trabajo. Hacen uso del hecho de que muchas tareas
contienen subtareas distintas e independientes. Se puede utilizar un thread
para cada subtarea.
Mientras que los programas de flujo único pueden realizar su tarea ejecutando
las subtareas secuencialmente, un programa multithreaded permite que cada
thread comience y termine tan pronto como sea posible. Este comportamiento
presenta una mejor respuesta a la entrada en tiempo real.
Vamos a modificar nuestro programa de saludo creando tres threads
individuales, que imprimen cada uno de ellos su propio mensaje de saludo,
MultiHola.java:
// Definimos unos sencillos threads. Se detendrán un rato

// antes de imprimir sus nombres y retardos
class TestTh extends Thread {

private int retardo;
// Constructor para almacenar nuestro nombre

// y el retardo
public TestTh( String s,int d ) {
nombre = s;
retardo = d;
}
// El metodo run() es similar al main(), pero para

// threads. Cuando run() termina el thread muere
public void run() {
// Retasamos la ejecución el tiempo especificado

try {
sleep( retardo );
} catch( InterruptedException e ) {
;
}
// Ahora imprimimos el nombre

System.out.println( "Hola Mundo! "+nombre+" "+retardo );
}
}
public class MultiHola {

public static void main( String args[] ) {
TestTh t1,t2,t3;
// Creamos los threads

t1 = new TestTh( "Thread 1",(int)(Math.random()*2000) );
// Arrancamos los threads

t1.start();
t2.start();
t3.start();
}
}
PROYECTO: TIENDA
Este proyecto desarrollado con programación en Java usando el entorno de
desarrollo NetBeans consta de 5 archivos de extensión java:
Almacen.java
DetallePedido.java
Pedido.java
Producto.java
Sistema_Tienda.java

Sistema_Tienda.java contiene:
package proyecto_tienda;
import java.io.*;
public class Sistema_Tienda

{
public static int mostrarMenuPrincipal()throws IOException
{
int op;
System.out.println("MENU PRINCIPAL");
System.out.println("==============");
System.out.println("1. Adicionar Almacen");
System.out.println("2. Mantenimiento de Productos");
System.out.println("3. Realizar Pedidos");
System.out.println("4. Listar Productos");
System.out.println("5. Listar Pedidos");
System.out.println("6. Salir");
System.out.print("Ingresa una opcion: ");
op=Integer.parseInt(br.readLine());
return op;
}
public static int mostrarMenuProductos()throws IOException

{
int op;
System.out.println("MENU PARA PRODUCTOS");
System.out.println("===================");

System.out.println("1. Adicionar Producto");

System.out.println("2. Modificar Producto");
System.out.println("3. Salir");
System.out.print("Ingresa una opcion: ");
op=Integer.parseInt(br.readLine());
return op;
}

{
String nomalmacen, nompro;
int rpta=1, cant, opcion, r=0, numpro;
float pre;
Almacen oA= null;
Producto p;
do
{
opcion=mostrarMenuPrincipal();
switch (opcion)
{
case 1:
System.out.print("Ingrese el nombre del almacen: ");
nomalmacen=br.readLine();
oA= new Almacen(nomalmacen);
if(oA!=null)
System.out.println("Almacen creado ...");
break;
case 2:
do
{

r=mostrarMenuProductos();
switch(r)
{
case 1:
System.out.println("INGRESO DE PRODUCTOS");
System.out.println("====================");
do
{
System.out.print("CODIGO DEL PRODUCTO: ");
numpro=Integer.parseInt(br.readLine());
System.out.print("NOMBRE: ");
nompro=br.readLine();
System.out.print("STOCK: ");
cant=Integer.parseInt(br.readLine());
System.out.print("PRECIO: ");
pre=Float.parseFloat(br.readLine());
System.out.print("¿Desea ingresar los datos de otro
producto? (Si=1, No=0): ");
rpta=Integer.parseInt(br.readLine());
//Creacion del Objeto a partir de la Clase Producto
p=new Producto(numpro, nompro, cant, pre);
//Adiciona el objeto al Arreglo de Productos
oA.adicionarProducto(p);
}while(rpta==1);
break;
case 2:
//Falta hacer la modificacion de datos del producto
}
}while(r!=3);
break;
case 3:
// Falta hacer la realizacion del pedido

break;
case 4:
System.out.println("LISTA DE PRODUCTOS");
int total,i;
total=oA.getNproductos();
if (total>0)
for(i=0;i<total;i++)
{
p=oA.obtenerProducto(i);
System.out.println(p.getNombre()+"\t"+p.getStock()
+"\t"+p.getPrecio());
}
break;
case 5:
// Falta hacer el listado de pedidos
}
}while(opcion !=6);
System.out.println("Gracias por usar el pequeño Sistema ....");
}
}
Almacen.java contiiene:

{
//Atributos resultado de la relacion con la clase Producto
public Almacen(String nom)

{
nombre=nom;
//Creacion del arreglo de objetos producto
nproductos = 0;
}
//Método para adicionar o grabar un nuevo producto para un almacen

especifico
{
//Variable que nos servirá si realmente se registró el producto
String rpta;
if (nproductos < 100) {
productos[nproductos] = prod;
nproductos++;
//Un mensaje diciendo que se registro el producto
} else {
//Un mensaje diciendo que no se pudo registrar
}
return rpta;
}
//Método para obtener los datos del producto dado el indice

{
//El indice tiene que ser menor a la cantidad de elementos que tenemos en
el arreglo
if (indice < 0 || indice >= nproductos) {


return null;
} else {
}
}
//Método que permite buscar Producto x nombre

public Producto buscarProducto(String nom) {
Producto pro=null;
//Recorre el Arreglo de Productos
for(int i=0; i<nproductos; i++) {
//Verifica si existe el Producto x su nombre
if(nom.equals(productos[i].getNombre())) {
pro=obtenerProducto(i);
break; //sale del For
}
}
return pro;
}
public String modificarProducto(Producto prod) {

//Variable que nos indicara si realmente se registro el producto
String rpta;
int indice=-1;
for(int i=0; i<this.nproductos; i++) {
//Verifica si existe el Producto x su nombre
if(prod.getNombre().equals(this.productos[i].getNombre())) {
//ObjTabla.setValue(valor,nroFila,nroColumna)
indice=i;
break;//sale del For
}
}

if (indice < 100) {
this.productos[indice] = prod;
//Manda un mensaje diciendo que se registro el producto
rpta = "Se modificó el producto";
} else {
//Manda un mensaje diciendo que no se pudo registrar
rpta = "No se modificó el producto";
}
return rpta;
}

return nproductos;
}
return nombre;
}
}
Producto.java contiene:

{
//Atributos de la clase
private int numpro;
private int stock;
//Constructor
public Producto(int numpro, String nombre, int stock,float precio ) {

this.numpro = numpro;
this.stock = stock;
}
//Los Metodos Set y Get para cada atributo

public int getNumPro()
{
return numpro;
}

return nombre;
}

}

return stock;
}
public void setStock(int stock) {

this.stock = stock;
}

return precio;
}
public void setPrecio(float precio) {

}

return "Producto{" +"NumPro="+numpro+ " Nombre=" + nombre + ",
Precio=" + precio + ", Stock=" + stock + '}';
}
}
Pedido.java contiene:
public class Pedido {

private int numero;
private String fecha;
private String cliente;
//Atributos resultado de la relacion con la

//clase DetallePedido- Arreglo de Objetos
//DetallePedido
private int ndetalles;
private DetallePedido[] detalles;
//Constructor
public Pedido(int numero, String fecha,String cliente) {
this.numero = numero;
this.fecha = fecha;
this.cliente = cliente;
//Porque el primer indice va a ser cero
this.ndetalles = 0;
//Creamos el arreglo con un maximo de 50
this.detalles = new DetallePedido[50];
}
//Se obtiene el numero del pedido

public int getNumero() {
return numero;
}
//Se obtiene la fecha de emisión del pedido

public String getFecha() {
return fecha;
}

//Se obtiene el cliente que realizó el pedido

public String getCliente() {
return cliente;
}
//Se obtiene la cantidad de detalles que tiene el Pedido

public int getNdetalles() {
return ndetalles;
}
//Sirve para adicionar un detalle de pedido al pedido

public String adicionarDetalle(DetallePedido det) {
//Variable que nos indicara si realmente se registro el detalle
String rpta;
if (this.ndetalles < 50) {
this.detalles[this.ndetalles] = det;
this.ndetalles++;
//Manda un mensaje diciendo que se registro el detalle
rpta = "Se registro el detalle";
} else {
//Manda un mensaje diciendo que no se pudo registrar
rpta = "No se registro el detalle";
}
return rpta;
}
// Sirve para obtener un detalle de pedido segun el indice

public DetallePedido obtenerDetalle(int indice) {
//El indice tiene que ser menor a la cantidad de
//elementos que tenemos en el arreglo
if (indice < 0 || indice >= this.ndetalles) {
return null;
} else {
return this.detalles[indice];
}
}
//Sirve para obtener el total del Pedido

public float calcularTotalPedido() {
float total = 0;
//Tenemos que recorrer todos los detallesPedido

//Hasta la cantidad que nos indique la variable

//ndetalles
for (int i = 0; i < this.ndetalles; i++) {
//obtengo la cantidad
int cantidad = this.detalles[i].getCantidad();
//obtengo el precio
float precio = this.detalles[i].getPrecio();
//incremento el total
total += (cantidad * precio);
}
return total;
}
}
DetallePedido.java contiene:
public class DetallePedido

{
private int cantidad;
//Atributos que se obtiene de la relacion
//Con la clase DetallePedido
private Producto producto;
//Contructor
public DetallePedido(int cantidad, float precio, Producto producto) {
this.cantidad = cantidad;
this.producto = producto;
}
//Se obtiene la cantidad de Productos del Detalle

public int getCantidad() {
return cantidad;
}
//Se obtiene el precio del Producto

return precio;
}
//Se obtiene el producto que esta en el detalle

public Producto getProducto() {
return producto;

}
}
AUTOEVALUACION

1. Agrupación de clases afines se les denomina paquetes (verdadero o
falso): _______________________
2. Es un evento que ocurre durante la ejecución de un programa que
interrumpe el flujo normal de las sentencias: ____________________
3. Dos clases con el mismo nombre en dos paquetes distintos no pueden
coexistir e incluso no pueden usadas en el mismo programa (verdadero o
falso): _______________________
4. Controla un único aspecto dentro de un programa, como puede ser
supervisar la entrada en un determinado periférico o controlar toda la
entrada / salida del disco se denomina: ________________________
b) Muestra una lista de excepciones que te propone Java y la manera como

se debe interpretarlos al momento que se muestre en la ejecución de un
programa.
REFERENCIAS WEBGRAFICAS
http://dis.um.es/~bmoros/Tutorial/parte8/cap8-1a.html (La Clase Math)

http://www.webtaller.com/manual-java/clase-integer.php (La Clase Integer)
http://www.webtaller.com/manual-java/clase-character.php (La clase
Character)
http://www.webtaller.com/manual-java/clase-float.php (La clase Float)
http://www.webtaller.com/manual-java/clase-double.php (La clase Double)
http://es.scribd.com/doc/87261446/Introduccion-Java (La clase String,
Arreglos)
http://pruebaodshadow.blogspot.com/2010/11/estructuras-recursivas.html
(recursividad)
http://ingsolorzano.wordpress.com/clases-con-java/ (Estructura de una clase)
http://www.edukanda.es/mediatecaweb/data/zip/1305/page_38.htm
(Instanciar objetos)
http://www.buenastareas.com/ensayos/Constructor-Java/1411669.html
(Métodos constructores)
http://wwwdi.ujaen.es/asignaturas/progav/progav-tema2.pdf (Relaciones
entre clases)
http://mundogeek.net/archivos/2009/03/30/modificadores-en-java/
(Modificadores de acceso)
http://www.geocities.ws/marcelino_torres_villanueva/programacionorientada
aobjetos.pdf (Herencia de clases, polimorfismo)
http://dns.uls.cl/~ej/web_Poo_2010/Teo_Poo_2010/librojava.doc
(Clases abstractas)
http://www.webtaller.com/construccion/lenguajes/java/lecciones/clases-
contra-interfaces-java.php (Interfaces)
http://dis.um.es/~lopezquesada/documentos/IES_1011/DFSI/curso/UT6/java
/cap11/index.html (Interfaces)
Referencias bibliográficas (biblioteca virtual de la ULADECH)

1. PROGRAMACION EN JAVA2.Autor: Jesus Sanchez Allende, Gabriel Huecas
Fernandez-Toribio, Pilar Moreno Diaz.Editorial: McGraw-Hill España. Publicacion:
2005.Temas: Java2(lenguaje de programacion) Java(Computer program languaje).
2. Java: Soluciones de programación. Autor: Herbert Schildt. Editorial: McGraw-Hill

Professional Publishing. Fecha de publicación original: 12/2010. Temas: Lenguajes de
programación. Programación de ordenadores. Programming languages (Electronic
computers) Computer programming. Programacion.

Texto de Tecnicas de Programacion

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Texto de Tecnicas de Programacion

Cargado por

Copyright:

Formatos disponibles

Texto para el curso de

Ing. Martín Salcedo

Docente: Ing. Martín Salcedo Quiñones Pagina: 2

Docente: Ing. Martín Salcedo Quiñones Pagina: 3

METODOS DE CLASES DE JAVA

ESTRUCTURA DE UNA APLICACIÓN DE JAVA SENCILLA

Para compilar un programa de Java se hace lo siguiente

Docente: Ing. Martín Salcedo Quiñones Pagina: 4

C:\JDK1.3\BIN>javac HolaMundo.java <Intro>

Al hacer esto se crea un archivo llamado HolaMundo.class que es un archivo

Después de esto se utiliza el comando java para interpretar y ejecutar el

C:\JDK1.3\BIN>java HolaMundo <Intro>

- Las instrucciones en un programa Java se escriben en minúsculas

La clase BufferedReader para entrada de datos

Docente: Ing. Martín Salcedo Quiñones Pagina: 5

BufferedReader in = new BufferedReader( new

En este ejemplo se ha declarado una variable nombre de tipo String y se esta

La clase Math representa la librería matemática de Java. Las funciones que

Docente: Ing. Martín Salcedo Quiñones Pagina: 6

System.out.println("pi = " + Math.PI);

Los métodos que tiene la clase Math son:

 String Integer.toString( int i,int base );

Docente: Ing. Martín Salcedo Quiñones Pagina: 7

cadena=Integer.toString(valor); //no colcarle base se assume que es base 10

 int I.parseInt( String s,int base );

 Integer Integer.valueOf( String s,int base );

Al trabajar con caracteres se necesitan muchas funciones de comprobación y

La primera sentencia creará una variable carácter y la segunda un objeto

Docente: Ing. Martín Salcedo Quiñones Pagina: 8

Character.isLowerCase(c) //devuelve verdadero si el character está en minúscula

En este caso, si tuviésemos un objeto Character C , no se podría hacer

int i = Character.digit( c,base );

Métodos de la clase Character

C = new Character( 'J' );

La primera sentencia creará una variable float y la segunda un objeto Float:

Docente: Ing. Martín Salcedo Quiñones Pagina: 9

La función isNaN() comprueba si f es un No-Número . Un ejemplo de no-

La primera sentencia creará una variable double y la segunda un objeto

Métodos más usados en Double

Docente: Ing. Martín Salcedo Quiñones Pagina: 10

Los métodos mas utilizados son:

cadena.length() : El método length Devuelve el numero de Caracteres de una cadena.

cadena1.equals(cadena2) : El método equals devuelve true si las dos cadenas son

cadena1.equalsIgnoreCase(cadena2) : El método equalsIgnoreCase no toma en cuenta

cadena1.compareTo(cadena2) : El método compareTo devuelve un numero entero:

Docente: Ing. Martín Salcedo Quiñones Pagina: 11

< 0 Si cadena1 es menor que cadena2

cadena1.compareToIgnoreCase(cadena2) : El método compareToIgnoreCase no toma

cadena.charAt(indice) : El método charAt delvuelve el carácter que indica el indice.

cadena.toUpperCase() : Convierte la cadena a mayúsculas

cadena.toLowerCase() : Convierte la cadena en minúsculas

cadena.trim() : Elimina los espacios al inicio y al final de la cadena.

cadena1.startsWith(cadena2) : Devuelve verdadero si cadena1 comienza con cadena2.

cadena1.endsWith(cadena2) : Devuelve verdadero si cadena1 finaliza con cadena2.

cadena.indexOf(caracter) : Devuelve el índice de la primera ocurrencia del carácter.

cadena.indexOf(carácter,posicion) : Devuelve el índice de la primera ocurrencia del

cadena1.indexOf(cadena2) : devuelve el índice de la primera ocurrencia de cadena2 en

cadena1.indexOf(cadena2,posición): Devuelve el índice de la primera ocurrencia de la

cadena.lastIndexOf(caracter) : Devuelve el índice de la ultima ocurrencia del carácter.

cadena.lastIndexOf(carácter,posicion) : Devuelve el índice de la ultima ocurrencia del

cadena1.lastIndexOf(cadena2) : devuelve el índice de la ultima ocurrencia de cadena2

cadena1.lastIndexOf(cadena2,posición): Devuelve el índice de la ultima ocurrencia de

cadena.substring(indiceInicial, indiceFinal) : Devuelve una subcadena que esta

String.valueOf() : Convierte tipos primitivos a cadenas. La clase String sobrecarga el