5.-clases y objetos

5/9/2018 5.-Clases y Objetos - slidepdf.com

http://slidepdf.com/reader/full/5-clases-y-objetos 1/74

Java : Clases y Objetos

CAPITULO VOOP

CON JAVA

Los temas que se desarrollan en este capitulo son:

1. Fundamentos de OOP

2. Clases y Objetos

3. Variables Miembro

Variables de ClaseVariables de Instancia

4. Métodos

Métodos de Clase

Métodos de Instancia

Constructores

Creación de Objetos

Paquetes

HerenciaPolimorfismo

1




FUNDAMENTOS DE OOP

Como es sabido, la Programación Estructurada se caracteriza por la

representación de acciones a realizar mediante el uso de los algoritmos, los

cuales a su vez se implementan en bloques a los cuales se les aplican las

estructuras de control adecuadas y se obtienen los programas. La

Programación Orientada a Objetos (OOP), combina las mejores técnicas de

la Programación Estructurada con nuevos conceptos de Organización,

permitiendo descomponer un programa en grupos relacionados entre si,

Cada subgrupo pasa a ser un objeto autocontenido con sus propias

instrucciones y datos.

A diferencia de la Programación Estructurada que exige el diseño delalgoritmo y la estructura de datos adecuada, en OOP se describen primero

la entidades implicadas en el programa, siendo la clave de esta encontrar

características comunes entre entidades y crear estructuras de datos

(Objetos) que encapsulen esas características.

Las tres principales características de los lenguajes orientados a objetos son:

Encapsulación, Herencia y Polimorfismo.

Encapsulamiento :

Se define el encapsulamiento como la capacidad de envoltura y protección

alrededor del código y los datos que se manipulan. Esta envoltura define el

comportamiento y protege el código y los datos para evitar que otro código

acceda a ellos de manera arbitraria.

En Java el nivel de encapsulamiento por defecto es el paquete, siendo laclase la unidad mínima de encapsulamiento.

Herencia :

2




Es una propiedad que permite que un objeto herede propiedades y

característica de otra clase de objetos, existiendo una relación de jerarquía.

Es decir a partir de una clase que contiene los atributos generales (super

clase), se definen otras con atributos más específicos (sub clase).

Polimorfismo :

Es una propiedad que permite que un objeto tenga un comportamiento

distinto en función a una realidad. Es decir un objeto reaccionará o

responderá de una manera diferente ante diversas realidades.

3

Documentos

Factura Boleta Guía

Guía de Remisión




CLASES EN JAVA

Una clase es una agrupación de datos (atributos) y de funciones (métodos)

que operan sobre esos datos. La clases es el centro de la Programación

Orientada a Objetos.

Definición de una clase.

El modificador de visibilidad public, es opcional, si no se especifica

significa que la visibilidad de la clase es por defecto, es decir que la clase

solo será visible o accesible por las demás clases que se encuentran dentro

del paquete.

Todos los atributos y métodos de la clase, deben ser implementados dentro

de los {…}, que indican el inicio y fin de la clase.

Se recomienda que la primera letra del nombre de la clase siempre sea una

mayúscula.

4

[public] class NombreClase{

definición de atributos y métodos

…

}




Ejemplo:

Definir una clase Triangulo, con sus atributos base y altura y un método que

calcule el área.

5

public class Triangulo{

double base=0;

double altura=0;

double area(){

return base*altura/2;

}}




Variables Miembro

A diferencia de la Programación Estructurada o nivel de algoritmos que se

centraba en las funciones, la Programación Orientada a Objetos se centra en

los datos.

Funciones Miembro (Métodos)

Los métodos en Programación Orientada a Objetos son el equivalente a las

funciones en la Programación Convecional, los métodos definen el

comportamiento de la clase.

Variables de Instancia

Cada instancia o cada objeto (cada ejemplar concreto de la clase) contiene

su propia copia de variables miembro, conservando cada una de estas

variables su propio valor para cada objeto en particular. Es así que cada

objeto o instancia creada a partir de la clase Triangulo contendrá su propia

copia de la variables base y altura conservando para cada objeto o instancia

su propio valor en particular.

Las variables miembro de una clase (también llamadas atributos), pueden

ser de cualquier tipo primitivo de java (int, double, char, etc) o de cualquier

tipo compuesto (referencias a objetos de otra clase), siendo muy importante

para el correcto funcionamiento de los programas que estas sean

correctamente inicializadas.

Declaración de una Variable Miembro de Instancia

Declaración de Variables Miembro de Instancia (Atributos) de la Clase

Alumno.

6

tipoDeDato NombreVariable = ValorInicial;




Métodos de Instancia

Los Métodos de Instancia o de Objeto, son funciones que definen el

comportamiento de dicho objeto y tienen visibilidad directa a las variables

miembro del objeto.

Estructura general de un Método

7

public class Alumno{

int codigo=0; // variable de tipo primitivo int

String nombre=0; //variable de tipo compuesto String

String direccion=””; //variable de tipo compuesto String

char sexo=’ ’; // variable de tipo primitivo char

int edad=0; // variable de tipo primitivo int

}

Método

Parámetros o

Argumentos

Retorno




Declaración de Métodos de Instancia

Como podemos apreciar en la declaración del método, la lista de

Parámetros es opcional, es decir que no todos los métodos necesitan de parámetros para poder ejecutar la función para la cual son implementados.

Al igual que no todos los métodos tienen un valor de retorno. Cuando el

método no devuelve valores, el tipoDeDatoRetorno es void.

8

tipoDatoDeRetorno nombreMetodo( [listaDeParámetros] ){cuerpoDelMétodo

[return varlorDeRetorno;]}




Declaración de un Método de Instancia con parámetros y con Retorno

Ejemplo:

Este método calcula y devuelve el área de un triángulo. Para calcular el área

del triángulo se requiere conocer los valores de la base y la altura los cuales

son pasados como parámetros al método (double base, double altura),

conocidos estos valores se procede a calcular el área, la cual lo

almacenamos en una variable area previamente declarada double area=0;

una vez calculado el valor del área y almacenado en la variable

correspondiente, este es devuelto por el método return area;

Debe tener en cuenta que el valor devuelto (area), debe ser del mismo tipo

que el valorDeRetorno del método.

9

tipoDatoDeRetorno nombreMetodo( listaDeParámetros ){

cuerpoDelMétodo

return varlorDeRetorno;

}

double areaTriangulo(double base, double altura){

double area=0;

area=base*altura/2;

return area;

}




Declaración de un Método de Instancia con parámetros y sin Retorno

Ejemplo:

Este método calcula y muestra el área de un triángulo. Para calcular el áreadel triángulo se requiere conocer los valores de la base y la altura los cuales

