Implementación

Y uso de
Clases en Java:
Encapsulamiento

V2.0
Enero 2012
Ferreiras
Ferreiras IMPLEMENTACIO 1
 Exploración del Concepto “Caja Negra”,
“interfaz”:
ECM Si le preguntamos al
mecánico que cosa
hay dentro del ECM:

Interfaz para
conectar con los Que se yo !! Esa vaina es una
sensores. caja negra que se conecta a los
sensores para hacer funcionar
el vehiculo.
ECM: Electronic Control Module

Ferreiras IMPLEMENTACIO 2
 Encapsulamiento Es el proceso de
ocultar detalles de implementación,
mientras se publica una interfaz.
interfaz

En el ejemplo anterior,
anterior el mecánico
no tiene por que conocer los detalles
de implementación, le es suficiente con
la interfaz que le proporciona el ECM
para hacer sus conexiones.

Ferreiras IMPLEMENTACIO 3
 MAS DEL ENCAPSULAMIENTO
Toda clase consiste de dos partes:
Puede ser vista y usada por los
clientes de la clase

interfase
Que está oculta a los
usuarios de la clase.
Solo su desarrollador
IMPLEMENTACIÓN lo conoce.
(código fuente)

Ferreiras IMPLEMENTACIO 4
 Ocultar los detalles de implementación
de una clase se llama ocultamiento de
información o encapsulación;

 encapsulación se refiere a la
combinación de los datos y las operaciones
en un objeto;

 Ocultamiento de información se refiere

a la habilidad del objeto para ocultar sus
datos de código que esta fuera del objeto;

Ferreiras IMPLEMENTACIO 5
 La encapsulación protege el estado
interno del objeto de ser corrompido por sus
clientes;

 La encapsulación protege el código del

cliente de que se vea afectado por cambios
en la representación interna de un objeto;

Ferreiras IMPLEMENTACIO 6
 La encapsulación prevé que los valores
de los atributos del objeto puedan ser
cambiados únicamente por operaciones
suplidas por el objeto mismo;

 La encapsulación proporciona
operaciones para acceder a los valores de
los atributos que el cliente necesita
cambiar;

Ferreiras IMPLEMENTACIO 7
 El encapsulamiento impide que el
estado del objeto no puede ser modificado
directamente por el cliente;

 El encapsulamiento garantiza que el

código cliente puede usar únicamente las
operaciones proporcionadas en la
interfase;

Ferreiras IMPLEMENTACIO 8
 El encapsulamiento impide que el
código cliente puede conocer la
implementación de las operaciones ni tomar
ventajas de ello;

 El encapsulamiento garantiza que el

código cliente no será afectado por
cambios en la implementación

Ferreiras IMPLEMENTACIO 9
 Gráficamente: Objeto

Interfaz

 operaciones
Cliente  definidas en
 la clase del
 objeto

Un cliente interactuando con

un objeto por medio de su
interfaz. Datos

Ferreiras IMPLEMENTACIO 10
 En JAVA, se logra el encapsulamiento
en objetos usando modificadores, llamado
modificadores de visibilidad,
visibilidad debido a
que controlan el acceso a los miembros de
la clase. Las palabras reservadas public,
private y protected son modificadores de
visibilidad que se aplican a las variables y a
los métodos de las clases.

Ferreiras IMPLEMENTACIO 11
 Operaciones de acceso, de
transformación
Debido a que los datos son encapsulados
(private), toda clase debe proveer las
operaciones para accederlos y
modificarlos. Las operaciones de acceso
permiten acceder a los datos y las
operaciones de transformación permiten
cambiarlos.

Ferreiras IMPLEMENTACIO 12
Implementación
De clases
En JAVA

Ferreiras IMPLEMENTACIO 13
 La implementación de una
clase
 provee una plantilla para la creación de objetos;

 establece qué tipos de datos se utilizaran para

representar los atributos;

 implementa las funciones que representarán las

operaciones de los objetos que representa;

Ferreiras IMPLEMENTACIO 14
 PROCESO PARA LA
IMPLEMENTACIÓN DE UNA
CLASE EN JAVA
A partir de de la especificación de las clases
identificadas en el proceso “Encontrando
Clases”, escrita en la forma

NombreClase(atr1, atr2,…; acc1, acc2, …);

Ferreiras IMPLEMENTACIO 15
 Los atributos son mapeados a
variables miembros de la clase;

 Las operaciones (acciones)son

mapeadas como métodos de la clase

Ferreiras IMPLEMENTACIO 16
 Definición de clases en java
class NombreDeLaClase {
// Encapsulamiento
private T var1; Mapea los atributos
private T var2; a variables miembro
...
private T var;
// Interfaz
public T metodo1( ){ ... } Mapea las
public T metodo2( ) { ... } operaciones a
... métodos de la
public T metodo( ){ ... } clase
}

T es cualquier tipo válido

Ferreiras IMPLEMENTACIO 17
Por ejemplo: La parte de la clase
class AsignacionNotas { que encapsula la
información que
private String nombre; almacenarán sus
private int nota; objetos.
private double indice;
La parte de la
public String getNombre(){ }
clase que
public void setNota(int n ){ }
public void calculaIndice( ){ }
establece la
interfaz para sus
} usuarios.
Obsérvese que los métodos son
definidos completamente dentro
de la clase.

Ferreiras IMPLEMENTACIO 18
cada instancia de la clase poblará su data
con valores particulares de sus atributos;

 en cualquier momento una clase tiene cero o

mas instancias;

 la afiliación de clase de un objeto no cambia

durante su vida útil;

Ferreiras IMPLEMENTACIO 19
 las operaciones de la clase pueden ser
invocadas por cada una de sus instancia;

 usualmente, las clases son estáticas, su

existencia, semántica y relaciones están
definidas antes de la ejecución del programa;

 los objetos son dinámicos, pueden ser

