Estructura básica de una clase (POO)

ESTRUCTURA BASICA DE UNA CLASE (POO)

Ahora veremos cómo se estructura un programa dentro de la POO del cual viene con clases

que definen a los objetos mediante atributos las cuales nos dicen quiénes son estos objetos así

como una persona se identifica y se hace única con un nombre, apellidos, nacionalidad, etc. Lo

mismo sucede con los objetos pero no sólo es la persona como tal sino el hecho de hablar,

caminar, etc. dentro de la POO a esto se le conoce como métodos. Que definen lo que el

objeto va hacer o ejerce, es decir cómo los manipula completamente.

Muchas de las clases están ya escritas y compiladas en la biblioteca de JAVA Y otras debemos

escribirlas nosotros dependiendo del problema que tengamos que resolver. Una de las clases

de la aplicación siempre debe llevar el método main el cual cumple el objetivo del objeto que

es iniciar y finalizar la ejecución del a aplicación; volviendo al ejemplo de la persona pero ya

viéndolo desde el la perspectiva del cuerpo humano es como nuestro cerebro sin él no

podemos decirle a cada parte del cuerpo que debe realizar parece una analogía algo rara pero

ese método es la puerta tanto de salida como entrada.

Ya que estamos adentrándonos a la estructura de las POO, hay que recalcar que el hecho de

llamarse lenguaje también cuanta con una sintaxis la cual mediante de indicadores clave nos

va dando la referencia y lugar que ocupa cada uno de ellos. Empezaremos con las palabras

clave que nos aparecerán en remarcadas a lo que se denominan “bold” y el texto aparece en

cursiva. Otros elementos en la sintaxis son los corchetes que indican que la información

encerrada entre ellos es opcional y los puntos suspensivos que pueden aparecer más elementos

de la misma forma.

Las famosas llaves nos harán referencia a que dentro de ellas va lo que el objeto realizará y los

paréntesis indican que se refiere a un método y dentro de ellos van los parámetros. En java

existen caracteres que son utilizados para formar constantes, los identificadores y las palabras

clave. Dentro de la POO se reconocen a las letras tanto minúsculas como mayúsculas de los

alfabetos internacionales ejemplo de la A-Z, a-z, también dígitos de los mismo alfabetos que

van del 0 -9, algunos caracteres como “_”, “$” y cualquier carácter Unicode por encima de

00C0, con estos podemos decir que se hace una gran diferencia entre palabras minúsculas y

mayúsculas, por ejemplo “no es lo mismo Año que año”.

Hay los denominados espacios en blanco que son: los caracteres espacio en blanco, tabulador

horizontal, avance de página, nueva línea, retorno de carro –éstos dos últimos conocidos como

retorno de carro \n-. Todos estos actúan como separadores entre los elementos del programa,

lo cual hace a los programas más legibles. Como mencionamos anteriormente hay caracteres

que son especiales y que se utilizan para indicar que un identificador es una función y o un

arrray; para determinar una operación aritmética, lógica o de relación, los caracteres especiales

son los siguientes: “. , ; : ? „ “() [] {} ¡ \ | / ~ + & + -“

Ahora bien en las estructuras de las clases para poder realizar operaciones o acciones dentro

de ellas necesitamos utilizar a lo que identifique los datos que van a jugar el roll anteriormente

mencionado, es decir, vamos a declarar las variables. Los datos se clasifican en dos: tipos

primitivos y tipos referenciados.

Los primitivos son ocho y están clasificados como numéricos y booleanos; a su vez los

booleanos se clasifican en enteros y reales.

Los numéricos:

Enteros: byte, short, int, Long y char.

Reales: float y double.

Los booleanos son el true y false.

Cada uno de los datos primitivos tiene un rango diferente de valores positivos y negativos a

excepción de los booleanos.

El byte se utiliza para declarar datos enteros comprendidos entre -128 y +127, se define como

un conjunto de 8 bits. El short se utiliza para declarar datos enteros que van de -32768 y

+32767, se define como un dato de 16 bits. Int se utiliza para declarar datos enteros

comprendidos entre -2147483648 y +2147483647, se define como un dato de 32 bits de

longitud. El Long se utiliza para declarar datos enteros comprendidos -9223372036854775808

y +9223372036854775807 y se define como un dato de 64 bits de longitud.

El char se utiliza para declarar datos enteros que van desde del o al 127 del código ASCII.