son pasados como parámetros al método (double base, double altura),

conocidos estos valores se procede a calcular el área, la cual lo

almacenamos en una variable area previamente declarada double area=0

una vez calculado el valor del área, este se muestra en la consolaSystem.out.println(area).

Como este método no tiene retorno, observamos que es del tipo void.

Declaración de un Método de Instancia sin parámetros y con Retorno

10

void nombreMetodo( listaDeParámetros ){

cuerpoDelMétodo

}

void areaTriangulo(double base, double altura){

double area=0;

area=base*altura/2;

System.out.println(area);

}




Ejemplo:

Este método devuelve un número aleatorio comprendido entre 0 y 10, para

lo cual hace uso del método random() de la clase Math, el cual devuelve unnúmero aleatorio comprendido entre 0 y 1 el cual al multiplicarse por 10

genera un numero entre 0 y 10, el cual es almacenado en la variable num

previamente declarada y luego es devuelto return num.

Declaración de un Método de Instancia sin parámetros y sin Retorno

11

tipoDatoDeRetorno nombreMetodo( ){

cuerpoDelMétodoreturn varlorDeRetorno;

}

double numeroAleatorio(){

double num=0;

num=Math.random()*10;

return num;

}




Ejemplo:

Este método muestra el mensaje “Hola Desde Java” en la consola.

Para acceder a las Variables Miembro de Instancia y a las Funciones

Miembro de Instancia (Métodos de Instancia), se debe hacer siempre a

través de un objeto o instancia, es decir primero se debe instanciar o crear

un objeto de una determinada clase y luego acceder a sus atributos y

métodos a través del objeto creado.

12

void nombreMetodo( ){

cuerpoDelMétodo}

void mostrarSaludo(){System.out.println("Hola Desde Java...");

}




Constructores

Son métodos especiales cuya función es crear objetos a partir de la clase

reservando memoria e iniciando las variables miembro de la clase.

Una clase puede implementar más de un constructor y estos sólo pueden ser

llamados dentro de esta por otros constructores haciendo uso de la palabra

this. Dentro de este contexto la palabra this debe aparecer siempre como la

primera sentencia de código.

Además un constructor puede hacer referencia a un constructor de su super

clase, haciendo uso de la palabra super.

Un constructor siempre tendrá el mismo nombre de la clase que lo

implementa.

Definición de un Constructor

13

class NombreClase{

NombreClase(){ //Método Constructor

}

}




Ejemplo

Creación de Objetos

Un objeto es una instancia particular de una clase.

Para crear un objeto se hace uso del operador new y del constructor de laclase de la cual deriva el objeto.

Sintaxis para crear un Objeto

14

class Circulo{

double radio=0;

Circulo(){ //Método Constructor

super();

}

Circulo(double r){ //Método Constructor

radio=r;

}}

NombreClase NombreObjeto = new NombreConstructor();




Creación de Objetos de la Clase Circulo, previamente implementada.

Hemos creado tres objetos C1,C2 y C3 que son instancias particulares de la

clase Circulo. Estos objetos han sido creados haciendo uso de sus

constructores y cada uno de ellos conserva una copia de las variables

miembro de la clase Circulo (radio).

El Círculo C1 ha sido creado haciendo uso del primer constructor, y como

este no implementa ningún código solo reserva memoria para el objeto e

inicializa las variables miembro (radio=0).

Los Círculos C2 y C3 ha sido creados haciendo uso del segundo

constructor, y como este implementa un código, además de reservar

memoria para los objetos e inicializar las variables miembro (radio=0),

luego se asigna un valor en particular para la variable radio. (radio=5 para

C2) y (radio=10 para C3)

Como la variable miembro radio es una Variable de Instancia, cada objeto

en particular contiene una copia de esta variable, almacenando valores

particulares para cada objeto en particular.

15

Circulo C1 = new Circulo();Circulo C2 = new Circulo(5);

Circulo C3 = new Circulo(10);




La Clase Circulo

Resumen del Proceso de Creación de Objetos

Cada vez que se crea un nuevo Objeto:

16

radio=0

radio=0 radio=5 radio=10

C1 C2 C3

Objetos de la Clase

Circulo

- Se reserva la memoria necesaria

- Se da valor por defecto a las variable miembro de tipo primitivo.

- Se ejecutan los inicializadotes del objeto.

- Se ejecutan los constructores




Accediendo a las Variables Miembro de Instancia y

Funciones Miembro de Instancia de una Clase.

Para acceder a las Variables Miembro de Instancia y a las Funciones

Miembro de Instancia (Métodos de Instancia), se debe hacer siempre a

través de un objeto o instancia, es decir primero se debe instanciar o crear

un objeto de una determinada clase y luego acceder a sus atributos y

métodos a través del objeto creado.

Ejemplo 01.

Implementar una Clase llamada Triangulo_01, que permita calcular el área

y el perímetro de un triángulo en función de su base y su altura.

17

public class Triangulo_01 { //Inicio de la Clase

double base=0; //variable miembro base

double altura=0; //variable miembro altura

public Triangulo() {

super();

}

double area(){

double area=0;

area=this.base*this.altura/2;

return area;

}

Objeto.variableMiembro

Objeto.fuciónMiembro()




Ejecución.

18

public static void main(java.lang.String[] args) {

//Creamos el Objeto T1 de la Clase Triangulo_01

Triangulo_01 T1=new Triangulo_01 ();

//Le asignamos valores para la base y la altura de T1T1.base=5;

T1.altura=10;

//Mostramos los valores de la base, la altura y el área de T1

System.out.println("Triángulo T1");

System.out.println("=======================");System.out.println("Base\t:\t"+T1.base);

System.out.println("Altura\t:\t"+T1.altura);

System.out.println("Area\t:\t"+T1.area());

System.out.println("\n=======================");

System.out.println("Aplicación Finalizada...");

}

}//Fin de la Clase

Triángulo T1

=======================

Base : 5.0Altura : 10.0

Area : 25.0

=======================

Aplicación Finalizada...




Ejemplo 02.

Implementar una Clase llamada Triangulo_02, que permita calcular el área

y el perímetro de un triángulo en función de su base y su altura,

implementando un segundo constructor el cual permita crear objetosasignando directamente la base y la altura.

19




public Triangulo_02() { //Constructor 01

super();

}

public Triangulo_02(double b,double h) { //Constructor 02

this.base=b; //Asignamos el valor de b al atributo base

this.altura=h; //Asignamos el valor de h al atributo altura

}

double area(){ //método que calcula y devuelve el valor del área

double area=0;

area=this.base*this.altura/2;

return area;

}