creados y destruidos durante la ejecución del
programa ;

Ferreiras IMPLEMENTACIO 20
 Partes de una Clase JAVA
Inicio
bloque de
la clase

Especificador de acceso
a nivel de clases
class nombreDeLaClas {
e

Especificador de acceso
a nivel de miembros de la clase
Variables de instancia

Especificador de acceso
a nivel de miembros de la clase
Métodos

fin
bloque de }
la clase

Ferreiras IMPLEMENTACIO 21
 Especificador de nombre de la clase
acceso a nivel de
Por ejemplo: la clase

Variable

public class Libro {

Método
private int numeroPaginas;
Especificador de acceso
a nivel de miembros public void setPaginas( int num){
de la clase

numeroPaginas = num;
}
} Variable local al
método

Ferreiras IMPLEMENTACIO 22
 Los modificadores de acceso a nivel de
clase :
public
Significa que a la clase se puede acceder
desde cualquier lugar;

Si la clase no tiene modificador

Significa que a la clase solo se puede
acceder en el mismo archivo o en el mismo
paquete ( package-private, a ver más adelante );

Ferreiras IMPLEMENTACIO 23
 Los modificadores de acceso a nivel de
miembros ( variables y métodos ) :
public
Significa que se le puede acceder desde
cualquier lugar; Es visible para todas las clases
en todas partes.

Si no tiene modificador
Significa que solo se le puede acceder en
el mismo archivo o en el mismo paquete
(package-private, a ver más adelante );
Ferreiras IMPLEMENTACIO 24
private
Significa que puede ser accedido solamente
por miembros de la misma clase, en su misma
clase; Solo puede ser accedido en su propia
clase;

protected
Significa que se le puede acceder desde el
mismo package o desde cualquier subclase
( clase derivada) de su clase, existente en
cualquier otro package.

Ferreiras IMPLEMENTACIO 25
 En resumen:

Misma Mismo otros

Subclase
Modificador de clase Package packages
acceso
public S S S S
protected S S S N
no access
S S N N
modifier
private S N N N

Ferreiras IMPLEMENTACIO 26
class Es una palabra reservada de JAVA, la cual
comunica al intérprete que se definirá una nueva
clase ; Todo el quehacer de JAVA esta en una
class;

nombreDeLaClase Es el nombre de la clase y

debe ser descriptivo de ésta; Suele ser muy
largo, muy laaaargo, en JAVA; Se escribe como
mostrado, esto es, al estilo “camellado”. Por
ejemplo:
ClaseVerLimitesTipoPrimitivo

En el archivo fuente ClaseVerLimitesTipoPrimitivo.java

Ferreiras IMPLEMENTACIO 27
variables de instancia Son declaradas
dentro de la clase ( es decir, una variable
miembro), pero no dentro de un método;
Es una variable de la cual cada objeto de la
clase tendrá una copia por separado y viven
en RAM durante la vida de éste.

Ferreiras IMPLEMENTACIO 28
 Una variable de instancia (también
llamada campo de instancia) es una
variable que se relaciona con una sola
instancia de una clase. Cada vez que una
instancia de una clase se crea, el sistema
crea una copia de las variables de instancia
relacionadas con esa clase.

Ferreiras IMPLEMENTACIO 29
 Por defecto, todas las variables se
crean como variables de instancia;
instancia

 Se recomienda Que todas las

variables de instancias sean private,
para garantizar el encapsulamiento
de la información, uno de los
prinicipios básicos de la TOO;

Ferreiras IMPLEMENTACIO 30
 Lo contrario de una variable de
instancia es una variable estática,
también conocida como una
variable de clase.
clase Una variable
estática existe en todas las
instancias de una clase ( Ver más
adelante “static en JAVA”).

Ferreiras IMPLEMENTACIO 31
 Por ejemplo:
class EjemploDeVariables { Variables de instancia

private boolean respuesta;

Variable de clase
private long codigoCliente;
public static int visitantes;
public final static TASA_DE_CAMBIO = 38.00;
....
Constante
}

Ferreiras IMPLEMENTACIO 32
 Dentro de un método,
método en Java NO es
posible declarar variables static:
// Vichy0.java No compila. El error
class Fofi {
reportado es: “illegal
void Yiyo( double x) {
start of expression” en
static double y = 0.0;
static double y = 0.0;
}

}
public class Vichy0 {
public static void main( String [ ] args ) {
//...
}
}

Ferreiras IMPLEMENTACIO 33
Métodos ( funciones miembro ) Son
una parte integral de cualquier clase
Java; Toda clase java contiene al menos
un método, el método principal main();
Un método java puede ser de instancia,
de la clase, auxiliar ó un constructor.

Ferreiras IMPLEMENTACIO 34
Método de instancia Es un método que
está asociado con un objeto y utiliza las
variables de instancia de ese objeto.

Lo contrario de un método de instancia es

un método estático, También conocido
como método de la clase; Por defecto, un
método es un método de instancia.

Ferreiras IMPLEMENTACIO 35
 Método de clase ( ó método static) Es
un método que pertenece a su clase, en
lugar de a un objeto de esa clase;
Mientras que un método de instancia
tiene acceso tanto a las variables de
instancia como a las variables de clase,
un método de clase sólo tiene acceso a
las variables de clase (variables static).

Ferreiras IMPLEMENTACIO 36
 Un método de clase se declara con el
modificador static, así, por ejemplo:

public static tipoDeRetorno metodoStatic(lista de parametros){

// cuerpo del método
}

Ferreiras IMPLEMENTACIO 37
En un método static La palabra clave
static adhiere el método a la clase, en
lugar de a los objetos de esa clase;
Para invocarlo, se hace con el nombre
de la clase, en lugar de un objeto de
ésta:

ClaseConMetodoStatic.metodoStatic();

