 |
 |
 |
 |
|
|
|||||
Lenguaje Java |
en la WEB |
||||
|---|---|---|---|---|---|
Hora es ? |
y Hora |
||||
Cuadros Paquetes |
|||||
El formato del objeto, usando lenjuaje Java, queda definido por su clase generadora,
cuya estructura sintáctica es:
Recuerda que para procesar los programas de estos links, requieres tener instalado en tu máquina la versión oficial de Java 2 de Sun en su plataforma JDK..!!
PARADIGMA
En los ojos del joven arde la llama
en los del viejo brilla la luz..!!
Víctor Hugo
Como en cualquier lenguaje orientado a objetos, tanto la sintaxis como la semántica usada por Java, también
gira al rededor de los siguiéntes conceptos y parámetros:
- C L A S E S
La clase define el formato del objeto, que es la unidad fundamental en java y sus datos se denominan atributos. Se la identifica con la palabra reservada class, seguida del nombre de la clase. Luego, entre llaves, se va definiendo su estructura. Ejemplo una clase que carece de declaraciones y al ejecutarse solo mostrará la cadena: "Qué nervios..!!, Esta es mi primera vez..!!"
class MiDebut
{
public static void main ( String[] arguments )
{
System.out.println("Qué nervios..!!, Esta es mi primera vez..!!");
}
}
Las declaraciones de variables, funciones o rutinas, se escriben dentro el entorno de una clase, porque los datos y rutinas, no existen en Java, si no es dentro de una clase que contiene variables globales o funciones.
Otro ejemplo de una clase que define dos atributos enteros x e y, declarados con el modificador public, por tanto accesibles y conocidos por cualquier otro objeto, es:
class Coordenada{
public long x;
public long y;
}
Ejemplo de una clase con atributos que no son tipos primitivos, sino referencias a otros objetos, donde la clase tiene tres atributos: dos son tipos primitivos (enteros), pero el atributos origen está definido como va a referenciar a un objeto, una instancia de la clase Punto , que al comienzo este atributo no contendrá ningún objeto.
class Rectangulo {
Punto origen;
int ancho;
int alto;
}
PARADIGMA
Es más grande quién se levanta que quién no cayó..!!!
Wilucha
Es la instancia o materialización de una clase, cuya declaración referencia ineludiblemente a una clase. Por ejemplo para crear una variable que referencia, o apunta a un objeto de la clase Coordenada; aunque el objeto todavía no está creado; solamente declaramos una variable, un atributo, que llegado el momento, referenciará un objeto de la clase Coordenada; usamos:
Coordenada origen;
En el momento de la creación, el atributo origen no apunta a ningún objeto, y tiene como valor reservado null, es decir, no apunta a nada.
A partir del objeto Coordenada en la variable p, podemos acceder a sus atributos con expresiones de formato:
< Objeto >.< Atributo >;
Ejemplo:
int coordenada = p.x;
Al crear un objeto las variables miembros son inicializados a 0 ó a null, según el tipo, por ello para iniciarlas a algún valor, podemos escribir:
class Persona {
int edad = 21;
int peso = 60;
}
Son las instrucciones que definen las tareas que deben desarrollar cada objeto, tienen formato de rutinas y funciones asociadas a la clase y que operan sobre sus datos. Ejemplo:
class Rectángulo {
int tomarArea () {
void ponerAncho (int nuevoAncho) {
void ponerAlto (int nuevoAlto) {
void mover (Punto nuevoOrigen) {
Punto origen;
int ancho;
int alto;
return ancho*alto;
}
ancho = nuevoAncho;
}
alto = nuevoAlto;
}
origen = nuevoOrigen;
}
}
Hemos agregado algunos métodos.
El primero, TomarArea, es una función que nos devuelve el área del rectángulo.
Al declararlo:
int tomarArea () {
Le pusimos un tipo (int, devuelve entero) de resultado. Luego viene el
nombre (tomarArea), y los parámetros que recibe, entre paréntesis
(en este caso ninguno). Al abrir la llave, comienza el bloque de sentencia que compone el método.
Este método devuelve algo, usando el verbo return, seguido de una expresión resultado:
return ancho*alto;
El tipo de la expresión se convierte al tipo declarado como el resultado a devolver
(en este caso, int).
El próximo método ya no es una función, pues no devuelve nada. Al declararlo:
void ponerAncho (int nuevoAncho) {
Estamos poniendo que su tipo es void (sin valor de retorno).
Este método espera un argumento, de tipo entero. Vemos que ese parámetro será el nuevo valor
de la variable miembro ancho.
Supongamos que ya tenemos creado y funcionando, un objeto de la clase
Rectángulo, y lo llamamos r.
Podemos operar sobre él de esta forma:
r.ponerAncho (10);
int area = r.tomarArea ();
r.ponerAlto (5);
Observemos que para invocar a un método de un objeto, escribimos la forma:
< Objeto >. < Método > ( { < parámetros > } )
Las llaves { } indican que los parámetros son opcionales. Es decir, primero nombramos al objeto, y luego de un punto, ponemos el método que invocamos, siempre seguido de paréntesis, que pueden contener los argumentos que necesita. Un error muy frecuente es poner:
r.tomarArea;
Pero es incorrecto, y el compilador lo rechazará: faltan los paréntesis. Sí está permitido:
int ancho = r.ancho;
Así es como se accede a una variable miembro inmediatamente.
En el último método definido:
void mover (Punto nuevoOrigen) {
definimos que recibe un parámetro, que resulta ser un objeto (en rigor de verdad, es una referencia a un objeto). Ese argumento es de la clase Punto, y termina siendo asignado a la variable miembro origen :
origen = nuevoOrigen;
Esta asignación no copia el contenido de un objeto a otro, sino que hace que dos variables, dos referencias, apunten al mismo objeto.
Si, por ejemplo, tenemos dos rectángulo r1 y r2, cada uno ya creado e inicializado, cuando hacemos:
r1.origen = r2.origen;
de ahora en más, ambos rectángulos tienen el mismo objeto Punto como punto de origen del rectángulo. Si ejecutamos:
r1.origen .x = 0;
cambiando la coordenada x del origen de r1, cambiamos también el valor del origen de r2.
Vistas estas cuestiones podríamos definir mejor el método del problema como:
Void mover (Punto nuevoOrigen) {
origen.x = nuevoOrigen.x;
origen.y = nuevoOrigen.y;
}
siempre y cuando podamos acceder a las variables miembros de la clase Punto.
Al escribir:
return x*y;
Para calcular el área, no tuvimos necesidad de indicar a qué objeto pertenecían x e y. Cuando no se pone el objeto antes de atributo, se asume que la variable es un miembro del objeto, o es una variable local o parámetro. Si los nombres colisionan, como podría ser en el siguiente método de Punto:
Void mover (int x, int y) {
this.x = x;
this.y = y;
}
Usamos this para indicar al objeto actual. Esta palabra reservada siempre está apuntando al objeto actual, y puede usarse como arriba, para resolver una ambigüedad, o puede usarse, por ejemplo, como parámetro de un método de otro objeto:
objeto.procesar(this);
Cuando declaramos variables miembro, estas variables están "dentro" del objeto y viven con él. En un método, aparte de las variables propias del objeto y los parámetros que recibe, podemos declarar, en cualquier momento, variables locales:
double binomio (double a, double b)
aa = a * a;
double ab;
ab = a * b;
double bb;
bb = b * b;
return (aa+ab+bb) ;
{
double aa;
{
Las variables que declaramos se pueden iniciar con algún valor en el mismo momento de declararlas:
double ab = a*b;
Examinemos el siguientes código:
class Punto {
void mover (Punto nuevo) {
void mover(int x, int y) {
int x;
int y;
x = nuevo .x;
y = nuevo .y;
}
this .x = x;
this .y = y;
}
Al parecer, definimos un método dos veces. ¿Será un error? No, en Java (como en C++) podemos definir dos métodos con el mismo nombre, siempre que tengan diferentes tipos de argumentos.
En el primer método mover, pasamos como objeto todo un
Punto, mientras que en el segundo método, pasamos dos coordenadas enteras.
El compilador sabe a cuál de los dos métodos invocar, según el tipo de argumentos con que se lo invoque.
Cuando creamos un objeto, por ejemplo, de la clase Punto, sus variables miembros toman los valores de sus inicializadotes (o 0 o null, si no pusimos ningún valor inicial en su declaración).
Hay otra manera de poner valores iniciales, y es con métodos llamados constructores. Un método constructor no tiene tipo, y lleva el mismo nombre que la clase:
class Punto {
Punto (int x, int y) {
Punto (Punto p) {
int x;
int y;
this.x = x;
this.y = y;
}
x = p.x;
y = p.y;
}
}
Vemos acá dos constructores (notamos que se pueden sobrecargar). Al primero se le pasan dos argumentos, las coordenadas iniciales. En el segundo, se pasa un punto completo, que debe servir de referencia para los valores iniciales.
Si no lo declaráramos, existe un constructor asumido:
Punto () {
x = 0;
y = 0;
}
El objeto al iniciar de la ejecución del programa, nace pleno de vida; feliz or haber pasado por un constructor, con sus métodos listos para trabajar, pero con el paso del tiempo, cada objeto puede ser descartado, y no ser necesario más en la lógica del programa... se fini...!!!
Así, si el programador puede crear objetos, su destrucción, queda en manos del verdugo, o perdón digo de la máquina virtual de Java...!!. Para ello, al introducir los objetos, los referenciamos en variables, como miembros de alguna clase, o parámetros, o variables locales.
Java asigna espacio a los objetos que creamos con new. Y tal espacio se libera, y el objeto se destruye completamente, cuando Java detecta que ese objeto NO ES MAS REFERENCIADO, por ningún objeto activo del sistema.
A tal efecto, la maquina virtual Java ejecuta paralelamente un proceso de recolección de basura denominado "garbage collector", que detecta objetos desreferenciados completamente, los hace pelota y libera su espacio.
Así, ya no bebemos preocuparnos más de decidir cuando un objeto debe ser liberado; como ocurre en C++ donde las referencias a objetos dinámicos se basan en punteros.
Por tanto en C++ podemos destruir un objeto referenciado por un puntero pero, ¿qué pasa si hay otro puntero que referencia a la misma dirección/objeto?. El segundo puntero referenciará a algo inválido, a memoria liberada. Habremos destruido objetos que no deben ser destruidos y podemos olvidarnos de destruir objetos que no ya no necesitamos. En cambio en Java, evitamos esos problemas. Ejemplo:
Punto p1 = new Punto (1,2);
Punto p2 = p1;
p1 = null;
El objeto creado con el new, queda referenciado por p1 . Luego p2 queda apuntando al mismo objeto. Hacemos que p1 apunte a nada. Al final de esta secuencia, el objeto sigue existiendo, y tiene una referencia, la de p2. Cuando hagamos:
p2 = null;
O
p2 = new Punto ();
Ahora, cuando p2 apunte a otro objeto, el objeto inicial quedara sin referencias que lo apunten, y no podrá ser más accedido por ningún elemento del programa. Luego, el objeto puede ser destruido en cualquier momento cuando el "garbage collector" le corte la cabeza..!! y cuando el objeto es destruido, se invoca su método:
proctected void finalize() throws Throwable { .
Que redefinimos para realizar las últimas tareas previo a su partida al más alla.
null indica que no apuntamos a ningún objeto, es el valor que toman los miembros de un objeto que referencian a otros objetos, al momento de ser creados y por tanto null puede ser devuelto por ciertos métodos, que devuelven referencias a objetos, indicando, por ejemplo, que no existe el objeto resultado pedido.
Como no es válido invocar cualquier método de una referencia, si esta contiene null. , conviene preguntar si la referencia tiene o no null.
if (referencia != null)
System.out.println("Existe referencia");
Comparando si una referencia era distinta de null. Los operadores que podemos usar, para comparar referencias son el:
- IGUAL: ==
La igualdad en el caso entre dos rectángulos, no se basa en los valores de sus variables, sino en los valores de sus referencias. Si queremos comparar valores ( por ejemplo, si dos rectángulo tienen el mismo punto de origen, el mismo ancho y el mismo alto), debemos recurrir a un método propio de comparación. - DISTINTO: !=
Los dos primero sólo necesitan una aclaración: dos referencias son iguales, si y sólo si apuntan al mismo objeto. - instanceof
Que se usa así:if (r instanceof Rectángulo)
Determina si un objeto es instancia, pertenece a una clase. Veremos mas adelante, que r puede pertenecer a una subclase de Rectángulo. Aun así, el resultado de r instanceof Rectángulo sería verdadero.
Como al definir una clase cualquiera, establecemos sus atributos y métodos, puede ocurrir que necesitemos crear otra clase, que resulta un caso especial de la anterior. Así, podríamos tener la clase Empresa ya definida, y necesitar ahora definir la clase Cliente.
Notemos que cualquier atributo o método que tenga Empresa como razón social, domicilio, teléfono, también lo necesita Cliente.
Por tanto, podemos construir a Cliente de tal forma que sea un caso especial de Empresa, quizá con atributo y métodos adicionales, como condición de venta y consulta de saldo. Decimos entonces que Cliente hereda todos los atributos y métodos de Empresa.
Además de agregar métodos, podemos redefinir métodos de la clase inicial. Supongamos que tenemos una clase Cuadrilátero, con un método área que calcula su área.
Ahora creamos una clase Rectángulo que hereda de Cuadrilátero. Podemos redefinir su método área, para que lo calcule de otra forma.
No es necesario redefinir todos los métodos. Si un método no se redefine, se hereda sin alterar el
método de la clase inicial.
¿Cómo se implementa la herencia en Java? Al declarar una clase, podemos indicar que es una clase derivada de otra, de la cual hereda todos sus atributos y métodos. Se declara, por ejemplo:
class button extends Component {
Esta es un declaración de la clase Button (botón), como subclase de Component (componente de interfase de usuario). La palabra clave es extends (extiende).
En java, se entiende que una subclase "extiende" las capacidades y conductas de la clase madre.
Sean dos clases:
class Empresa {
class Cliente extends Empresa {
....
// Método de Impresión de datos de una empresa
void imprime() {
....
}
}
...
// Método de impresión de datos de un cliente
void imprime() {
super.imprime(); // Datos de Empresa
// Otras instrucciones de impresión
}
}
Una clase Cliente es subclase de la otra, Empresa; y ambas tienen definido un método imprime, para imprimir sus datos, y al definir el método de impresión de Cliente, aprovechamos el método ya definido de Empresa.
¿Cómo lo invocamos? Con la expresión super.imprime( ). La seudo-variable super apunta al mismo objeto que this pero con métodos de su superclase inmediata.
En este caso, this.imprime( ) es el método de Cliente , mientras que super.imprime( ) es el método de impresión de Empresa.
Podemos redefinir un método sin necesidad de invocar a su supermétodo, y hasta podemos invocarlo en
cualquier momento (al principio, en el medio, al final del nuevo método).
Para crear una clase, que no pueda extenderse en ninguna subclase, puedes definirla como:
class final class Contraseña {
La palabra clave final indica que esta clase no puede extenderse. Otras veces, no queremos que se pueda redefinir un método. Podemos escribir:
final void ingresaContraseña() {
Si queremos que un atributo permanezca constante, podemos ponerle un valor inicial, y con la palabra clave final lo marcamos como inalterable:
final int ncolumnas = 8;
Esta es la forma de declarar constantes. Hemos utilizado algunas, como Font.PLAIN , o Color.yellow. Para los programadores C/C++, es lo más cercano a un #define de una constante.
Nos hemos encontrado con métodos como el main que han sido calificados con la palabra reservada static.
Un método o atributo estático es uno que no está dentro de cada objeto de la clase, sino que existe un único representante para toda la clase en la que está definido. El ejemplo clásico de un atributo estático es un contador de objetos creados de una clase.
class Empleado {
Empleado() {
static int empleados = 0;
empleados++;
}
....
}
Un método estático no se invoca con objeto, pues no lo necesita; puede invocarse antes de la creación de cualquier objeto de su clase. Hay ejemplo estáticos definidos en paquetes y clases, para uso del programador, como por ejemplo el conversor de String a enteros:
int i = Integer.parseString("123");
Hemos definido clases, sus atributos y métodos. En alguna ocasión, nos hemos topado con la palabra clave public, que hemos usado para definir una clase pública en cada archivo .java que hemos construido.
Cuando definimos una clase, un método o un atributo podemos calificarlo como public, private o protected.
Cuando declaramos un método o atributo de una clase como público, establecemos que puede ser accedido desde otros puntos del sistema.
Cuando creamos un objeto de una clase, todos los atributos y métodos definidos como públicos pueden ser usados e invocados, en métodos de la misma clase, o de otras clases.
En tecnología de objetos se trata de no declarar todo público, en especial los atributos. Con esto se logra el llamado encapsulamiento, donde las variables de un objeto quedan ocultas, para impedir que puedan ser modificadas por cualquiera.
Lo que se trata de publicar son los métodos, la conducta del objeto, y no su implementación.
Para conseguir que un atributo o método sólo pueda usarse dentro de la clase en la que esta definido, se puede calificar como private:
private void verificaContraseña() {
Al declarar como privado un miembro de una clase, sólo puede ser invocado y usado en métodos de esa clase. Ni siquiera esta disponible para las subclases.
Si queremos relajar un poco esta restricción, podemos usar el calificador protected.
En este caso, el método o atributo marcado como protegido, puede ser accedido en las subclases que se definan, de la clase inicial, pero seguirá siendo inaccesible a los demás objetos.
Las clases no pueden marcarse como private o como protected.
Si a un atributo o método no lo calificamos con nada, entonces el compilador asume que puede ser
accedido por las demás clases, pero sólo del mismo paquete, que es un conjunto de clases.
Ya veremos paquetes, como el java.awt, que agrupan clases de interfase de
usuario.
En el lenguaje Java, además de clases, existe el concepto de interfase, que es importante a la hora de entender ciertas clases del lenguaje.
Una interfase consiste en una declaración de métodos, sin su implementación, sin su código. Entonces, ¿Para qué sirve? Sirve de molde, podríamos decir, para que a una clase la declaremos como que soporta esa interfase.
Podemos definir una interfase que afirme la existencia de dos métodos,leer y grabar. La podemos definir como:
interface Archivable {
void leer();
void grabar();
}
De ahí en más, cuando queramos afirmar que una clase posee métodos para leerse y grabarse, podemos escribir:
class Documento implements Archivable {
....
}
class Cliente extends Empresa implements Archivable {
....
}
Así evitamos escribir las implementaciones de esos métodos en Documento y en Cliente. Pero es una forma de agrupar métodos y usarlo, definirlos, en clases distintas, que no tienen por qué estar en la misma jerarquía ni estar relacionadas.
Para los que conocen algo de programación orientada a objetos, ésta es la forma que tiene Java de
acercarse algo a la herencia de múltiple clases.
Otros lenguajes orientados a objetos sólo se preocupan de definir clases, las cuales pueden crearlas distintos programadores, y hasta distintas empresas, puede ocurrir que en una librería de manejo de base de datos, exista una clase Tabla, mientras que en otra librería, de clases matemáticas, también puede haber una clase Tabla.
Java aborda el problema, definiendo las clases que brinda, no como una gran conjunto, sino como clases agrupadas en paquetes. Cada paquete tiene un nombre, que puede consistir de palabras unidas por puntos, como java.io, java.applet.
Incluso podemos crear nuestros propios paquetes como com.mp.libros.
Cuando uno accede a una clase, y esta en un paquete, debemos poner el nombre del paquete, pero en nuestros programas importamos el nombre del paquete, en declaraciones como:
import java.applet.* ;
En caso de tener que indicar que la clase Applet pertenece al paquete java.applet, deberíamos escribir expresiones como:
class MiApplet extends java.applet.Applet {
Si quisiéramos que la clases definidas en un archivo .java, fuera a incluirse en un paquete, podemos declarar:
package com.mp.libros;
Al principio del texto del archivo .java, para indicarle al compilador, que las clases que vaya a generar,
pertenecerán a ese paquete.
- CLASES:
- Estado (datos)
- Comportamiento (funciones y rutinas).
- UNA CLASE EN JAVA
- Los datos que contengan, se denominan atributos.
- Las funciones y rutinas que defina, se conoce como sus métodos.
- Un objeto es la instancia de una clase, una clase llevada a la existencia.
Así, la variable entera es una instancia, de int. - Una clase define como es un objeto.
En los lenguajes tradicionales los datos y funciones o rutinas operan sobre esos datos, que son entidades separadas de las funciones que operan sobre ellos. En cambio la POO, una clase es un plano para un objeto, que es una entidad que posee sus propios datos y funciones asociadas.
En programación tradicional por un lado estan los datos de un ente y por otro las funciones que operan sobre esos datos. En la POO, definimos la clase ente, que contendrá tanto los datos privados que describen al ente, como las funciones y rutinas que pueden aplicarse a esos datos.
Así podemos manejar entidades, descriptas en clases, que contienen tanto la información de su:
En la POO, se definen cosas descriptas en clases; como la descripción de entidades del mundo real; facilitando la construcción de una clase, la definición de sus datos, y la especificación de sus rutinas y funciones asociadas, nos lleva a pensar el sistema modularmente.
Cada clase puede diseñarse e implementarse independientemente de las demás, facilitando la utilización de una clase en otro proyecto, y la modificación de alguna en el tiempo, sin necesidad de modificar el resto de las clases.
Se dice que las clases posibilitan la utilización repetida y el mantenimiento del código escrito.
En cada programa java, aparece la definición de por lo menos, alguna clase. Toda declaración de variable, toda función o rutina, está escrita en el entorno de una clase, porque los datos y rutinas, no existen en Java, si no es dentro de una clase.
No hay variables globales o funciones aisladas. Solo existen dentro de una clase..!!, por ello, la clase es una unidad fundamental de Java, donde:
Un ejemplo inicial de clase puede ser el siguiente:
class Punto {
public coordenada x;
public coordenada y;
}
La clase se define con la palabra reservada class, seguida del nombre de la clase. Luego, entre llaves, se va definiendo su estructura. El ejemplo definime una clase, con dos atributos enteros x e y. Los atributos se han declarado con el modificador public: Estos datos son accesibles desde otras clases, es decir, son públicos y conocidos por cualquier otro objeto.
El ejemplo anterior solo define una clase, pero no crea ningún objeto. Cuando necesitemos, en alguna otra clase o métodos, declarar un objeto de la clase Punto, bastará poner.
Punto origen;
Así creamos una variable que referencia o apunta a un objeto de la clase Punto.
El objeto todavía no está creado; solamente se declara una variable, un atributo, que llegado el momento, referenciará un objeto de la clase Punto.
En el momento de la creación, el atributo origen no apunta a ningún objeto, y tiene como valor reservado null, es decir, no apunta a nada.
Si ya tenemos un objeto Punto en la variable p, podemos acceder a sus atributos con expresiones como:
int coordenada = p.x;
Escribiendo de la forma: < Objeto > . < Atributo >
No siempre es posible hacer esto, pues no todos los atributos de un objeto pueden estar disponibles para que puedan ser accedidos en cualquier lugar.
Al crear un objeto, las variables miembros son inicializados a 0 o a null, según el tipo, o en su declaración podemos iniciarlas a algún valor:
class Persona {
int edad = 21;
int peso = 60;
}
Una clase que puede contener atributos que no son tipos primitivos, sino referencias a otros objetos, es la siguiente:
class Rectángulo {
Punto origen;
int ancho;
int alto;
}
Esta clase tiene tres atributos: dos son tipos primitivos (enteros), pero el atributos origen está
definido como va a referenciar a un objeto, una instancia de la clase Punto.
Este atributo no contendrá ningún objeto: debemos crearlo.
Son rutinas y funciones que están asociadas a la clase, que operan sobre sus datos. Se definen en el interior de la clase.
Ejemplo:
class Rectángulo {
Punto origen;
int ancho;
int alto;
int tomarArea () {
return ancho*alto;
}
void ponerAncho (int nuevoAncho) {
ancho = nuevoAncho;
}
void ponerAlto (int nuevoAlto) {
alto = nuevoAlto;
}
void mover (Punto nuevoOrigen) {
origen = nuevoOrigen;
}
}
Hemos agregado algunos métodos.
Un objeto puede contener variables de tipos primitivos, o que son referencias a otros objetos. En este caso, pueden estar ya apuntando a objetos creados, o no pueden apuntar a ninguno (null).
TomarArea, es una función que nos devuelve el área del rectángulo. Al declararlo:
int tomarArea () {
le pusimos un tipo (int, devuelve entero) de resultado. Luego viene el nombre (tomarArea), y los parámetros que recibe, entre paréntesis (en este caso ninguno). Al abrir la llave, comienza el bloque de sentencia que compone el método.
Este método devuelve algo, usando el verbo return, seguido de una expresión resultado:
return ancho*alto;
El tipo de la expresión se convierte al tipo declarado como el resultado a devolver (en este caso, int). El próximo método ya no es una función, pues no devuelve nada.
Al declararlo:
void ponerAncho (int nuevoAncho) {
Su tipo es void (sin valor de retorno). Este método espera un argumento, de tipo entero. Vemos que ese parámetro será el nuevo valor de la variable miembro ancho.
Supongamos que ya tenemos creado y funcionando, un objeto de la clase Rectángulo, y lo llamamos r. Podemos operar sobre él de esta forma:
r.ponerAncho (10);
r.ponerAlto (5);
int area = r.tomarArea ();
Observemos que para invocar a un método de un objeto, escribimos la forma:
< Objeto > .< Método > ( { < parámetros> } )
(Las llaves {} indican que los parámetros son opcionales). Es decir, primero nombramos al objeto, y luego de un punto, ponemos el método que invocamos, siempre seguido de paréntesis, que pueden contener los argumentos que necesita.
Un error muy frecuente es poner:
r.tomarArea;
Es incorrecto, y el compilador lo rechazará: faltan los paréntesis. Sí está permitido accede a una variable miembro inmediatamente:
int ancho = r.ancho;
PARADIGMA
El amor eterno no debe durar más de dos horas . .!!
Wilucha
- EDITA TU PROGRAMA
Copia textualmente el siguiente código en el editor de la plataforma JDK de Java Versión 1.2 de la Empresa Sun
Si estas operando PadPro JAVA y activa: File/New/Java file y pega el listado anterior, luego Graba como Pichula
/*
* Author: Wilucha
* Created: 08/31/2002 16:58:13
* Modified: 08/31/2002 16:58:13
*/
class Pichula
{
String color;
String sexo;
boolean sueño;
void feedPichula() {
if (sueño==true){
System.out.println("Qué Grande soy..!!");
sueño=false;
}else
System.out.println("Qué Chiquito soy..!!");
}
void showAttributes() {
System.out.println("Pichula es un " + sexo+ " tiene color "+ color+ " y es pequeñin..!!");
if (sueño==true){
System.out.println("Pichula tiene sueñito");
sueño=false;
}else
System.out.println("Pichula esta parado");
}
public static void main (String arguments[]){
Pichula j = new Pichula();
j.color = "bonito";
j.sexo = "nene";
j.sueño = true;
System.out.println("ACTO I");
System.out.println("Te cuento que:..");
j.showAttributes();
System.out.println("ACTO II");
System.out.println("Luego, Pichula dice ..");
j.feedPichula();
System.out.println("ACTO III");
System.out.println("Antes de terminar, Pichula dice ..");
j.showAttributes();
System.out.println("ACTO IV");
System.out.println("Finalmente, Pichula se despide y dice ..");
j.feedPichula();
}
}
PARADIGMA
La materia ni se crea ni destruye..
..pero se puede perder..!!
Wilucha
Ahora, verifica cuidadósamente que tu archivo sea una copia fiel del mio..!!
Para compilar: JDK / Compile Pichula.java
Como resultado obtendras el mensaje:
Warning: Space found in classpath: C:\Mis documentos Sun's JDK debugger will not work correctly with a space in the classpath. Warning: Space found in classpath: C:\Mis documentos Sun's JDK debugger will not work correctly with a space in the classpath. ---------------- JDK Debug Build ------------------ Compiling C:\Mis documentos\Pichula.java Command line: "C:\jdk1.2.2\bin\javac.exe" -deprecation -g -classpath "C:\Mis documentos" "C:\Mis documentos\Pichula.java" The current directory is: C:\Mis documentos Finished
PARADIGMA
Un poco de inexactitud, a veces evita..
..toneladas de explicaciones..!!
Wilucha
Para ver el resultado ejecuta el siguiente proceso:
- Revisa que hayas copiado totalmente el archivo del link anterior, luego graba con el nombre de "Pichula" y no pongas ninguna extención, por que el editor lo hará por ti.
- Con tu explorador de Windows ubica el archivo anterior y verás que lo encontrarás bajo el nombre de "Pichula.java"
- Ahora compila con el compilador de java llamado "javac", verás que si no tiene errores el archivo "Pichula.java", javac habrá generado el archivo "Pichula.class"
- Si no metiste el dedito donde no corresponde, al ejecutar "Pichula.class" lograrás el siguiente resultado
Si estas trabajando en la plataforma de JDK, para ejecutar: JDK / Run Aplication Pichula.java
Starting application C:\JPadPro\Documents\Ide\Pichula.class Command line: "C:\jdk1.2.2\bin\java.exe" -classpath "C:\JPadPro\Documents\Ide" Pichula The current directory is: C:\JPadPro\Documents\Ide ACTO I Te cuento que:.. Pichula es un nene tiene color bonito y es pequeñin..!! Pichula tiene sueñito ACTO II Luego, Pichula dice .. Qué Chiquito soy..!! ACTO III Antes de terminar, Pichula dice .. Pichula es un nene tiene color bonito y es pequeñin..!! Pichula esta parado ACTO IV Finalmente, Pichula se despide y dice .. Qué Chiquito soy..!! Interactive Session Ended
Si lograste esto conviene que descorches una botella de un Don Perignon y salud..!! a celebrar..!! .. ahora Java ya está en tu bolsa...!!!
Ahh..!! Te ruego me digas por qué..
..si el tomate puede ser perita, porque la pera no puede ser tomatito.???
En los siguientes links te describiré la sintaxis de esta tu primera aplicación Java.
PARADIGMA
La mentira ... es un simple sistema de verdades..!!!
Wilucha
Ahora que lograste hacer correr la aplicación anterior, para entrar en training y comenzar a captar la sintaxis de Java, modifica el listado fuente de Pichula.java, de acuerdo al siguiente código.
Lee cuidadosamente las descripciones introducidas y con facilidad deducirás la estructura de este novedoso lenguaje.
/* Lenguaje Java 2
* Author: Wilucha
* Created: 08/31/2002 16:58:13
* Modified: 08/31/2002 16:58:13
*/
class Pichula
{
//Declaración de variables
String color;
String sexo;
boolean sueño;
// Método de una Función
void PichulaEnAccion()
{
if (sueño==true)
{
System.out.println("Qué Grande soy..!!");
sueño=false;
}
else
System.out.println("Qué Chiquito soy..!!");
}
// Método de otra Función
void MostrarAtributos()
{
System.out.println("Pichula es un " + sexo+ " que tiene color "+ color+ " y es pequeñin..!!");
if (sueño==true)
{
System.out.println("Pichula tiene sueñito");
sueño=false;
}
else
System.out.println("Pichula esta parado");
}
// FUNCION PRINCIPAL
public static void main (String arguments[]){
Pichula j = new Pichula();
j.color = "bonito";
j.sexo = "nene";
j.sueño = true;
System.out.println("EJEMPLO 1: APLICACION JAVA 2");
System.out.println("PICHULA Wilo Carpio");
System.out.println("ACTO I");
System.out.println("Te cuento que:..");
j.MostrarAtributos();
System.out.println("ACTO II");
System.out.println("Luego, Pichula dice ..");
j.PichulaEnAccion();
System.out.println("ACTO III");
System.out.println("Antes de terminar, Pichula dice ..");
j.MostrarAtributos();
System.out.println("ACTO IV");
System.out.println("Finalmente, Pichula se despide y dice ..");
j.PichulaEnAccion();
}
}
Dime si no tengo razón esta sintaxis es una derivación simplificada de C.??!!
¿Por qué la luz negra no es negra?
PARADIGMA
Si se juntan suficientes datos
..se puede demostrar cualquier cosa..!!
.. con ayuda del sistema estadístico
Wilucha
Con las modicaciones anteriores, ahora Pichula.class, generará el siguiente resultado, que conviene comparar con el anterior resultado.
Starting application C:\JPadPro\Documents\Ide\Pichula.class Command line: "C:\jdk1.2.2\bin\java.exe" -classpath "C:\JPadPro\Documents\Ide" Pichula The current directory is: C:\JPadPro\Documents\Ide EJEMPLO 1: APLICACION JAVA 2 PICHULA Wilo Carpio ACTO I Te cuento que:.. Pichula es un nene que tiene color bonito y es pequeñin..!! Pichula tiene sueñito ACTO II Luego, Pichula dice .. Qué Chiquito soy..!! ACTO III Antes de terminar, Pichula dice .. Pichula es un nene que tiene color bonito y es pequeñin..!! Pichula esta parado ACTO IV Finalmente, Pichula se despide y dice .. Qué Chiquito soy..!! Interactive Session Ended
Finalmente deducirás que la estructura sintáctica de esta aplicación se reduce al siguiente formato
class Pichula
{
//Declaración de variables
// Método de una Función
void PichulaEnAccion()
{
. . . . .
}
// Método de otra Función
void MostrarAtributos()
{
. . . . .
}
// FUNCION PRINCIPAL
public static void main (String arguments[])
{
. . . . .
}
}