//Creamos el Objeto T1 de la clase Triangulo_02,

//utilizando el segundo constructor a través del cual le

//asignamos directamente el valor de la base y la altura

Triangulo_02 T1=new Triangulo_02(5,10);



System.out.println("=======================");System.out.println("Base\t:\t"+T1.base);

System.out.println("Altura\t:\t"+T1.altura);

System.out.println("Area\t:\t"+T1.area());



}

}// Fin de la Clase




Ejecución.

Ejemplo 03.

20

Triángulo T1

=======================

Base : 5.0

Altura : 10.0

Area : 25.0

=======================





La Clase Triángulo anterior, con un poco más de orientación a objetos.

21




double area=0; //variable miembro area

public Triangulo_03() {

super();

}

//Método que asigna un valor para la altura del objeto que se cree

void registrarBase(double b){

this.base=b;

}

//Método que asigna un valor para la base del objeto que se cree

void registrarAltura(double h){

this.altura=h;

}

//Método que calcula el área del objeto que se cree y lo almacena

//en el atributo area

void calcularArea(){

this.area=this.base*this.altura/2;

}

//Método que devuelve el valor de la base del objeto que se cree

double obtenerBase(){

return this.base;

}

//Método que devuelve el valor de la altura del objeto que se creedouble obtenerAltura(){

return this.altura;

}

//Método que devuelve el valor del área del objeto que se cree

double obtenerArea(){

return this.area;

}


//Creamos el Objeto T1 de la clase Triangulo_03

Triangulo_03 T1=new Triangulo_03();

//Asignamos los valores de la base y la altura para T1,

//utilizando los métodos implementados registrarBase y

//registrarAlturaT1.registrarBase(5);

T1.registrarAltura(10);

//Calculamos el valor del área, utilizando el método

//calcularArea

T1.calcularArea();




22



System.out.println("=======================");

System.out.println("Base\t:\t"+T1.obtenerBase());

System.out.println("Altura\t:\t"+T1.obtenerAltura());

System.out.println("Area\t:\t"+T1.obtenerArea());



}

}//Fin de la Clase




Ejecución.

Para los casos anteriores, tanto las variables miembro(atributos), como las

funciones miembro (métodos), se han implementado en la misma clase en

23

Triángulo T1

=======================

Base : 5.0

Altura : 10.0

Area : 25.0

=======================





donde se han instanciado los objetos T1, sin embargo lo más correcto sería

que la clase implementada para que a partir de ella se creen los objetos,

debería contener únicamente los atributos y métodos del objeto, y los

objetos se puedan crear o instanciar desde cualquier otra clase, tal y

conforme se muestra en el siguiente ejemplo.

Ejemplo 04.

Implementamos una Clase llamada Triangulo_04, la cual servirá para

instanciar objetos (crear objetos Triangulo) a partir de ella, más no será una

clase que se pueda ejecutar, razón por la cual no le implementamos un

método main.

24




double area=0; //variable miembro area

public Triangulo_04() { //Constructor 1super();

}

public Triangulo_04(double b, double h) { //Constructor 2

this.base=b;

this.altura=h;

}

//Método que asigna un valor para la altura del objeto que se cree


this.base=b;

}

//Método que asigna un valor para la base del objeto que se cree


this.altura=h;

}

//Método que calcula el área del objeto que se cree y lo almacena

//en el atributo areavoid calcularArea(){

this.area=this.base*this.altura/2;

}

//Método que devuelve el valor de la base del objeto que se cree


return this.base;

}

//Método que devuelve el valor de la altura del objeto que se cree

double obtenerAltura(){return this.altura;

}

//Método que devuelve el valor del área del objeto que se cree


return this.area;

}

} // Fin de la Clase




Ahora implementamos una clase principal (ejecutable, con un método

main), para en ella instanciar (crear) objetos de la Clase no ejecutable

25

public class CrearTriangulos_01 { //Inicio de la Clase

public CrearTriangulos_01() {

super();

}



//utilizando el primer constructor

Triangulo_04 T1 = new Triangulo_04();

//Asignamos los valores de la base y la altura para T1,

//utilizando los métodos implementados registrarBase y

//registrarAltura

T1.registrarBase(5);

T1.registrarAltura(10);

//Calculamos el valor del área de T1, utilizando el método

//calcularAreaT1.calcularArea();


System.out.println("Tringulo T1");


System.out.println("Base\t:\t" + T1.obtenerBase());

System.out.println("Altura\t:\t" + T1.obtenerAltura());

System.out.println("Area\t:\t" + T1.obtenerArea());




Triangulo_04.

26


//utilizando el segundo constructor el cual ya asigna los

//valores para los atributos base y alturaTriangulo_04 T2 = new Triangulo_04(4,8);

//Calculamos el valor del área de T2, utilizando el método

calcularArea

T2.calcularArea();


System.out.println("\nTriángulo T2");


System.out.println("Base\t:\t" + T2.obtenerBase());

System.out.println("Altura\t:\t" + T2.obtenerAltura());

System.out.println("Area\t:\t" + T2.obtenerArea());



}

}// Fin de la Clase




Ejecución.

27

Triángulo T1

=======================

Base : 5.0

Altura : 10.0

Area : 25.0

Triángulo T2

=======================

Base : 4.0

Altura : 8.0

Area : 16.0

=======================





Ejemplo 5.

Implementar una Aplicación Java que permita calcular el área y el

perímetro de un triángulo en función de sus lados, los cuales serán leídos

desde el teclado. Verificar que los valores leídos para los lados puedan

formar el triángulo.

En todo triángulo, la suma de dos lados cualesquiera, siempre es menor al

tercer lado.