Ferreiras IMPLEMENTACIO 38
Método constructor Es un método
especial que se utiliza para inicializar
las variables miembro de un objeto
recién creado. Es la forma correcta
para definir el estado inicial de un
objeto.

Ferreiras IMPLEMENTACIO 39
Un Método constructor Se caracteriza
porque:

 Tiene un solo modificador ( public o private ). Rara

vez es private;
 No retorna ningún valor, ni siquiera void;
 Tiene exactamente el mismo nombre de su clase;
 No puede ser invocado directamente. La palabra
reservada “new” debe ser usada;

Ferreiras IMPLEMENTACIO 40
Por ejemplo (definición) :

public Libro() { Constructor por

defecto, definido por
numeroPaginas = 344; el desarrollador
}

Constructor con
public Libro( int paginas) { parámetros para
numeroPaginas = paginas; argumentos

Ferreiras IMPLEMENTACIO 41
Por ejemplo (uso) :
Construye, crea un
objeto Libro con
Libro unLibro = new Libro();
valores por defecto.

Libro otroLibro = new Libro(1344);

Construye, crea un
objeto Libro con
valores
especificados como
argumentos del
constructor

Ferreiras IMPLEMENTACIO 42
 Si un constructor no es definido para la
clase, JAVA usa su constructor implícito por defecto para
inicializar las variables a sus valores por defecto:

 Las variables de tipo numérico son establecidas a 0;

 Las variables de tipo char son establecidas al
carácter nulo ‘\0’;
 Las referencias de las variables objetos son
establecidas a null;

Ferreiras IMPLEMENTACIO 43
 Sobrecarga de Constructores La clase
puede tener cualquier cantidad de
constructores. Para diferenciarlo el
compilador se basa en los tipos, la cantidad
y el orden de los parámetros:

Libro() { ... }
Libro(int x) { ... }
Libro( String c, double p, int z) { ... }

Ferreiras IMPLEMENTACIO 44
 Cuando un objeto es construido,
construido
ocurren las siguientes acciones:
 Todas las variables de instancia son inicializadas con
0, false o null;
 Los inicializadotes y los bloques de inicialización son
ejecutados en el orden en el cual fueron declarados;
 El cuerpo del constructor es invocado;

Ferreiras IMPLEMENTACIO 45
Método auxiliar Es un método que es
exclusivo a la clase; Solo otros métodos en la
misma clase lo pueden invocar. No están
destinado para prestar servicios directamente
a clientes fuera de la clase. Se declara con el
modificador private:
private tipoDeRetorno nombreDelMetodo( lista par){
// cuerpo
}

Ferreiras IMPLEMENTACIO 46
{ y } Las llaves,
llaves Indican el inicio y el
final del cuerpo de la clase.

class Ferrom { // Inicio del cuerpo de la clase

// Cuerpo de la clase

} // Fin del cuerpo de la clase

Ferreiras IMPLEMENTACIO 47
Estructura de una clase JAVA
La organización (recomendada) de las
partes de una clase JAVA es como sigue:
 Las variables miembros al principio, antes que los métodos;
 Los métodos son organizados así, en ese orden:
 constructores
 métodos generales ( acceso y cambio )
 métodos estáticos
 métodos private ( si los hay )
 método main ( si hay uno en el archivo ) de ultimo.

Ferreiras IMPLEMENTACIO 48
Estructura de un Test-Driver
de Clases en JAVA
declaraciones de import (si requeridas)
class C1{ }
Debe ser el mismo nombre del archivo fuente
class C2 { } nombreArchivo.java, así lo prefiere Ferreiras.
...
public class nombreArchivo{
// ...
public static void main(String[] args) {
// ...
}
}
Ferreiras IMPLEMENTACIO 49
 El método main()
Es el punto de entrada donde el proceso de
ejecución de la aplicación java comienza. Un
programa java no podrá funcionar sin el
método main(). La JVM busca este método
para la ejecución de la aplicación. Es siempre
lo primero que se ejecuta en un programa
java.

Ferreiras IMPLEMENTACIO 50
 El método main() tiene la siguiente
estructura y sintaxis, obligatoria:
public static void main(String[ ] args) {

// Cuerpo
}

String[ ] args Son los argumentos de “línea de comando”.

Es obligatorio su uso, aunque no sean explícitamente
evaluados dentro del método.

 Cada sentencia dentro del bloque main() es ejecutada por

la JVM.

Ferreiras IMPLEMENTACIO 51
 Cada aplicación java debe tener un
método main(), así:

public class nombreDeLaAplicacion{

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

// Cuerpo
} Lo recomendable es
} que en esta clase solo
se escriba el método
main()

Ferreiras IMPLEMENTACIO 52
String[ ] args Indica que main() tiene un
arreglo de referencias a String; Los
elementos del arreglo se refieren a cadenas
que contienen texto que es suplido en la
línea de comando que inicia el programa.
Por ejemplo:
C:\>java StringDemo stringA stringB stringC ...

args[0] args[1] args[2] ...

Ferreiras IMPLEMENTACIO 53
Clase0a.java
jdk1.6.0_25

Ferreiras / JAVA / Argumentos en linea de comando

public class Clase0a{

public static void main (String args[]) {
System.out.println("\n\t" + args[0] + " " + args[1]);
}
}

C:\Program Files\Java\jdk1.6.0_22\bin>java Clase0a Hola Ferreiras

Hola Ferreiras

C:\Program Files\Java\jdk1.6.0_22\bin>

Ferreiras IMPLEMENTACIO 54
 Uso de la clase: Creación de
objetos en java
En JAVA:
 Variable primitiva: Almacenan valores de los
tipos primitivos de java, esto es, valores tipo byte,
short, int, long, float, double, char, boolean, que les
son asignados.
 Variable objeto: Almacena una referencia a un
