5.1 estructura de una clase.

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Persona{
private String nombre;
private String apellido;
private int edad;
public Persona(String n, String a, int e){
nombre
= n;
apellido = a;
edad
= e;
}
public void saludar(){
System.out.println("Hola, mi nombre es " + nombre);
}
public int getEdad(){
return edad;
}
}

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/estructurabasica-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-comoescribir-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

5.1 estructura de una clase.

Más contenido relacionado

La actualidad más candente (20)

Similar a 5.1 estructura de una clase. (20)

Más de K Manuel TN (20)

5.1 estructura de una clase.