Siendo a,b y c los lados :

))()(( c sb sa s sarea −−−=

2

cba s

++=

Solución.

Implementamos una clase llamada Triangulo_05

28




Esta clase implementa por defecto un Constructor sin parámetros.

Para nuestro caso en particular le implementamos otro constructor con tres

parámetros del tipo double, los cuales permitirán asignar los valores para

los lados del triángulo.

Implementamos los métodos para asignar los valores a cada uno de los

lados del triángulo, para el caso que se utilice el constructor por defecto

para crear los objetos.

29

public class Triangulo_05 {


super();

}

}

public Triangulo_05(double a, double b, double c) {

//Asignamos los valores de a , b y c a los lados del triángulo

this.lado1=a;this.lado2=b;

this.lado3=c;

}




Este método necesita de dos parámetros que indican el número de Lado del

Triángulo (nLado) y el valor que tomará este lado (vLado).

Implementamos un método con estas características para no tener que crear

tres métodos iguales para asignar el valor a cada uno de los lados del

triángulo.

Utilizando el método anterior, para asignarle un valor a un lado del

triángulo lo haríamos de la siguiente forma:

Donde, el primer parámetro 2, indica que el valor asignado como segundo

parámetro 5.6, se asignará al segundo lado del triángulo.

Una vez que hemos implementado el método para registrar los lados del

triángulo, procedemos a implementar un método que permita verificar si los

lados registrados pueden formar o no un triángulo.

30

void registrarLado(int nLado, double vLado){

switch(nLado){

case 1: this.lado1=vLado;break;case 2: this.lado2=vLado;break;

case 3: this.lado3=vLado;break;

default : {

mostrarMensaje("\nError...\nNúmero de Lado

Incorrecto");

System.exit(0);

}

}}

Objeto.registrarLado(2,5.6)




El método a implementar devolverá un valor verdadero (true) para el caso

en que los valores registrados para los lados formen un triángulo y falso

(false) cuando no lo formen, por lo tanto el método devolverá un valor del

tipo boolean.

En este método, capturamos los valores de los lados lado1, lado2 y lado3 en

las variables a,b y c respectivamente y luego preguntamos si estos valorescumplen con la condición para formar un triángulo y se ser así, asignamos

el valor true a la variable de retorno xRet previamente declarada, de no ser

así, esta variable xRet se queda con su valor de inicio false, indicando que

los valores no corresponden a los de un triángulo. Luego este valor es

devuelto.

Una vez que tenemos el método que verifica si los lados registrados forman

o no un triángulo, implementamos los métodos para calcular el perímetro yel área del triángulo.

31

boolean esTriangulo(){

boolean xRet=false;

double a=this.lado1;

double b=this.lado2;double c=this.lado3;

if(a+b>c && a+c>b && b+c>a){

xRet=true;}

return xRet;

}

void calcularPerimetro(){


double b=this.lado2;

double c=this.lado3;

this.perimetro=a+b+c;

}




Para calcular el área del triángulo en función de sus lados, primero

verificamos si los lados registrados corresponden o no a los lados de un

triángulo y para ello hacemos uso del método esTriangulo previamente

implementado y si este devuelve un valor verdadero (true), entonces

procedemos a calcular el perímetro del triángulo utilizando el método

calcularPerimetro antes implementado ya que la fórmula calcula el área en

función de los lados y el semiperímetro (s=this.perimetro/2;) . Para

obtener la raíz cuadrada, utilizamos el método sqrt de la clase Math.

Puede apreciarse que para hacer referencia a las variables miembro de

instancia (lado1, lado2, lado3, area y perimetro) así como a las funciones

miembro de instancia o métodos de instancia (esTriangulo y

calcularPerimetro), no es necesario primero crear un objeto y luego

32


if (this.esTriangulo() = = true){

this.calcularPerimetro();

double s=this.perimetro/2;



double c=this.lado3;this.area=Math.sqrt(s*(s-a)*(s-b)*(s-c));

}else{

mostrarMensaje("Los Valores Ingresados para los

Lados\nNo Corresponden a los de un Triángulo");

System.exit(0); //Finaliza la aplicación

}

}




utilizarlas a través de él, sino que se hacen referencia directa a través de la

palabra this (opcional para este caso). Esto es posible puesto que estas

variables y métodos están siendo referenciadas desde por otros métodos que

se encuentran en la misma clase, no podría ser así si el método que lo

invoca es un método que pertenece a una clase distinta.

Finalmente procedemos a implementar los métodos para devolver los

valores de los lados del triángulo así como su área y su perímetro.

Este método requiere el parámetro entero nLado para poder determinar el

lado a devolver.

33

double obtenerLado(int nLado){

double vLado=0;

switch(nLado){case 1: vLado=this.lado1;break;

case 2: vLado=this.lado2;break;


default : {mostrarMensaje("\nError...\nNúmero de Lado

Incorrecto");

System.exit(0); //Finaliza la aplicación

}

}

return vLado;

}


return this.area;

}

double obtenerPerimetro(){

return this.perimetro;

}




El Código Completo

34


double lado1=0;

double lado2=0;

double lado3=0;

double area=0;

double perimetro=0;


super();

}

public Triangulo_05(double a, double b, double c) {

this.lado1=a;

this.lado2=b;

this.lado3=c;

}

void registrarLado(int nLado,double vLado){

switch(nLado){




default : {

mostrarMensaje("\nError...\nNúmero de

Lado Incorrecto");

System.exit(0);

}

}

}

boolean esTriangulo(){

boolean xRet=false;double a=this.lado1;



if(a+b>c && a+c>b && b+c>a){

xRet=true;

}

return xRet;

}

void calcularPerimetro(){




this.perimetro=a+b+c;

}




35


if (this.esTriangulo()){

this.calcularPerimetro();

double s=this.perimetro/2;



double c=this.lado3;this.area=Math.sqrt(s*(s-a)*(s-b)*(s-c));

}else{

mostrarMensaje("Los Valores Ingresados para los

Lados\nNo Corresponden a los de un Triángulo");

System.exit(0);

}

}

double obtenerLado(int nLado){

double vLado=0;

switch(nLado){




default : {

mostrarMensaje("\nError...\nNúmero de

Lado Incorrecto");System.exit(0);

}

}

return vLado;

}


return this.area;}




36

double obtenerPerimetro(){return this.perimetro;

}

void mostrarMensaje(String strMsg){

System.out.print(strMsg);

}

} //Fin de la Clase






Triangulo_05

Como en esta clase hacemos uso del teclado para el ingreso de los lados del

triángulo, requerimos utilizar la Clase BufferedReader e InputStreamReader

las cuales se encuentran en el paquete java.io, razón por la cual importamos

este paquete.

37

import java.io.*; //Importamos el paquete java.io public class CrearTriangulos_02 {

public CrearTriangulos_02() {

super();

}


//Creamos el Objeto Teclado

BufferedReader Teclado=new BufferedReader(new

InputStreamReader(System.in));

double a=0;

double b=0;

double c=0;



try{

//Leemos los Lados desde el Objeto Teclado y los

almacenamos en las variables a,b y c.

System.out.print("Ingrese Primer Lado\t\t:\t");

a=Double.valueOf(Teclado.readLine()).doubleValue();

System.out.print("Ingrese Segundo Lado\t:\t");

b=Double.valueOf(Teclado.readLine()).doubleValue();

System.out.print("Ingrese Tercer Lado\t\t:\t");

c=Double.valueOf(Teclado.readLine()).doubleValue();


//utilizando el primer constructor

Triangulo_05 T1 = new Triangulo_05();

//Asignamos los valores a cada uno de los lados del

//triángulo, utilizando el método registrarLado

T1.registrarLado(1,a);

T1.registrarLado(2,b);

T1.registrarLado(3,c);

//Calculamos el valor del área, utilizando el método

//calcularAreaT1.calcularArea();




38

//Mostramos los valores de los lados, el área y el

//perímetro de T1

System.out.println("\nResultados");

System.out.println("=======================");System.out.println("Lado 1\t\t:\t" + T1.obtenerLado(1));

System.out.println("Lado 2\t\t:\t" + T1.obtenerLado(2));

System.out.println("Lado 3\t\t:\t" + T1.obtenerLado(3));

System.out.println("Area\t\t:\t" + T1.obtenerArea());

System.out.println("Perímetro\t:\t" + T1.obtenerPerimetro());

}catch(IOException e){

System.err.println("Error al Leer los Datos adesde el

Teclado\n"+e.getMessage());}catch(NumberFormatException e){

System.err.println("Error de Formato del Dato\n"

+e.getMessage());

}



}

}//Fin de la Clase