Float se utiliza para declarar un dato de coma flotante de 32 bits en formato IEEE 754,

almacena valores con precisión de 7 dígitos. El tipo doublé utiliza 64 bits para almacenar un

dato de coma flotante, almacena datos con una precisión de 16 dígitos. Y por último el

booleano se utiliza para las expresiones de lógica falsa o verdadera.

En la estructura de la POO están los denominados identificadores que son nombres dados a

tipos de literales, variables, clases, interfaces, métodos, paquetes y sentencias de un programa.

Existen las palabras clave dentro de la POO y son identificadores predefinidos que tienen un

significado especial para el compilador es por eso que un identificador definido por el usuario

no puede tener el mismo nombre que estas palabras claves, ejemplo: break, boolean, do,

doublé, default, etc.

Por último hablaremos de la consola que es la parte donde el programa va a correr, es decir, se

ejecuta que son más que nada ambientes de tipo MSDOS y en las IDE contienen una ventana

especial para hacerlo. En ella podremos ver los resultados o el objetivo que el nuestro

programa alcanza.

Estructura de una Clase en Java

Una clase en Java nos proporcionará los atributos y métodos necesarios que un objeto necesitará para interactuar con otros, por lo que es importante saber estructurar correctamente las clases.

Con la siguiente sentencia, estamos declarando una clase:

Public class NombreDeLaClase {}

La palabra "public" indica que el alcance de la clase será público, no significa "publicar clase”. Después de 'public class' escribimos el identificador de la clase. Se recomienda elegir un identificador abstracto a la clase, para facilitar la comprensión del código.

Por ejemplo, si queremos modelar objetos de tipo "Persona", es recomendable que el identificador sea "Persona" y no "Juan", el identificador de la clase debe proporcionar una idea general y no una idea específica.

En Java se usan llaves { } para agrupar trozos de código determinados, es por eso que todo el contenido de la clase que estamos haciendo debe estar entre sus respectivas llaves.

A continuación presentamos un ejemplo muy sencillo de una clase, lo analizaremos línea a línea (Los números de la columna de la izquierda solo los ponemos en este ejemplo para identificar fácilmente las líneas de código, éstos no forman parte del código):

1 public class Persona{ 2 private String nombre; 3 private String apellido; 4 private int edad;

5 6 public Persona(String n, String a, int e){ 7 nombre = n;

8 apellido = a; 9 edad = e; 10 } 11

12 public void saludar(){ 13 System.out.println("Hola, mi nombre es " + nombre); 14 } 15 public int getEdad(){

16 return edad; 17 } 18 }

Atributos

La primera línea ya la explicamos anteriormente, así que vayamos a la segunda línea: Private String nombre; Es recomendable declarar todos los atributos al inicio de la clase, así es que esta línea declara un atributo de alcance privado (private), el atributo es de tipo String (cadena de caracteres); y el identificador del atributo es: nombre. Como ya hemos dicho, los identificadores deben cumplir con ciertas reglas, y es recomendable que los identificadores de los atributos inicien con minúscula. La tercera es prácticamente igual, simplemente cambia el identificador. Ahora analicemos la cuarta línea: Private int edad; Qué piensas que es ¿un método o un atributo? Se trata de un atributo nuevamente privado, ¿por qué privado? Uno de los principios de la programación orientada a objetos es el encapsulamiento, y este significa resguardar los atributos para que no se pueda acceder directamente a ellos, sino que debemos crear interfaces para poder acceder a estos datos. La primera diferencia de esta línea con la anterior es el tipo de atributo, en este caso leemos

la palabra int, esto significa que edad es un atributo de enteros (dígitos). Como puedes ver, la 5a línea está vacía, ¿tiene que ser así? por supuesto que no, Java es tan potente que los espacios y saltos de línea son semejantes, para Java es lo mismo que pongas un espacio a que pongas los saltos de línea que quieras, así es que si quieres hacer más estético tu código, aprovéchalo.

Constructor