objeto, esto es, almacena la dirección del objeto al
que se refiere, es también llamada “puntero al
objeto”. (Ver mas adelante Clase1.java)
Ferreiras IMPLEMENTACIO 55
 instanciación Es el acto de la creación de un
objeto mediante el operador new. Un objeto se
dice que es una instancia de una clase en
particular. El operador new crea el objeto, usando
el constructor apropiado, y retorna su referencia
(una dirección en RAM) que es almacenada en la
variable objeto. La variable objeto es un sinónimo,
un alias, del objeto.

Ferreiras IMPLEMENTACIO 56
 Construye, crea un
Por ejemplo : objeto Libro con valores
por defecto.

Libro unLibro = new Libro( );

Libro otroLibro = new Libro(1344);

Construye, crea un
objeto Libro con valores
especificados como
argumentos del
Usando el constructor apropiado, el
constructor
operador new construye el objeto,
asignándole recursos de RAM, y
almacena su dirección en la variable
objeto (el alias del objeto, o,
simplemente, el objeto) .

Ferreiras IMPLEMENTACIO 57
  La variable Objeto se puede considerar
como un puntero a la ubicación en la
memoria donde se encuentre el objeto:

String nombre = new String( “Felix Ferreiras”);

 “Felix Ferreiras”
nombre

Toda interacción con un objeto es al través de una variable de referencia, luego, solo si
tenemos una referencia a un objeto es que podemos usarlo.

Ferreiras IMPLEMENTACIO 58
 Accesando Después de que el objeto
ha sido construido, el operador de punto
es usado para acceder a sus métodos de
instancia:
variableObjeto.metodoDeInstancia( );

variableObjeto.metodoDeInstancia( arg1, arg2);

variableObjeto Es el nombre del objeto

Ferreiras IMPLEMENTACIO 59
 Compilación y ejecución en
JAVA
Archivo
Archivo Archivo
fuente Archivo
Editor fuente Compilador ss.class
.class JVM

nombreClase.java

Librería
Librería
ss

Ejecución
Del
Programa

Ferreiras IMPLEMENTACIO 60
 En la consola: Compila el código
fuente

\bin> javac archivo.java 

\bin> java archivo 

Corre la aplicación

Ferreiras IMPLEMENTACIO 61
 javac -help
Usage: javac <options> <source files>
Where possible options include:
-g Generate all debugging info
-g:none Generate no debugging info
-g:{lines,vars,source} Generate only some debugging info
-nowarn Generate no warnings
-verbose Output messages about what the compiler is doing
-deprecation Output source locations where deprecated APIs are used
-classpath <path> Specify where to find user class files and annotation processors
-cp <path> Specify where to find user class files and annotation processors
-sourcepath <path> Specify where to find input source files
-bootclasspath <path> Override location of bootstrap class files
-extdirs <dirs> Override location of installed extensions
-endorseddirs <dirs> Override location of endorsed standards path
-proc:{none,only} Control whether annotation processing and/or compilation is done.
-processor <class1> Names of the annotation processors to run; bypasses default
[,<class2>,<class3>...] discovery process

Ferreiras IMPLEMENTACIO 62
 -processorpath Specify where to find annotation processors
<path>
-d <directory> Specify where to place generated class files
-s <directory> Specify where to place generated source files
-implicit:{none,class} Specify whether or not to generate class files for implicitly
referenced files
-encoding Specify character encoding used by source files
<encoding>
-source <release> Provide source compatibility with specified release
-target <release> Generate class files for specific VM version
-version Version information
-help Print a synopsis of standard options
-Akey[=value] Options to pass to annotation processors
-X Print a synopsis of nonstandard options
-J<flag> Pass <flag> directly to the runtime system

Ferreiras IMPLEMENTACIO 63
From Java source to bytecode to host machine code

See

http://www.javaworld.com/javaworld/jw-03-2000/jw-0331-java101.html

Ferreiras IMPLEMENTACIO 64
See
http://www.semihkorkmaz.com/2010/11/net-or-java/

Ferreiras IMPLEMENTACIO 65
 Organización de los archivos
de una aplicación JAVA
En JAVA no existe el concepto
“Compilación por separado”; Dos tipos de
archivos son de interés saber su ubicación:
nombre.java Son los archivos del código fuente; Todos los
archivos .java que una aplicación requiera deberán
estar en el mismo directorio del que contiene main()
o declarados en un package con import ;
nombre.class Son los archivos de código byte generados por el
compilador de JAVA;

Ferreiras IMPLEMENTACIO 66
Como usted podrá notar, Ferreiras
pone todo en el directorio ...\bin.
Ese es su estilo. Usted puede
organizar sus archivos por tema.
Editar la variable de entorno PATH
le será necesario para correr el
compilador desde cualquier ruta.

Ferreiras IMPLEMENTACIO 67
/*

Clase0.java
jdk1.6.0_22 \\ jdk1.6.0_25

JAVA / Encapsulamiento

Hacer el proceso de abstracción de un objeto de los que le

rodea, definir la clase con una funcionalidad mínima y probarla
en un test-drive.-

Ferreiras
15-Mayo-2011

*/

Ferreiras IMPLEMENTACIO 68
// Uso de la clase Observe que el nombre de esta clase es
el mismo nombre del archivo fuente:
Clase0.java, Así lo prefiere Ferreiras. 
public class Clase0 {

public static void f(){

System.out.println("\n\t Hey Ferreiras, JAVA !!\n");
}

public static void main( String[ ] pArgs){

f(); // Si no es static: non-static method f() cannot be

// referenced from a static context

Grapadora g1 = new Grapadora();

System.out.println("\n\t* Grapadora por defecto:\n\n");
g1.verDatos();
g1.ponerDatos( "STANDLEY", 10, 6, 3456.34, 123.45);
System.out.println("\n\t* Grapadora con datos:\n\n");
g1.verDatos();
}
}