Ejecución 01.

Ejecución 02.

39

Triángulo T1

=======================

Ingrese Primer Lado : 3

Ingrese Segundo Lado : 4

Ingrese Tercer Lado : 5

Resultados=======================

Lado 1 : 3.0

Lado 2 : 4.0

Lado 3 : 5.0

Area : 6.0

Perímetro : 12.0

=======================


Triángulo T1

=======================

Ingrese Primer Lado : 4

Ingrese Segundo Lado : 6Ingrese Tercer Lado : 12

Los Valores Ingresados para los Lados

No Corresponden a los de un Triángulo




40




Ejemplo 6.

Implementar una Aplicación Java que permita simular una Cuenta Bancaria

Básica y permita realizar movimientos como: Aperturar Cuentas, hacer depósitos, hacer retiros y consultar saldos.

Solución:

Implementamos una clase llamada Cuenta_01 y le definimos los atributos

numero y saldo.

Implementamos un nuevo Constructor para crear los Objetos Cuenta

asignándole un Número de Cuenta y un Saldo Inicial de la Cuenta.

41

public class Cuenta_01 {

String numero="";

double saldo=0;

public Cuenta_01() {

super();

}

}

public Cuenta_01(String xNumero, double xSaldo) {this.numero=xNumero;this.saldo=xSaldo;

}




Ahora le implementamos los métodos que permitan registrar los depósitos y

los retiros de la cuenta, así como un método que permita obtener el saldo

actual de la cuenta.

Para el case de un depósito, el nuevo saldo será igual al saldo actual más elmonto del depósito

Para el case de un retiro, el nuevo saldo será igual al saldo actual menos el

monto del retiro; pero no se podrá retirar una cantidad mayor al saldo actual

de la cuenta.

Método que devuelve el saldo actual de la cuenta

42

void deposito(double xMonto){

this.saldo+=xMonto;

}

void retiro(double xMonto){

if(xMonto<=this.saldo){this.saldo-=xMonto;

}else{

System.out.println("Cantidad no Disponible");

}

}

double obtenerSaldo(){

return this.saldo;

}




Código Completo:

43