Después de los atributos se recomienda colocar el constructor (o los constructores), si aún no te queda clara la función de un constructor, este nos sirve para crear las instancias de las clases (los objetos), y este puede solicitar datos para asignarlos a las variables/atributos que sean necesarias. Analicémoslo. Public Persona (String n, String a, int e) {

Como vemos, esta línea empieza con "public" que, como ya hemos dicho, no significa "publicar", sino que significa que el alcance o visibilidad que tendrá este constructor será público. ¿Por qué público? Es necesario que el constructor sea público, ya que si no fuera así, no podríamos crear objetos porque no tendríamos acceso al constructor. Después de declarar que será público colocamos el identificador, que en el caso de los constructores debe ser exactamente igual al identificador de la Clase, por eso el identificador de este constructor es: Persona. A continuación observamos que hay una serie de datos dentro de unos paréntesis (String n, String a, int e) A estos les llamaremos parámetros, y su función es solicitar datos al momento de que un objeto es creado, en este caso de la clase Persona, el constructor nos está solicitando dos cadenas (n y a) y un valor entero (e). Como vemos, al momento de escribir los parámetros debemos especificar primeramente el tipo de dato que queremos que nos den y después del tipo, un identificador temporal, que nos servirá mientras el constructor esté siendo ejecutado. Es muy importante que los parámetros vayan separados por comas. Finalmente lo último que hay en la línea es una llave que abre el bloque de código que contendrá el constructor. {

Las líneas 7, 8 y 9 realizan acciones similares. Nombre = n; apellido = a; edad = e; Se recomienda que dentro del constructor se inicialicen las variables, es decir, que se les asignen valores. Es por eso que en estas líneas le asignamos valores a los atributos que declaramos anteriormente usando los parámetros que solicitamos. Hay que recalcar, que todas las sentencias en Java deben terminar con punto y coma (;) ya que como ya hemos visto, Java no toma en cuenta los saltos de línea, así es que es necesario especificar en dónde termina una instrucción.

En la línea 10 solo observamos la llave que cierra el bloque de código correspondiente al constructor. }

Métodos

En nuestra clase, a partir de la línea 12 se encuentran 2 métodos escritos, analicemos el primero: Public void saludar () { System.out.println ("Hola, mi nombre es " + nombre) ;}

Nuevamente nos encontramos con la palabra public, que a estas alturas ya sabes qué significa; lo que aún no sabes qué significa es void.

Para escribir un método, después de declarar el alcance que tendrá, debemos especificar el tipo de dato que regresará el método al ser ejecutado, obviamente no todos los métodos deben regresar algún dato, algunos métodos simplemente realizan su función y no tienen que regresar algún valor, así que para estos métodos que no retornan nada es necesario escribir la palabra void. Con lo que hemos visto ya podemos leer la declaración de este método: "saludar" es un método público que no retorna ningún valor y no solicita ningún parámetro. Decimos que no solicita ningún parámetro ya que, como vimos en el constructor, los métodos también pueden recibir datos para ser usados en su trabajo, los parámetros siempre se encuentran entre paréntesis al lado del identificador, y si no se solicitarán parámetros, es necesario escribir los paréntesis vacíos ( ). Observamos que la única sentencia que se encuentra dentro del bloque de llaves de este método es: System.out.println ("Hola, mi nombre es " + nombre);

¿Para qué sirve System.out.println ( )? Esta sentencia nos ayudará a imprimir (mostrar) en la pantalla cadenas de texto, así que la cadena que queremos mostrar, debe ir dentro de los paréntesis y entre comillas. Así mismo, dentro de esta cadena que deseamos imprimir, podemos agregar valores de las variables simplemente colocando un + y el nombre de la variable que queremos insertar, de hecho, hasta podemos llamar a métodos que devuelvan valores que queremos imprimir, pero eso lo veremos más adelante. Suponiendo que al momento de construir un objeto de tipo Persona se le pasaron los siguientes valores: "Juan""Pérez"15 Al ejecutarse este método el programa debería mostrar en pantalla: Hola, mi nombre es Juan Ahora es tu turno, analiza el último método y trata de describir qué es lo que hace.

Ejemplos de estructura de clase

Persona

Declaración de la clase

Class persona {

prívate:

char nombre [10];

long int CI;

int edad;

public:

Voidingreso ();

Voidimprimir ();

};

// Implementación de la clase

Voidpersona:ingreso () {

cout<< “Ingreso del Nombre”<< endl;

Cin>>nombre;

}

Explicación

Creo el objeto persona a, b:

Clase vector 3D

Class vector {

Private:

Double x, y, z;

Public:

Voidingreso ();

Floatmodulo ();

Vectorsuma vector (vector a, vector b);

Floatproducto punto (vector a, vector b);

Vectorproducto cruz (vector a, vector b);

};

Clase Cuadrado

};

Triangulo

