5.-clases y objetos
TRANSCRIPT
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 2/74
Java : Clases y Objetos
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 3/74
Java : Clases y Objetos
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 4/74
Java : Clases y Objetos
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
…
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 5/74
Java : Clases y Objetos
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;
}}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 6/74
Java : Clases y Objetos
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;
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 7/74
Java : Clases y Objetos
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 8/74
Java : Clases y Objetos
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;]}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 9/74
Java : Clases y Objetos
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;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 10/74
Java : Clases y Objetos
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);
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 11/74
Java : Clases y Objetos
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;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 12/74
Java : Clases y Objetos
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...");
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 13/74
Java : Clases y Objetos
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
}
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 14/74
Java : Clases y Objetos
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();
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 15/74
Java : Clases y Objetos
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);
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 16/74
Java : Clases y Objetos
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 17/74
Java : Clases y Objetos
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()
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 18/74
Java : Clases y Objetos
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...
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 19/74
Java : Clases y Objetos
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 class Triangulo_02 { //Inicio de la Clase
double base=0; //variable miembro base
double altura=0; //variable miembro altura
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;
}
public static void main(java.lang.String[] args) {
//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);
//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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 20/74
Java : Clases y Objetos
Ejecución.
Ejemplo 03.
20
Triángulo T1
=======================
Base : 5.0
Altura : 10.0
Area : 25.0
=======================
Aplicación Finalizada...
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 21/74
Java : Clases y Objetos
La Clase Triángulo anterior, con un poco más de orientación a objetos.
21
public class Triangulo_03 { //Inicio de la Clase
double base=0; //variable miembro base
double altura=0; //variable miembro altura
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;
}
public static void main(java.lang.String[] args) {
//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();
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 22/74
Java : Clases y Objetos
22
//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.obtenerBase());
System.out.println("Altura\t:\t"+T1.obtenerAltura());
System.out.println("Area\t:\t"+T1.obtenerArea());
System.out.println("\n=======================");
System.out.println("Aplicación Finalizada...");
}
}//Fin de la Clase
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 23/74
Java : Clases y Objetos
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
=======================
Aplicación Finalizada...
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 24/74
Java : Clases y Objetos
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
public class Triangulo_04 { //Inicio de la Clase
double base=0; //variable miembro base
double altura=0; //variable miembro altura
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
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 areavoid 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 cree
double obtenerAltura(){return this.altura;
}
//Método que devuelve el valor del área del objeto que se cree
double obtenerArea(){
return this.area;
}
} // Fin de la Clase
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 25/74
Java : Clases y Objetos
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();
}
public static void main(java.lang.String[] args) {
//Creamos el Objeto T1 de la clase Triangulo_04,
//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();
//Mostramos los valores de la base, la altura y el área de T1
System.out.println("Tringulo T1");
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());
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 26/74
Java : Clases y Objetos
Triangulo_04.
26
//Creamos el Objeto T2 de la clase Triangulo_04,
//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();
//Mostramos los valores de la base, la altura y el área de T2
System.out.println("\nTriángulo T2");
System.out.println("=======================");
System.out.println("Base\t:\t" + T2.obtenerBase());
System.out.println("Altura\t:\t" + T2.obtenerAltura());
System.out.println("Area\t:\t" + T2.obtenerArea());
System.out.println("\n=======================");
System.out.println("Aplicación Finalizada...");
}
}// Fin de la Clase
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 27/74
Java : Clases y Objetos
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
=======================
Aplicación Finalizada...
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 28/74
Java : Clases y Objetos
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 29/74
Java : Clases y Objetos
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 {
public 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;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 30/74
Java : Clases y Objetos
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)
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 31/74
Java : Clases y Objetos
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 a=this.lado1;
double b=this.lado2;
double c=this.lado3;
this.perimetro=a+b+c;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 32/74
Java : Clases y Objetos
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
void calcularArea(){
if (this.esTriangulo() = = true){
this.calcularPerimetro();
double s=this.perimetro/2;
double a=this.lado1;
double b=this.lado2;
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
}
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 33/74
Java : Clases y Objetos
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;
case 3: vLado=this.lado3;break;
default : {mostrarMensaje("\nError...\nNúmero de Lado
Incorrecto");
System.exit(0); //Finaliza la aplicación
}
}
return vLado;
}
double obtenerArea(){
return this.area;
}
double obtenerPerimetro(){
return this.perimetro;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 34/74
Java : Clases y Objetos
El Código Completo
34
public class Triangulo_05 { //Inicio de la Clase
double lado1=0;
double lado2=0;
double lado3=0;
double area=0;
double perimetro=0;
public Triangulo_05() {
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){
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);
}
}
}
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 a=this.lado1;
double b=this.lado2;
double c=this.lado3;
this.perimetro=a+b+c;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 35/74
Java : Clases y Objetos
35
void calcularArea(){
if (this.esTriangulo()){
this.calcularPerimetro();
double s=this.perimetro/2;
double a=this.lado1;
double b=this.lado2;
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){
case 1: vLado=this.lado1;break;
case 2: vLado=this.lado2;break;
case 3: vLado=this.lado3;break;
default : {
mostrarMensaje("\nError...\nNúmero de
Lado Incorrecto");System.exit(0);
}
}
return vLado;
}
double obtenerArea(){
return this.area;}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 36/74
Java : Clases y Objetos
36
double obtenerPerimetro(){return this.perimetro;
}
void mostrarMensaje(String strMsg){
System.out.print(strMsg);
}
} //Fin de la Clase
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 37/74
Java : Clases y Objetos
Ahora implementamos una clase principal (ejecutable, con un método
main), para en ella instanciar (crear) objetos de la Clase no ejecutable
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();
}
public static void main(java.lang.String[] args) {
//Creamos el Objeto Teclado
BufferedReader Teclado=new BufferedReader(new
InputStreamReader(System.in));
double a=0;
double b=0;
double c=0;
System.out.println("Triángulo T1");
System.out.println("=======================");
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();
//Creamos el Objeto T1 de la clase Triangulo_05,
//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();
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 38/74
Java : Clases y Objetos
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());
}
System.out.println("\n=======================");
System.out.println("Aplicación Finalizada...");
}
}//Fin de la Clase
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 39/74
Java : Clases y Objetos
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
=======================
Aplicación Finalizada...
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 40/74
Java : Clases y Objetos
40
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 41/74
Java : Clases y Objetos
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;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 42/74
Java : Clases y Objetos
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;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 43/74
Java : Clases y Objetos
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");}
}
} // Fin de la Clase
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 44/74
Java : Clases y Objetos
Ahora implementamos una clase principal (ejecutable, con un método
main), para en ella instanciar (crear) objetos de la Clase no ejecutable
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();
}
public static void main(java.lang.String[] args) {
//Creamos el Objeto Teclado
BufferedReader Teclado=new BufferedReader(new
InputStreamReader(System.in));
//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();
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 45/74
Java : Clases y Objetos
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())
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 46/74
Java : Clases y Objetos
Ejecución 01.
46
}catch(IOException e){
System.err.println("Error al Leer los Datos desde el
Teclado\n"+e.getMessage());
}catch(NumberFormatException e){
System.err.println("Error de Formato del Dato\n"
+e.getMessage());
}
System.out.println("==============================");
System.out.print("Programa Finalizado...");
}
} // Fin de la Clase
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...
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 47/74
Java : Clases y Objetos
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...
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 48/74
Java : Clases y Objetos
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 49/74
Java : Clases y Objetos
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;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 50/74
Java : Clases y Objetos
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;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 51/74
Java : Clases y Objetos
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;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 52/74
Java : Clases y Objetos
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();
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 53/74
Java : Clases y Objetos
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;
}
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 54/74
Java : Clases y Objetos
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.println("======================");
System.out.print("x\t=\t");xPA=Integer.parseInt(Teclado.readLine());
System.out.print("y\t=\t");
yPA=Integer.parseInt(Teclado.readLine());
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 55/74
Java : Clases y Objetos
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.println("======================");
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());
}catch(IOException e){
System.err.println("Error al Leer los Datos desde el
Teclado\n"+e.getMessage());}catch(NumberFormatException e){
System.err.println("Error de Formato del
Dato\n"+e.getMessage());
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 56/74
Java : Clases y Objetos
Ejecución 01.
56
System.out.println("======================");
System.out.println("Programa Finalizado...");
}
} // Fin de la Clase
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
========================================
Programa Finalizado...
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 57/74
Java : Clases y Objetos
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 58/74
Java : Clases y Objetos
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
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 59/74
Java : Clases y Objetos
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;]
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 60/74
Java : Clases y Objetos
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
return varlorDeRetorno;
}
static void nombreMetodo( ){
cuerpoDelMétodo
}
static tipoDatoDeRetorno nombreMetodo( listaDeParámetros ){cuerpoDelMétodo
return varlorDeRetorno;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 61/74
Java : Clases y Objetos
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++;
}
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 62/74
Java : Clases y Objetos
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();
Circulo C2 = new Circulo(5);
Circulo C3 = new Circulo(10);
Objetos de la
Clase Circulo
radio=0
radio=0 radio=5 radio=10
C1 C2 C3
numCirculos=3
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 63/74
Java : Clases y Objetos
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++;
}
void registrarBase(double b){
this.base=b;
}
void registrarAltura(double h){
this.altura=h;
}
void calcularArea(){
this.area=this.base*this.altura;
}
double obtenerBase(){
return this.base;
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 64/74
Java : Clases y Objetos
64
double obtenerAltura(){
return this.altura;
}
double obtenerArea(){
return this.area;
}
} // Fin de la Clase
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 65/74
Java : Clases y Objetos
Clase Principal (main) para crear Objetos de la Clase Rectángulo
65
public class CreaRectangulos { //Inicio de la Clase
public CreaRectangulos() {
super();
}
public static void main(java.lang.String[] args) {
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");
System.out.println("=========================");
//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========================");
System.out.println("Programa Finalizado...");
}
}//Fin de la Clase
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 66/74
Java : Clases y Objetos
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
===========================
Programa Finalizado...
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 67/74
Java : Clases y Objetos
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 68/74
Java : Clases y Objetos
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 69/74
Java : Clases y Objetos
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();}
public static void main(java.lang.String[] args) {
System.out.println("Programa Número Días Mes");
System.out.println("=========================");
//Creamos el objeto Teclado
BufferedReader Teclado=new BufferedReader(new
InputStreamReader(System.in));
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));
}catch(IOException e){
System.err.println("Error al Leer los Datos desde el
Teclado\n"+e.getMessage());
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 70/74
Java : Clases y Objetos
70
}catch(NumberFormatException e){
System.err.println("Error de Formato del Dato\n"
+ e.getMessage());
}
System.out.println("\n=============================");
System.out.println("Programa Finalizado...");
}
}//Fin de la Clase
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 71/74
Java : Clases y Objetos
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
==============================
Programa Finalizado...
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 72/74
Java : Clases y Objetos
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
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 73/74
Java : Clases y Objetos
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;
}
}
5/9/2018 5.-Clases y Objetos - slidepdf.com
http://slidepdf.com/reader/full/5-clases-y-objetos 74/74
Java : Clases y Objetos
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