public class Cuenta_01 { // Inicio de la Clase

String numero="";

double saldo=0;

public Cuenta_01() {

super();

}

public Cuenta_01(String xNumero,double xSaldo) {this.numero=xNumero;

this.saldo=xSaldo;

}

void deposito(double xMonto){

this.saldo+=xMonto;

}

double obtenerSaldo(){

return this.saldo;

}

void retiro(double xMonto){

if(xMonto<=this.saldo){

this.saldo-=xMonto;

}else{

System.out.println("Cantidad no Disponible");}

}







Cuenta_01

Como en esta clase hacemos uso del teclado para el ingreso de datos,utilizamos la Clase BufferedReader e InputStreamReader del paquete

java.io, razón por la cual importamos este paquete.

44

import java.io.*;

public class MovimientosCuentas { //Inicio de la Clase

public MovimientosCuentas() {super();

}


//Creamos el Objeto Teclado



//Declaramos las variables para almacenar el numero

de //cuenta y el saldo de la cuenta, así como el montodel //depósito y el monto del retiro

String nroCuenta="";double saldoCuenta=0;

double montoDeposito=0;

double montoRetiro=0;

try{

System.out.println("Movimientos Cuenta");System.out.println("===================");

//Leemos losa datos necesarios desde el Teclado

System.out.print("Número de Cuenta\t:\t");

nroCuenta=Teclado.readLine();




45

System.out.println("\nCuenta Nº "+nroCuenta);

System.out.println("===================");

//Leemos el monto de apertura de la cuenta

//desde el Teclado

System.out.print("Monto de Apertura\t:\t");saldoCuenta=Double.valueOf(Teclado.readLine()).doubleValue();

//Creamos una nueva Cuenta a partir de la Clase Cuenta_01

//y le asignamos el número y el saldo inicial de la cuenta

Cuenta_01 Cta01=new Cuenta_01(nroCuenta,saldoCuenta);

//Leemos el monto del depósito desde el Teclado

System.out.print("Monto Depósito\t\t:\t");montoDeposito=Double.valueOf(Teclado.readLine()).doubleValue();

//Asignamos el monto del depósito a la cuenta

Cta01.deposito(montoDeposito);

//Mostramos el saldo actual de la CuentaSystem.out.println("Saldo Actual\t\t:\t"+Cta01.obtenerSaldo());

//Leemos el monto del retiro desde el Teclado

System.out.print("Monto Retiro\t\t:\t");montoRetiro=Double.valueOf(Teclado.readLine()).doubleValue();

//Asignamos el monto del retiro a la cuenta

Cta01.retiro(montoRetiro);

//Mostramos el saldo actual de la Cuenta

System.out.println("Saldo Actual\t\t:\t"+Cta01.obtenerSaldo())




Ejecución 01.

46


System.err.println("Error al Leer los Datos desde el

Teclado\n"+e.getMessage());

}catch(NumberFormatException e){


+e.getMessage());

}

System.out.println("==============================");

System.out.print("Programa Finalizado...");

}


Movimientos Cuenta

==============================

Número de Cuenta : 04-015-274928

Cuenta Nº 04-015-274928

==============================

Monto de Apertura : 1000

Monto Depósito : 250

Saldo Actual : 1250.0

Monto Retiro : 750

Saldo Actual : 500.0==============================Programa Finalizado...




Ejecución 02.

47

Movimientos Cuenta==============================

Número de Cuenta : 01-012-206235

Cuenta Nº 01-012-206235

==============================

Monto de Apertura : 1500

Monto Depósito : 500

Saldo Actual : 2000.0Monto Retiro : 2250Cantidad no Disponible

Saldo Actual : 2000.0

==============================

Programa Finalizado...




Ejemplo 7.

Implementar una Aplicación Java que permita calcular la longitud de una

línea a partir de dos punto leídos desde el teclado. Cada punto consta de doscoordenadas (x,y).

Solución Matemática

Para una línea cualesquiera:

Por lo tanto, la longitud L de la línea será:

)()(22

yA yB xA xB L −− +=

48

A (x,y)

B(x,y)

L

xB - xA

yB - yA




Solución Java.

Para obtener la longitud de una línea, según el problema planteado,

requerimos el ingreso de dos puntos, cada uno de los cuales tiene dos

coordenadas (x,y). Por lo tanto implementamos una clase llamada Puntocon sus atributos coordenada X y coordenada Y.

Implementamos un segundo constructor con dos parámetros enteros de tal

forma que podamos asignar las coordenadas x e y al crear un objeto de laclase Punto.

corX = Coordenada x del punto.

corY = Coordenada y del punto.

49

public class Punto {

int x=0; //Atributo para la coordenada X

int y=0; //Atributo para la coordenada Y

public Punto() { // Constructor por defectosuper();

}

}

public Punto(int corX, int corY) {

this.x=corX;

this.y=corY;

}




Luego implementamos la Clase Linea, cuyos atributos serán los puntos

punto1 y punto2, que son objetos de la clase Punto previamente

implementada.

Implementamos un segundo constructor con dos parámetros del tipo Punto,

que permitan asignar los valores para los atributos punto1 y punto2 al crear

un objeto de la Clase Linea.

50

public class Linea {

//Declaración e inicialización de las variables miembro o atributos

//de la clase Linea, como punto1 y punto2 son variables del

tipo //Objeto, estos se inicializan en null.

Punto punto1=null;Punto punto2=null;

public Linea() {

super();

}

}

public Linea(Punto P01, Punto P02) {

this.punto1=P01;this.punto2=P02;

}




Antes de implementar el método para obtener la longitud de la línea,

implementamos un método para verificar si los puntos ingresados

corresponden a una línea, ya que puede darse el caso que tanto el punto1

como el punto2 tengan las mismas coordenadas, en tal caso sólo será un

punto no una Línea.

Verificamos si las coordenadas x e y del punto1 son iguales a las

coordenada x e y del punto2, en tal caso el método devolverá un valor false

indicando que no es una línea, en el caso contrario se devolverá el valor

true.

Luego implementamos el método para obtener la longitud de la línea.

51

boolean esLinea(){

boolean xRet=true;

if(punto1.x = = punto2.x && punto1.y = = punto2.y){

xRet=false;

}

return xRet;

}

double obtenerLongitud(){

double l=0;

if(esLinea()==true){

l = Math.sqrt(Math.pow(punto2.x-punto1.x,2)

+ Math.pow(punto2.y-punto1.y,2));

}else{

System.out.println("No es una Línea...Es un Punto");System.exit(0); //Finaliza la Aplicación

}

return l;

}




Código Completo : Clase Punto

Código Completo : Clase Linea

52

public class Punto {

int x=0;int y=0;

public Punto() {

super();

}

public Punto(int corX, int corY) {

this.x=corX;this.y=corY;

}

}

public class Linea {

Punto punto1=null;

Punto punto2=null;

public Linea() {super();

}




53

public Linea(Punto P01,Punto P02) {

this.punto1=P01;

this.punto2=P02;

}

boolean esLinea(){

boolean xRet=true;

if(punto1.x==punto2.x && punto1.y==punto2.y){

xRet=false;

}

return xRet;

}

double obtenerLongitud(){

double l=0;

if(esLinea()==true){

l=Math.sqrt(Math.pow(punto2.x-punto1.x,2)

+ Math.pow(punto2.y-punto1.y,2));

}else{

System.out.println("No es una Línea...Es un Punto");

System.exit(0);

}

return l;

}

}




Ahora procedemos a implementar una clase principal (ejecutable, con un

método main), para en ella instanciar (crear) objetos de la Clase no

ejecutable Linea.

54

import java.io.*;

public class LongitudLineas { } // Inicio de la Clase

public LongitudLineas() {

super();

}

public static void main(java.lang.String[] args) {//Creamos el Objeto Teclado

BufferedReader Teclado=new BufferedReader(

new InputStreamReader(System.in));

int xPA=0;

int yPA=0;

int xPB=0;

int yPB=0;

try{

System.out.println("Líneas");

System.out.println("======================");

//Leemos las coordenadas del primer punto desde el

//Objeto Teclado

System.out.println("\nCoordenadas del

Primer Punto : A(x,y)");


System.out.print("x\t=\t");xPA=Integer.parseInt(Teclado.readLine());

System.out.print("y\t=\t");

yPA=Integer.parseInt(Teclado.readLine());




55

//Creamos el primer punto A de la Clase Punto con sus

//respectivas coordenadas x e y.

Punto A=new Punto(xPA,yPA);

//Leemos las coordenadas del primer punto desde el

//Objeto Teclado

System.out.println("\nCoordenadas del

Segundo Punto : B(x,y)");


System.out.print("x\t=\t");

xPB=Integer.parseInt(Teclado.readLine());System.out.print("y\t=\t");yPB=Integer.parseInt(Teclado.readLine());

//Creamos el primer punto A de la Clase Punto con sus

//respectivas coordenadas x e y.

Punto B=new Punto(xPB,yPB);

//Creamos el Objeto L de la Clase Linea, con sus

//respectivos puntos A y BLinea L=new Linea(A,B);

//Mostramos la longitude de la línea creada

System.out.println("\nLongitud Línea\t:\t"

+L.obtenerLongitud());



Teclado\n"+e.getMessage());}catch(NumberFormatException e){

System.err.println("Error de Formato del

Dato\n"+e.getMessage());

}




Ejecución 01.

56


System.out.println("Programa Finalizado...");

}


Líneas========================================

Coordenadas del Primer Punto : A(x,y)

========================================

x = 5

y = 3

Coordenadas del Segundo Punto : B(x,y)

========================================

x = 9

y = 6

Longitud Línea : 5.0

========================================





Ejecución 02.

57

Líneas

========================================

Coordenadas del Primer Punto : A(x,y)

========================================

x = 5

y = 12

Coordenadas del Segundo Punto : B(x,y)

========================================x = 5

y = 12

No es una Línea...Es un Punto




Variables de Clase

A diferencia de las variables de Instancia, en donde cada instancia o cada

objeto (cada ejemplar concreto de la clase) contiene su propia copia de

variables miembro, conservando cada una de estas variables su propio valor

para cada objeto en particular, las Variables de Clase o Static son propias

de la Clase y no de un Objeto en particular. Estas variables se suelen

utilizar para definir constantes comunes para todos los objetos de la clase,

en donde para cada objeto instanciado de la clase, esta variable siempre

mantendrá el mismo valor.

Las variables miembro de clase, pueden ser de cualquier tipo primitivo de

java (int, double, char, etc) o de cualquier tipo compuesto (referencias aobjetos de otra clase), siendo muy importante que estas sean correctamente

inicializadas.

Declaración de una Variable Miembro de Clase

Declaración de Variables Miembro de Clase de la Clase Circulo.

58

static tipoDeDato NombreVariable = ValorInicial;

public class Circulo{

static int numCirculos=0; // variable de tipo primitivo int

static double pi=3.1416; //variable de tipo primitivo double

}




Métodos de Clase (static)

Los Métodos de Clase o Estáticos a diferencia de los Métodos de Instancia

no actúan sobre objetos concretos a través del operador punto y no tienen

sentido como métodos de objeto. Al declarar un método como estático o de

clase, se evita que este acceda a las variables de instancia no estáticas.

Estructura general de un Método

Declaración de Métodos de Clase (static)

La declaración de los métodos de Clase o Estáticos tiene la misma sintaxis

de declaración que los métodos de instancia solo que se le antepone elmodificador static.

59

Método

Parámetros o

Argumentos

Retorno

static tipoDatoDeRetorno nombreMetodo( [listaDeParámetros] ){

cuerpoDelMétodo

[return varlorDeRetorno;]

}




Declaración de un Método de Instancia con parámetros y con Retorno

Declaración de un Método de Instancia con parámetros y sin Retorno

Declaración de un Método de Instancia sin parámetros y con Retorno

Declaración de un Método de Instancia sin parámetros y sin Retorno

60

static void nombreMetodo( listaDeParámetros ){

cuerpoDelMétodo

}

static tipoDatoDeRetorno nombreMetodo( ){

cuerpoDelMétodo


}

static void nombreMetodo( ){

cuerpoDelMétodo

}

static tipoDatoDeRetorno nombreMetodo( listaDeParámetros ){cuerpoDelMétodo


}




Accediendo a las Variables Miembro static y

Funciones Miembro static de una Clase.

Para acceder a las Variables Miembro de Clase o Estáticas y a lasFunciones Miembro de Clase (Métodos Estáticos), se suele utilizar el

nombre de la clase en vez del nombre de un objeto de la clase.

Los métodos y las variables de clase son lo más parecido que Java tiene a

las variables y funciones globales de C++ o Visual Basic.

Ejemplo

Creación de Objetos de la Clase Circulo, previamente implementada.

61

Clase.variableMiembro

Clase.fuciónMiembro()

class Circulo{

double radio=0; //Variable de Instancia

static int numCirculos=0; //Variable de Clase

Circulo(){ //Método Constructor super();

numCirculos++;

}

Circulo(double r){ //Método Constructor

radio=r;numCirculos++;

}

}




Hemos creado tres objetos C1,C2 y C3 que son instancias particulares de la

clase Circulo. Estos objetos han sido creados haciendo uso de sus

constructores y cada uno de ellos conserva una copia de las variables

miembro de la clase Circulo (radio) y una referencia a la Variable de Clase

(numCirculos).

El Círculo C1 ha sido creado haciendo uso del primer constructor, el cual

reserva memoria para el objeto e inicializa las variables miembro (radio=0)

y luego incrementa el en uno el valor de la Variable de Clase numCirculos.

(Para C1, numCirculos=1)

Al crear el Círculo C2, se de reserva memoria para el objeto e inicializa la

variable miembro (radio=0), luego se asigna un valor en particular para la

variable radio. (radio=5) y se incrementa le valor de la Variable de ClasenumCirculos que ahora toma el valor 2.

Al crear el Círculo C3, se de reserva memoria para el objeto e inicializa la

variable miembro (radio=0), luego se asigna un valor en particular para la

variable radio. (radio=10) y se incrementa le valor de la Variable de ClasenumCirculos que ahora toma el valor 3.

Como la variable miembro numCirculos es una Variable de Clase, esta

conserva el mismo valor para cada uno de los objetos creados. Ahora lavariable numCirculos tiene el valor 3, para cada uno de los objetos.

La Clase Circulo

62

Circulo C1 = new Circulo();



Objetos de la

Clase Circulo

radio=0

radio=0 radio=5 radio=10

C1 C2 C3

numCirculos=3




Ejemplo 08

Implementar una aplicación que permita crear Objetos Rectángulo y

mostrar su área y que vaya contando cuantos objetos se van creando.

63

public class Rectangulo { // Inicio de la Clase

double base=0; //Variable de Instancia

double altura=0; //Variable de Instancia

double area=0; //Variable de Instancia

static int numRectangulos=0; //Variable de Clase para contar el

// número de objetos creados

public Rectangulo() {

super();

//Incrementamos el contador de Rectángulos cada vez

//que se crea un objeto de esta clase

numRectangulos++;

}

public Rectangulo(double b,double h) {

this.base=b; //Asignamos los valores para la base

this.altura=h; //Asignamos los valores para la altura

//Incrementamos el contador de Rectángulos cada vez

//que se crea un objeto de esta clasenumRectangulos++;

}


this.base=b;

}


this.altura=h;

}


this.area=this.base*this.altura;

}


return this.base;

}




64

double obtenerAltura(){

return this.altura;

}


return this.area;

}