Ferreiras IMPLEMENTACIO 69
public void verDatos(){

System.out.println("\n\t* GRAPADORA: " + marca +

"\n\t* LONGITUD: " + longitud + " plg" +
"\n\t* NUMERO DE GRAPA QUE USA: " + grapaNo +
"\n\t* PRECIO DE LA GRAPADORA, RD$: " + precioGrapadora +
"\n\t* PRECIO DE LAS GRAPAS, RD$: " + precioGrapas +
"\n\n" );

} // Fin definicion de la clase

Ferreiras IMPLEMENTACIO 70
C:\Archivos de programa\Java\jdk1.6.0_25\bin> java Clase0

Hey Ferreiras, JAVA !! Son los valores por

defecto para los
* Grapadora por defecto: tipos usados.
* GRAPADORA: null
* LONGITUD: 0 plg
* NUMERO DE GRAPA QUE USA: 0 <= Valores por defecto para los
* PRECIO DE LA GRAPADORA, RD$: 0.0 tipos usados.
* PRECIO DE LAS GRAPAS, RD$: 0.0

* Grapadora con datos:

* GRAPADORA: STANDLEY
* LONGITUD: 10 plg
* NUMERO DE GRAPA QUE USA: 6
* PRECIO DE LA GRAPADORA, RD$: 3456.34
* PRECIO DE LAS GRAPAS, RD$: 123.45

C:\Archivos de programa\Java\jdk1.6.0_25\bin>

# 1 NOTA:
Es obligatorio usar String[] pArgs; Si no es usado
C:\Archivos de programa\Java\jdk1.6.0_25\bin>java Clase0
Exception in thread "main" java.lang.NoSuchMethodError: main

Ferreiras IMPLEMENTACIO 71
 Clase0b.java
jdk1.6.0_22 \\ jdk1.6.0_25

JAVA / Encapsulamiento / Constructor por defecto

/ Suplido por el desarrollador

Hacer el proceso de abstracción de un objeto de los que le

rodea, definir la clase con una funcionalidad mínima y
probarla en un test-drive.-