Class triangulo {

Prívate:

Doublé lado1, lado 2, lado 3;

Public:

Voidingreso ();

Voidimprimir ();

Double calcular_area ();

Doubleperímetro ();

};

Fecha

Classfecha {

Prívate:

Intdía, mes, año;

Public:

Voidingreso ();

Programación Orientada a Objetos – Cómo Escribir una Clase

Clase e Instancia.

Ahora que entendemos (más o menos) cómo funciona la teoría básica de la P.O.O. y sabemos

acerca de la importancia de las clases, es momento para que veamos cómo sería la estructura

de una clase.

Es importante tener en cuenta que cada lenguaje tiene, de acuerdo a su sintaxis, sus propias

normas sobre cómo escribir clases. No será lo mismo en PHP que en AS2 o incluso AS3. Así

que, primero, hablaremos en un sentido más general, para luego pasar a la práctica concreta.

Para los efectos, usaremos como lenguaje de ejemplo Action Script 2.0.

5.2 Elementos de una clase

Los elementos básicos de una clase se estructuran de la siguiente forma (más abajo

definiremos cada elemento):

1. Paquete al que pertenece la clase (package – sólo en AS3, en AS2 se incluye en la

Definición de la Clase).

2. Definición de la Clase (class – En AS2, si la clase está incluida en un paquete, se usa

la sintaxis paquete. Clase).

3. Variables Internas (Son de uso interno de la clase, por lo que se restringe su uso fuera

de ellas con la palabra clave private, así la variable miVar, de tipo numérico, podría

definirse así:

private var miVar:Number = 0;)

4. Constructor de la Clase (excepto en el caso de las clases estáticas, pero de eso

hablaremos en otro post).

5. Propiedades, Métodos y Eventos de la Clase (no necesariamente en ese orden, pero

es una buena forma de organizarlo).

Por supuesto, una clase bien hecha contiene además comentarios con información sobre la

clase, la forma de usarla, su autor, etc. En este caso lo omitimos para concentrarnos en lo

básico y no enredarnos más de lo estrictamente necesario.

Dicho esto, veamos los puntos nombrados arriba en una clase de ejemplo, para luego pasar a

explicar los conceptos:

Para crear una nueva instancia de la clase Persona debemos importarla y luego instanciar con

la palabra clave new, pasándole los parámetros que necesita:

Import cesarfrick.Persona;

varCesar: Persona = newPersona ("César", "Frick", 36);

Ahora expliquemos de qué se trata lo que hemos dicho:

Paquete: Aunque podemos colocar nuestras clases en el mismo directorio donde se encuentra el

archivo que los usará, siempre resulta más ordenado y eficiente clasificarlos en

carpetas, donde podemos colocar aquellas clases que tienen un mismo propósito. Así

podemos tener una carpeta llamada graph para clases de tipo gráfico, externalData

para clases que conectan y/o procesan datos externos, etc. Estas carpetas son conocidas

como paquetes.

Otra ventaja de usar paquetes (además de mantener nuestras clases ordenadas) es que

nos permiten importar todas las clases que necesitemos de ellos con sólo una línea:

import paquete.*, en vez de tener que hacer un import para cada clase. Si te

preocupa que terminen importándose más clases de las que necesitas de ese paquete,

no hay problema porque sólo se importarán las que sean necesarias y no las que no

utilices en el código.

En algunos lenguajes, existen palabras reservadas para declarar el paquete al que

pertenece una clase (como en el caso de AS3), en estos casos va primero la declaración

del paquete y luego la de la clase. En AS3 sería de esta forma:

PackagenombreDelPaquete {

class NombreDeLaClase{

...

}

}

Clase: La clase, propiamente dicha, se declara con la palabra clave class.

Hay un par de cosas que debemos tener en cuenta cuando creamos una clase:

No es obligatorio, pero por regla general -los entendidos lo llaman convención y es

cuando todos se ponen de acuerdo en hacer algo de la misma forma. los nombres de las

clases siempre comienzan con mayúsculas.

Esto si es obligatorio: El archivo donde se encuentra la clase debe tener el mismo

nombre que ésta, respetando mayúsculas y minúsculas. Esto es importante porque los

import usan el nombre del paquete (si lo hubiere) y la clase para ubicarlos en el disco,

así que si usas diferentes nombres, nunca los hallará y dará error.

Si el lenguaje no tiene una palabra reservada para definir el paquete (AS2, por

ejemplo), la definición de la clase sería así:

ClassnombreDelPaquete. NombreDeLaClase {

...

}

Variables Internas o Privadas: En último término, todas las propiedades de una clase son en realidad variables, pero

no es conveniente que el usuario de la clase pueda manipular directamente estas

variables, por ello se mantienen privadas, es decir, sólo pueden llamarse y

manipularse dentro del código de la clase, pero no fuera de ellas (o sea que si se

trata de llamar a una de estas variables desde la instancia, no funcionará). Para hacer

que una variable/función sea privada, se le antepone la palabra private.

Constructor: Es la función que se ejecuta cada vez que se crea una instancia de la clase, Si

necesitamos que nuestra clase inicie con ciertos valores, colocamos los parámetros

correspondientes entre los paréntesis. La función constructora siempre devuelve Void

(Vacío).

También puede haber casos en los que no queramos que la clase constructora ejecute

ningún código. Para ello simplemente la colocamos vacía, es decir, la declaramos pero

no ponemos código en ella. Si una clase no tiene un constructor, no puede ser

instanciada.

Propiedades, Métodos y Eventos de la clase: Decíamos antes que las propiedades son realmente variables dentro de la clase, pero

para poder controlar qué puede cambiar o no el usuario de la clase, si los valores son

correctos, etc. hacemos uso de unas funciones especiales para definir propiedades: get

y set.

get permite al usuario recuperar el valor de la propiedad, leerlo, por lo que su

salida debe ser correspondiente con la que se espera de la propiedad (por

ejemplo, no tendría sentido que la propiedad “nombre” del ejemplo devolviese

un número). Si sólo creamos una función get para una propiedad, ésta es de

sólo lectura.

set es usado para darle un valor a la propiedad, normalmente se añaden aquí los

controles para asegurarse que el valor que se asigna es del tipo deseado (y

evitar que la clase colapse por un error de tipo de datos). La función de set, al

ser para escribir en la propiedad no devuelve ningún tipo de datos, pero debe

tener un parámetro que es el valor que se pasará a la variable. Al contrario de

get, no puede haber una clase de sólo escritura (después de todo, no tiene

ningún sentido tener una propiedad a la que se le pueda asignar un valor pero

este no pueda ser recuperado).

Los métodos no son más que funciones públicas, que pueden tener o no datos y

que afectan a la instancia de alguna forma.

Los eventos, al igual que los métodos, son funciones, pero estos reaccionan

ante alguna interacción del usuario o pueden ser reescritos por éste. A ellos

dedicaremos un post especial.

5.3 Clase principal

Clase con el método main: clase principal, iniciadora o “programa principal” Esta es la clase Principal, es la encargada de ejecutar los Plugins, las clases que contienen un filtro especial para cada buscador en particular. Los Plugins extienden la clase GusPlugin que contiene las rutinas necesarias para que cualquier plugin funcione, como conectarse al buscador y devolver la búsqueda. Es una clase abstracta así que se obliga a extenderla. En el caso de que unplugin no funcione, por razones de cambio en el buscador original, entonces se puede cambiar la extensión, por la de un plugin ya hecho y dar la sensación de que la funcionalidad no se perdió. Esta clase contiene un pequeño cargador de clases así que sólo es necesario copiar los nuevos plugins a la carpeta con los demás sin tener que modificar el resto del código, y por supuesto losplugins son Threads que a medida que van terminando se interpretan y devuelven los resultados, mientras los otros siguen buscando. En este caso se limitó la carga de Plugins a 2 [0-1] por la razón de que son demasiados resultados y los usuarios, pueden terminar cancelando la búsqueda. Hasta ahora hemos visto código implementando clases y que las clases definen tipos, es decir, nos permiten crear objetos del tipo definido por la clase. Pero a todas estas, ¿dónde está el programa? Todavía no hemos visto ningún programa, y ya es hora de que abordemos este asunto. Sabemos que los métodos en Java pueden tener cualquier nombre (excluido el de palabras clave). Existe un nombre de método que está reservado en Java y otros lenguajes: el método main. Este método es un método especial en tanto en cuanto es el que da lugar al inicio del programa. Si comparamos un programa con un partido de fútbol, el método main sería el responsable de poner el partido en juego. Es importante tener claro que el método main no es el elemento principal en el desarrollo del programa. El programa, de acuerdo con el paradigma de programación orientada a objetos, se desarrolla mediante la interacción entre objetos, que en la figura hemos representado como jugadores en el campo de fútbol. Por tanto el cometido del método main normalmente es iniciar el programa (poner el balón en juego) y permanecer en un segundo plano mientras los objetos interactúan entre sí, controlando el desarrollo de la situación como si del árbitro se tratara. El método main normalmente no será muy extenso en cuanto a líneas de código respecto al resto del código (clases). Si esto ocurriera, posiblemente sería indicador de que este método tiene más protagonismo del que debe, y en nuestro símil el árbitro no debe ser protagonista del partido. En algunos ejemplos de código que desarrollemos quizás la clase con el método main contenga gran parte del código total, pero si esto es así será porque lo estamos utilizando con fines didácticos. En programas profesionales esto no debe ocurrir. El método main es indudablemente importante. Por eso y por motivos históricos en el desarrollo de la programación muchas veces se alude a él (o a la clase donde se sitúa) como clase principal o “programa” principal. Pero hay que tener bien claro que

su carácter principal se debe a que es quien inicia el desarrollo del programa, no a que sea quien debe asumir el protagonismo del mismo. Un error que cometen frecuentemente las personas que están aprendiendo Java es suponer que el método main es la parte principal del programa, en el sentido de que debe concentrar los procesos importantes y la mayor parte del código. Esta concepción errónea se reflejaría en el siguiente esquema, donde las clases y objetos están al servicio del método main (o de la clase donde se encuentre) que es quien centraliza las operaciones. Este esquema es posible, pero no es el adecuado dentro del estilo de programación orientada a objetos y no aprovecha todo el potencial de esta forma de programación.

La clase principal y el método main Un programa puede construirse empleando varias clases. En el caso más simple se utilizará una única clase. Esta clase contiene el programa, rutina o método principal: main () y en éste se incluyen las sentencias del programa principal. Estas sentencias se separan entre sí por caracteres de punto y coma. La estructura de un programa simple en Java es la siguiente: Public class ClasePrincipal { Public static void main (String [] args) { sentencia_1; sentencia_2; // ... sentencia_N; } } Como primer ejemplo sencillo de programa escrito en Java se va a utilizar uno que muestra un mensaje por la pantalla del ordenador. Por ejemplo, el programa Hola.java: /** * La clase hola construye un programa que * muestra un mensaje en pantalla */ Public class Hola { Public static void main (String [] args) { System.out.println ("Hola, "); System.out.println ("me llamo Angel"); System.out.println ("Hasta luego"); } } Como se ha indicado anteriormente, en un programa de Java todo se organiza dentro de las clases. En el ejemplo anterior, Hola es el nombre de la clase principal y del archivo que contiene el código fuente. Todos los programas o aplicaciones independientes escritas en Java tienen un método main o principal que, a su vez, contiene un conjunto de sentencias. En Java los conjuntos o bloques de sentencias se indican entre llaves { }. En el caso anterior, el conjunto de sentencias se reduce a

tres sentencias, que son llamadas a dos métodos predefinidos en Java (print y println) que permiten visualizar texto por el dispositivo de salida de datos por defecto (la pantalla). Por el momento y hasta que se explique con detalle el concepto de clase, los ejemplos de programa que se utilizarán constarán de una sola clase en la que se declara el método main. Este método es el punto de arranque de la ejecución de todo programa en Java.

Conclusión

Cada elemento definido como objeto en las POO ahora podemos ver como en su

programación se define sus características en su estructura y a cómo entender el desarrollo

en otras programaciones.

Bibliografía

Estructura de una Clase en

Java:http://aprendepooconjava.blogspot.mx/2012/09/estructura-de-una-clase-en-java.html

ESTRUCTURA DE UNA CLASE:http://poogg.jimdo.com/estructura-de-un-clase/

Estructura básica de una clase (POO):http://deganteioannis.wordpress.com/estructura-

basica-de-una-clase-poo/

Ceballos, F. J. (2011). Java 2 – Curso de Programación, Cd. México: Alfaomega,

Ra-Ma.

Deitel, P., Deitel, H. (9na ed.). (2012). Como programar en Java. Cd. México:

McGraw-Hill

Programación Orientada a Objetos – Cómo Escribir una

Clase:http://thefricky.wordpress.com/2008/02/18/programacion-orientada-a-objetos-como-

escribir-una-clase/

Clase principal.

Clase con el método main: clase principal, iniciadora o “programa principal”:

http://portafoliofundamentos.blogspot.mx/2012/12/53-clase-principal.html