Clase Principal (main) para crear Objetos de la Clase Rectángulo

65

public class CreaRectangulos { //Inicio de la Clase

public CreaRectangulos() {

super();

}


System.out.println("Rectángulos");

System.out.println("=========================");System.out.println("\nRectángulo 1");

System.out.println("=========================");

//Creamos el Objeto R1 de la Clase Rectángulo

//Utilizando en Constructor con Parámetros

//El cual asigna los valores para los atributos base y altura

//e incrementa el contador de rectángulos numRectangulos

Rectangulo R1=new Rectangulo(5,8);

System.out.println("Base\t\t:\t"+R1.obtenerBase());

System.out.println("Altura\t\t:\t"+R1.obtenerAltura());

//Calculamos el área de R1

R1.calcularArea();

//Mostramos el Area de R1

System.out.println("Area\t\t:\t"+R1.obtenerArea());

//Mostramos la cantidad de Rectángulos creados

System.out.println("Rectángulos Creados\t:\t"+Rectangulo.numRectangulos);

System.out.println("\nRectángulo 2");


//Creamos el Objeto R2 de la Clase Rectángulo

//Utilizando en Constructor sin parámetros el cual

//Inicia las variables de Instancia

//e incrementa el contador de rectángulos numRectangulos

Rectangulo R2=new Rectangulo();//Asignamos los valores para los atributos base

//y altura de R2

R2.registrarBase(4);

R2.registrarAltura(6);System.out.println("Base\t\t:\t"+R2.obtenerBase());

System.out.println("Altura\t\t:\t"+R2.obtenerAltura());

//Calculamos el área de R2

R2.calcularArea();

//Mostramos el Area de R2

System.out.println("Area\t\t:\t"+R2.obtenerArea());

//Mostramos la cantidad de Rectángulos creados

System.out.println("Rectángulos Creados\t:\t"+

Rectangulo.numRectangulos);

System.out.println("\n========================");


}

}//Fin de la Clase