Ferreiras IMPLEMENTACIO 72
 class Grapadora{ // Definicion de la clase

// Encapsulamiento

String marca; // Marca de la grapadora

private int longitud ; // size de la grapadora
private int grapaNo; // Numero de grapa
private double precioGrapadora; // Precio de la grapadora
private double precioGrapas; // precio de las grapas por caja

// Interfase

// Constructor por defecto suplido por el desarrolador

public Grapadora() {

marca = "Ferrom57";
longitud = 15;
grapaNo = 10;
precioGrapadora = 5678.34;
precioGrapas = 156.33;

Ferreiras IMPLEMENTACIO 73
public void ponerDatos(String ma, int lo, int nu, double p1, double p2){
marca = ma;
longitud = lo;
grapaNo = nu;
precioGrapadora = p1;
precioGrapas = p2;

//...

public void verDatos(){

System.out.println("\n\t* GRAPADORA: " + marca +

"\n\t* LONGITUD: " + longitud + " plg" +
"\n\t* NUMERO DE GRAPA QUE USA: " + grapaNo +
"\n\t* PRECIO DE LA GRAPADORA, RD$: " + precioGrapadora +
"\n\t* PRECIO DE LAS GRAPAS, RD$: " + precioGrapas +
"\n\n" );

} // Fin definicion de la clase

Ferreiras IMPLEMENTACIO 74
 // Uso de la clase

public class Clase0b {

public static void main( String[] pArgs){

Grapadora g1 = new Grapadora(); // Se invoca igual el constructor

System.out.println("\n\t* Grapadora por defecto:\n\n");
g1.verDatos();
g1.ponerDatos( "STANDLEY", 10, 6, 3456.34, 123.45);
System.out.println("\n\t* Grapadora con datos:\n\n");
g1.verDatos();

Ferreiras IMPLEMENTACIO 75
C:\Archivos de programa\Java\jdk1.6.0_25\bin> java Clase0b

* Grapadora por defecto:

* GRAPADORA: Ferrom57
* LONGITUD: 15 plg
* NUMERO DE GRAPA QUE USA: 10 <== Velores por defecto
* PRECIO DE LA GRAPADORA, RD$: 5678.34 suplidos por el
* PRECIO DE LAS GRAPAS, RD$: 156.33 desarrollador

* Grapadora con datos:

* GRAPADORA: STANDLEY
* LONGITUD: 10 plg
* NUMERO DE GRAPA QUE USA: 6
* PRECIO DE LA GRAPADORA, RD$: 3456.34
* PRECIO DE LAS GRAPAS, RD$: 123.45

Ferreiras IMPLEMENTACIO 76
Clase0c.java
jdk1.6.0_22 \\ jdk1.6.0_25

Ferreiras / JAVA / Encapsulamiento / Constructores por

defecto

Considerar la abstracción de los empleados que tienen

personas dependientes. Escribir la clase y probarla. Todo
en un mismo archivo .java

Ferreiras
18-Mayo-2011.-

Ferreiras IMPLEMENTACIO 77
 import java.util.Vector;

class Persona{

private String nombreCompleto;

private int edad;

public void setPersona( String no, int e ) {

nombreCompleto = no;
edad = e;
}

public String getNombre() { return nombreCompleto; }

public int getEdad() { return edad; }

Ferreiras IMPLEMENTACIO 78
class Empleado {

private long codigo;

private String nombreEmpleado;
private Vector<Persona> dependiente;

public void setEmpleado( long co, String n, Vector<Persona> d ) {

codigo = co;
nombreEmpleado = n;
dependiente = d;
}

Ferreiras IMPLEMENTACIO 79
public void verEmpleado() {

System.out.println( "\n\t=> DATOS DEL EMPLEADO:\n" +

"\n\t * CODIGO: " + codigo +
"\n\t * NOMBRE: " + nombreEmpleado + "\n");
int k;
System.out.println("\n\t => Dependientes\n");
for( k = 0; k < dependiente.size(); k++){
System.out.println("\n* NOMBRE: " + dependiente.get(k).getNombre() +
"\n* EDAD: " + dependiente.get(k).getEdad() );
}

Ferreiras IMPLEMENTACIO 80
 public class Clase0c {
public static void main( String[] pArgs) {
Persona p1 = new Persona();
p1.setPersona("Maria Sanchez", 34);
Persona p2 = new Persona();
p2.setPersona("Ricardito Sanchez", 14);
Persona p3 = new Persona();
p3.setPersona("Mariita Sanchez", 4);
Vector<Persona> pd = new Vector<Persona>();
pd.add(p1);
pd.add(p2);
pd.add(p3);
Empleado e1 = new Empleado();
e1.setEmpleado( 123456, "Ricardo Sanchez Padre", pd);
e1.verEmpleado();
}

Ferreiras IMPLEMENTACIO 81
C:\Archivos de programa\Java\jdk1.6.0_25\bin> javac Clase0c.java

C:\Archivos de programa\Java\jdk1.6.0_25\bin> java Clase0c

=> DATOS DEL EMPLEADO:

* CODIGO: 123456
* NOMBRE: Ricardo Sanchez Padre

=> Dependientes

* NOMBRE: Maria Sanchez

* EDAD: 34

* NOMBRE: Ricardito Sanchez

* EDAD: 14

* NOMBRE: Mariita Sanchez

* EDAD: 4

C:\Archivos de programa\Java\jdk1.6.0_25\bin>

Ferreiras IMPLEMENTACIO 82
 Clase1.java
jdk1.6.0_22 \\ jdk1.6.0_25

Ferreiras / JAVA / Referencia

Cuando se pasa un objeto como argumento, se

pasa una referencia al objeto

Ferreiras IMPLEMENTACIO 83
class Clase{
private int x;
public Clase(){ x = 0; }
public Clase( int z ){ x = z; }
public int getX(){ return x; }
public void setX(int w){ x = w; }
public void f(Clase obj, int y){
System.out.println("\n=> La referencia del objeto es: " + obj + "\n");
obj.setX(y);
}
}

Ferreiras IMPLEMENTACIO 84
public class Clase1 {

public static void main( String[] pArgs){

Clase c1 = new Clase(23);

System.out.println("\n=> La referencia del objeto es: " + c1 + "\n");
System.out.println("\n=> El estado es " + c1.getX() + "\n");

Clase obj2 = new Clase();// Para poder llamar f con el objeto c1

obj2.f(c1, 123); // f alterara el estado del objeto c1
System.out.println("\n=> La referencia del objeto es: " + c1 + "\n");
System.out.println("\n=> El estado es " + c1.getX() + "\n");
}
}

Observe que después de llamar a f

podemos acceder al nuevo estado
del objeto pasado como argumento

Ferreiras IMPLEMENTACIO 85
C:\Archivos de programa\Java\jdk1.6.0_25\bin> java Clase1

=> La referencia del objeto es: Clase@19821f

Observe que la
=> El estado es 23 referencia del objeto
se mantiene antes y
=> La referencia del objeto es: Clase@19821f después de f, esto
es, la dirección es
=> La referencia del objeto es: Clase@19821f 19821f

=> El estado es 123

C:\Archivos de programa\Java\jdk1.6.0_25\bin>

Ferreiras IMPLEMENTACIO 86
 Clase3.java
jdk1.6.0_25

Ferreiras / POO / JAVA / Encapsulamiento

Considere la abstraccion de objetos triangulos rectangulos

y escribir una clase llamada TriaRect con un minimo
de funcionalidades.

(-_\~) NOTA: Ver la definicion de la clase TriaRect en el archivo

TriaRect.java, en este mismo directorio.

Ferreiras
13-Mayo-2011
Santo Domingo, R.D.-

Ferreiras IMPLEMENTACIO 87
 //import static java.lang.Math.*; // => No requerido
// import java.util.Scanner; // => No requerido

public class Clase3 {

public static void main(String args[]){

TriaRect t1 = new TriaRect();

t1.AsignarDatos();
t1.VerDatos();
System.out.println("\nEl perimetro del Triangulo actual es: " +
t1.CalculaPeri() +
"\nEl Area es: " + t1.CalculaArea(2, 3) + "\n" );
t1.VerDatos();
}

Ferreiras IMPLEMENTACIO 88
 C:\Program Files\Java\jdk1.6.0_22\bin> java Clase3

* Entre la base: 10

* Entre la altura: 5

* Estado objeto triangulo:

altura = 5.0
base = 10.0
hipo = 11.180339887498949

El perimetro del Triangulo actual es: 26.18033988749895

El Area es: 3.0

* Estado objeto triangulo:

altura = 3.0
base = 2.0
hipo = 3.605551275463989

C:\Program Files\Java\jdk1.6.0_22\bin>

Ferreiras IMPLEMENTACIO 89
 TriaRect.java
jdk1.6.0_25

Ferreiras / POO / JAVA / Encapsulamiento

Considere la abstracción de objetos triángulos rectángulos

y escribir una clase llamada TriaRect con un mínimo
de funcionalidades.

Ferreiras
13-Mayo-2011
Santo Domingo, R.D.-

Ferreiras IMPLEMENTACIO 90
 import static java.lang.Math.*;
import java.util.Scanner;

// DEFINICION DE LA CLASE
Nótese, solo
hay una clase public class TriaRect{
con el
private double base;
modificador de private double altura;
acceso public y private double hipo;
su nombre es
justamente el public void AsignarDatos(){
nombre del
archivo .java en Scanner lee = new Scanner(System.in);
el que reside System.out.print("\n* Entre la base: ");
base = lee.nextDouble();

System.out.print("\n* Entre la altura: ");

altura = lee.nextDouble();
hipo = sqrt( pow(base, 2) + pow(altura, 2));
}

Ferreiras IMPLEMENTACIO 91
 public void VerDatos(){
System.out.println("\n* Estado objeto triangulo:\n" +
"\n\taltura = " + altura +
"\n\t base = " + base +
"\n\t hipo = " + hipo + "\n");
}
//...
public double CalculaArea(double x, double y){
base = x;
altura = y;
hipo = sqrt( pow(base, 2) + pow(altura, 2));
return (base * altura / 2.0);
}

public double CalculaPeri(){

return (base + altura + hipo);

}
} // Fin definición de la clase

Ferreiras IMPLEMENTACIO 92
VetorMisDobles.java
jdk1.6.0_22 | 25 ;-)

Ferreiras / JAVA / Encapsulamiento

Vector unicamente puede almacenar objetos. Los tipos primitivos ( int, double,
char, ...) no. Para resolver este problema y poder manipuar tipos double en un
Vector el trabajo es tremendo !!. Ver el codigo mas abajo.

Hacer la abstraccion de double en una clase suya con un minimo de

funcionalidades. Probar la clase.

Ferreiras
18 de Mayo 2011.-

Ferreiras IMPLEMENTACIO 93
 import java.util.Vector;

class MisDobles{ // mi wrapping class, ;-)

private double x;
public MisDobles( double d){ x = d; }
public void setDoble( double d ){ x = d; }
public double getDoble(){ return x; }

Ferreiras IMPLEMENTACIO 94
public class VectorMisDobles {

public static void main(String[] args) {

//Crear un Vector de objetos MisDobles

Vector<MisDobles> v = new Vector<MisDobles>();

v.add(new MisDobles(1.23));
v.add(new MisDobles(2.34));
v.add(new MisDobles(3.45));
v.add(new MisDobles(4.56));

double suma = v.get(0).getDoble() + v.get(1).getDoble();

System.out.println("\n\n\t => Suma = " + suma);
}
}

Ferreiras IMPLEMENTACIO 95
C:\Archivos de programa\Java\jdk1.6.0_25\bin> java VectorMisDobles

=> Suma = 3.57

C:\Archivos de programa\Java\jdk1.6.0_25\bin>

Ferreiras IMPLEMENTACIO 96
VetorDoubles.java
jdk1.6.0_22 | 25 ;-)

Vector unicamente puede almacenar objetos. Los tipos primitivos

( int, double, char, ...) no. Usaremos la clase numerica Double,
que es un wrapper del tipo primitivo double. Algunos de sus
metodos son:

new Double(value) Instantiate from double value

doubleValue() Return double value

Para los otros tipos primitivos a clases wrapper similares.

Ferreiras
18 de Mayo 2011.-

Ferreiras IMPLEMENTACIO 97
 import java.util.Vector;

public class VectorDoubles {

public static void main(String[] args) {

//Crear un Vector de objetos Double

Vector <Double>v = new Vector<Double>();

// Creamos los objetos Double y lo inyectamos al Vector

v.add(new Double(1.23));
v.add(new Double(2.34));
v.add(new Double(3.45));
v.add(new Double(4.56));

// Acceder con doubleValue() al valor primitivo en el objeto

// Double

double suma = v.get(0).doubleValue() + v.get(1).doubleValue();

System.out.println("\n\n\t => Suma = " + suma);
}
}

Ferreiras IMPLEMENTACIO 98
C:\Archivos de programa\Java\jdk1.6.0_25\bin> java VectorDoubles

=> Suma = 3.57

Ferreiras IMPLEMENTACIO 99
/*
ClaseVerLimitesTipoPrimitivo.java
jdk1.6.0_25 Observe que laaargo es
el nombre de la clase
Ferreiras / JAVA / Limites de los tipos primitivos

*/

public class ClaseVerLimitesTipoPrimitivo {

public static void main(String args[]) {

System.out.println("\n\n\t=> Valores minimo y maximo de los tipos primitivos\n" +

"\n\t: tipo(min, max)\n" +
"\n\t\t byte ( " + Byte.MIN_VALUE + ", " + Byte.MAX_VALUE + " )\n" +
"\n\t\t short ( " + Short.MIN_VALUE + ", " + Short.MAX_VALUE + " )\n" +
"\n\t\t int ( " + Integer.MIN_VALUE + ", " + Integer.MAX_VALUE + " )\n" +
"\n\t\t float ( " + Float.MIN_VALUE + ", " + Float.MAX_VALUE + " )\n" +

"\n\t\t double( " + Double.MIN_VALUE + ", " + Double.MAX_VALUE + " )\n");

}
}

/*

Ferreiras IMPLEMENTACIO 100

C:\Archivos de programa\Java\jdk1.6.0_25\bin>java ClaseVerLimitesTipoPrimitivo

=> Valores minimo y maximo de los tipos primitivos

: tipo(min, max)

byte ( -128, 127 )

short ( -32768, 32767 )

int ( -2147483648, 2147483647 )

float ( 1.4E-45, 3.4028235E38 )

double( 4.9E-324, 1.7976931348623157E308 )

C:\Archivos de programa\Java\jdk1.6.0_25\bin>

Ferreiras IMPLEMENTACIO 101

Componentes gráficos, GUIs
Las aplicaciones Java son
programas independientes que no se
ejecutan a través de la Web. Las
aplicaciones de línea de comandos
interactúan con el usuario sólo a
través de mensajes de texto simple.

Ferreiras IMPLEMENTACIO 102

 Una aplicación Java puede tener
componentes gráficos también. Es lo que
veremos al final de cada PPT, como
una forma de ir introduciendo el
concepto, paso a paso. El estudiante
tiene la obligación de ir consultando
las API presentadas en cada caso, muy
lentamente.

Ferreiras IMPLEMENTACIO 103

 Este es un enfoque practico,
ctico
pragmático,
pragmático para construir el
conocimiento deseado. Requiere de un
esfuerzo adicional del estudiante. Por
suerte, los nombres de las clases y los
métodos son bien descriptivos y
asociativos con la operación que realizan.

How do it ? Look

Ferreiras IMPLEMENTACIO 104

 How to Blog: Blogging !!

Ferreiras IMPLEMENTACIO 105

Learning doing , That is the question !!!

Go ahead
and good
luck!!

Ferreiras IMPLEMENTACIO 106

/*
Gui0.java
jdk1.6.0_22

Ferreiras/ JAVA / Componentes Graficos, Aplicaciones

con GUI

Uso de las clases JFrame, JPanel, JLabel

*/

Ferreiras IMPLEMENTACIO 107

import java.awt.*;
import javax.swing.*;

public class Gui0 {

public static void main(String[] args){

// Construimos el marco

JFrame marco = new JFrame("Aplicacion GUI");

marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// Construimos el panel para el marco

JPanel panel1 = new JPanel();

panel1.setBackground(Color.magenta);
panel1.setPreferredSize( new Dimension(300, 100));

Ferreiras IMPLEMENTACIO 108

// Construimos las etiquetas para el panel

JLabel etiqueta1 = new JLabel("Esta es una aplicacion GUI");

JLabel etiqueta2 = new JLabel("que no le permite al usuario");
JLabel etiqueta3 = new JLabel("interactuar con ella !! Zoquete");

// Agregamos las etiquetas al panel, en ese orden

panel1.add(etiqueta1);
panel1.add(etiqueta2);
panel1.add(etiqueta3);

Ferreiras IMPLEMENTACIO 109

// Agregamos el contenido del panel al marco

marco.getContentPane().add(panel1); // Obtiene el contenido del

// panel y lo agrega al marco
marco.pack(); // Establece el size del marco apropiado al del marco
marco.setVisible(true); // para que el marco sea visible en la
//pantalla
}

Ferreiras IMPLEMENTACIO 110

C:\Program Files\Java\jdk1.6.0_22\bin>javac Gui0.java

C:\Program Files\Java\jdk1.6.0_22\bin> java Gui0

Ferreiras IMPLEMENTACIO 111

/*
GraphicUI0.java
jdk1.6.0_22

Ferreiras / JAVA / Seguimiento Grafico / GUI / Entrada-Salida

Entrada-Salida con GUI usando javax.swing.JOptionPane

Ver en

http://download.oracle.com/javase/1.4.2/docs/api/javax/swing/JOptionPane.html

*/

Ferreiras IMPLEMENTACIO 112

import javax.swing.JOptionPane;

class Configuracion {

public Configuracion() { // Constructor

hacerConfiguracion();
}

public void hacerConfiguracion() {

// Salidas, se muestran una a una

JOptionPane.showMessageDialog ( null, " ! Bienvenido a JAVA con Ferreiras " );

JOptionPane.showMessageDialog ( null, " ! Bienvenido a JAVA con Ferreiras " ,

"Prograda de ejemplo de GUI",
JOptionPane.INFORMATION_MESSAGE );

Ferreiras IMPLEMENTACIO 113

 JOptionPane.showMessageDialog ( null, " ! Bienvenido a JAVA con Ferreiras " ,
"Prograda de ejemplo de GUI",
JOptionPane.ERROR_MESSAGE );

JOptionPane.showMessageDialog ( null, " ! Bienvenido a JAVA con Ferreiras " ,

"Prograda de ejemplo de GUI",
JOptionPane.WARNING_MESSAGE );

Ferreiras IMPLEMENTACIO 114

// entradas, se muestran una a una

String entrada1;

entrada1 = JOptionPane.showInputDialog ( "Introduzca un valor entero" );

String entrada2;

entrada2 = JOptionPane.showInputDialog ( null, " Introduzca un valor real",

"Mi programa en JAVA",
JOptionPane.QUESTION_MESSAGE );

String entrada3 = JOptionPane.showInputDialog( null, "Introduzca un valor cadena",

"Otro programa en JAVA",
JOptionPane.INFORMATION_MESSAGE );

Ferreiras IMPLEMENTACIO 115

 // Conversion de String a valones numericos

int valor1 = Integer.parseInt(entrada1);

double valor2 = Double.parseDouble(entrada2) ;

// Algunas operaciones aritmeticas

valor1 = valor1 * 10;

valor2 = valor2 + 1000;

Ferreiras IMPLEMENTACIO 116

 // Mostrar resultados

JOptionPane.showMessageDialog( null, "Resultado Numero 1 = " +

valor1 + " USD" );

JOptionPane.showMessageDialog( null, "Resultado Numero 2 = " +

valor2 + " DOP" );

JOptionPane.showMessageDialog( null, "Preparado por: " + entrada3 );

System.exit(0); // recomendable despues de usar JOptionPane

} // fin del metodo hacerConfiguracion
} // fin de la clase Configuracion

Ferreiras IMPLEMENTACIO 117

 // Probamos la clase

public class GraphicUI0 {

public static void main( String [ ] args ) {

Configuracion c = new Configuracion();

}
}

Ferreiras IMPLEMENTACIO 118

C:\Program Files\Java\jdk1.6.0_22\bin> java GraphicUI0

Ferreiras IMPLEMENTACIO 119

Ferreiras IMPLEMENTACIO 120
Ferreiras IMPLEMENTACIO 121
 EJEMPLOS

Ferreiras IMPLEMENTACIO 122

 EJERCICIOS

Ferreiras IMPLEMENTACIO 123

 GRACIAS.

Ferreiras IMPLEMENTACIO 124