Ejecución

66

Rectángulo 1

===========================

Base : 5.0

Altura : 8.0

Area : 40.0

Rectángulos Creados : 1

Rectángulo 2===========================

Base : 4.0

Altura : 6.0

Area : 24.0

Rectángulos Creados : 2

===========================





Si la variable de clase numRectangulos, se hubiera declarado como variable

de instancia, al momento de crear cada objeto se hubiese creado una copia

de esta variable para cada uno y se hubiese inicializado en 0, por lo tantoesta variable siempre tendría el valor de 1 y no contaría el número de

rectángulos que se van creando.

Ejemplo 09

Implementar una Aplicación que permita mostrar el número de días

correspondiente a un mes ingresado desde el teclado. (1 - 12).

67




Solución Java

Implementamos una Clase llamada DiasMes

68

public class DiasMes {// Inicio de la Clase

public DiasMes() {

super();

}

//Método de Clase para determiner si un año es bisiesto o no

//un año es bisiesto si es múltiplo de 4 pero no de 100 o

//es múltiplo de 100 y también de 400

static boolean esBisiesto(int xAnio){

boolean bisiesto=false;

if((xAnio%4 = = 0 && xAnio%100!= 0) ||

(xAnio%100 = = 0 && xAnio%400 = = 0)){

bisiesto=true;

}

return bisiesto;

}

//Método de clase para devolver el número de días

//correspondiente a un determinado mes (xMes) y un determinado

//año (xAnio), ya que para los años bisiestos febrero tiene 29 días

static int diasMes(int xMes,int xAnio){

int numDias=0;switch(xMes){

case 1:

case 3:

case 5:

case 7:

case 8:

case 10:

case 12:numDias=31;break;case 4:

case 6:

case 9:

case 11:numDias=30;break;

case 2:{

if(esBisiesto(xAnio)){

numDias=29;

}else{

numDias=28;}

}

break;

}

return numDias;

}

}// Fin de la Clase




Clase principal (ejecutable) para utilizar los métodos de la clase ya

DiasMes ya implementada.

69

public class NumeroDiasMes { //Inicio de la Clase

public NumeroDiasMes() {

super();}


System.out.println("Programa Número Días Mes");


//Creamos el objeto Teclado



int numAnio=0;

int numMes=0;

//Leemos el número del mes desde el teclado (1<=mes<=12)

try{

do{

System.out.print("Año\t\t\t\t:\t");

numAnio=Integer.parseInt(Teclado.readLine());

System.out.print("Mes (1 - 12)\t:\t");

numMes=Integer.parseInt(Teclado.readLine());}while(numMes<1 ||numMes>12);

//Mostramos el número de días del mes correspondiente

//haciendo uso del método de clase diasMes de la Clase DiasMes

System.out.println("Número de Días\t:\t"+

DiasMes.diasMes(numMes,numAnio));



Teclado\n"+e.getMessage());




70

}catch(NumberFormatException e){


+ e.getMessage());

}

System.out.println("\n=============================");


}

}//Fin de la Clase




Nótese que para hacer referencia al método distes(int,int), de la clase

DiasMes, no es necesario instanciar o crear un objeto de esta clase, sino que

se hace referencia directa utilizando el nombre de la Clase (DiasMes) , esto

es posible puesto que diasMes(int,int) es un Método de Clase (static).

Ejecución

Paquetes

Los paquetes son contenedores de clases e interfaces y también puedencontener a otros paquetes. Todas las clases contenidas en un paquete son

clases amigas y pueden compartir variables y métodos dentro de este

ámbito.

71

Programa Número Días Mes

==============================

Año : 2004

Mes (1 - 12) : 2

Número de Días : 29

==============================





Todas las clases en java se encuentran agrupada en paquetes además el

usuario puede crear sus propios paquetes para agrupar sus propias clases

relacionadas.

Para que una clase forme parte de un paquete hay que incluir la sentenciapackage nombrepaquete; al inicio de la clase.

Para utilizar un paquete o utilizar las clases incluidas en el, se debe importar

el paquete utilizando la sentencia import nombrepaquete;. Cuando se

importa un paquete, no se importan todas las clases del paquete sino

únicamente las clases publicas, tampoco se importan los sub paquetes. Por

ejemplo al importar el paquete java.awt, no se importa el paquete java.awt.event.

72




Herencia

La Herencia es el mecanismo por el que se crean nuevas clases definidas en

términos de clases ya existentes. La herencia relaciona clases en modo jerárquico, esto permite que una clase herede todas la variables y métodos

de su clases superior además de implementar sus propias clases y métodos.

Para indicar que una clase deriva de otra se utiliza la palabra extends.

Java permite múltiples niveles de herencia pero no permite que una clase

derive de varias, es decir no permite herencia múltiple.

Ejemplo de Herencia

73

[public] class NombreClase extends SuperClase{

definición de atributos y métodos

…}

public class Punto2D {int x=0;

int y=0;

public Punto2D() {

super();

}

public Punto2D(int corX, int corY) {super();

this.x=corX;

this.y=corY;

}

}




Implementamos una clase Punto2D, que contiene dos variables de instancia

que hacen referencia a las coordenadas x e y el punto. Luego le

implementamos un constructor que permita construir un objeto de la Clase

Punto2D asignando los valores para cada una de sus coordenadas.

Luego implementamos una Clase llamada Punto3D, para construir objetos

punto en tres dimensiones (x,y,z); pero como ya tenemos una Clase

(Punto2D) que implementa un punto con dos coordenadas, a partir de esta

clase derivamos la clase Punto3D la cual heredará las variables x e y de la

Clase Superiror Punto2D y solo le implementamos la tercera coordenada z,

además de un constructor que construya objetos punto en tres dimensiones.

74

5.-clases y objetos

Documents