INSTITUTO TECNOLÓGICO SUPERIOR DE IRAPUATO

INGENIERÍA EN SISTEMAS COMPUTACIONALES

INTRODUCCIÓN A LA INGENIERÍA EN SISTEMAS

COMPUTACIONALES

TEMA: PROGRAMACIÓN JAVA

RIVERA MUÑOZ JESÚS RAMÓN IS09110255

MAESTRA: MARIANA RICO CHAGOLLAN

IRAPUATO, GTO. 13 DE SEPTIEMBRE DE 2010

Contenido
Contenido............................................................................................................ i
Historia del lenguaje Java...................................................................................3
Programación Java..............................................................................................5
Comentarios....................................................................................................... 6
Identificadores....................................................................................................6
Palabras clave.................................................................................................... 7
Literales.............................................................................................................. 7
Arrays................................................................................................................. 8
Operadores.........................................................................................................9
Separadores..................................................................................................... 10
Clases y objetos............................................................................................... 10
Atributos........................................................................................................... 11
Comportamiento.............................................................................................. 11
El proyecto....................................................................................................... 11
La clase............................................................................................................ 12
Los miembros dato...........................................................................................12
Las funciones miembro....................................................................................13
Los constructores.............................................................................................16
Los objetos....................................................................................................... 17
Acceso a los miembros.....................................................................................18
La vida de un objeto.........................................................................................19
Identificadores..................................................................................................21
BIBLIOGRAFIA...................................................................................................22

i
PROGRAMACION EN JAVA
Historia del lenguaje Java

Java es un lenguaje de programación orientado a objetos desarrollado por Sun

Microsystems a principio de los años 90´s.

En Diciembre de 1950 Patrick Naughton, ingeniero de Sun Microsystems, reclutó

a varios colegas entre ellos James Gosling y Mike Sheridan para trabajar sobre un
nuevo proyecto conocido como "El proyecto verde".
Con la ayuda de otros ingenieros, empezaron a trabajar en una pequeña oficina
en Sand Hill Road en Menlo Park, California. Y así interrumpió todas las
comunicaciones regulares con Sun y trabajó sin descanso durante 18 meses.

Intentaban desarrollar una nueva tecnología para programar la siguiente

generación de dispositivos inteligentes, en los que Sun veía un campo nuevo a
explorar. Crear un lenguaje de programación fácil de aprender y de usar.
En un principio se consideraba C++ como lenguaje a utilizar, pero tanto Gosling
como Bill Joy lo encontraron inadecuado. Gosling intentó primero extender y
modificar C++ resultando el lenguaje C++ ++ - (++ - porque se añadían y
eliminaban características a C++), pero lo abandonó para crear un nuevo lenguaje
desde cero al que llamo Oak (roble en inglés, según la versión más aceptada, por
el roble que veía a través de la ventana de su despacho).

El resultado fue un lenguaje que tenía similitudes con C, C++ y Objetive C y que
no estaba ligado a un tipo de CPU concreta.
Mas tarde, se cambiaría el nombre de Oak a Java, por cuestiones de propiedad
intelectual, al existir ya un lenguaje con el nombre de Oak. Se supone que le
pusieron ese nombre mientras tomaban café (Java es nombre de un tipo de café,
originario de Asia), aunque otros afirman que el nombre deriva de las siglas de
James Gosling, Arthur Van Hoff, y Andy Bechtolsheim.

En Agosto de 1991 Oak ya corría sus primeros programas.

Para 1992, el equipo ya había desarrollado un sistema en un prototipo llamado

Star7 (*7), dispositivo parecido a una PDA, cuyo nombre venía de la combinación
de teclas del teléfono de la oficina del Proyecto Green que permitía a los usuarios
responder al teléfono desde cualquier lugar.

Por su parte, el presidente de la compañía Sun, Scott McNealy, se dio cuenta de

forma oportuna y estableció el Proyecto Verde como una subsidiaria de Sun.

Después de mostrar a Scott McNealy y Bill Joy los prototipos de bajo nivel del
sistema, continúan con el desarrollo, incluyendo sistema operativo, Green OS; el
lenguaje Oak, las librerías, alguna aplicación básica y el hardware, hasta que el 3
de septiembre de 1992 se termina el desarrollo y con ello el Proyecto Verde.

De 1993 a 1994, el equipo de Naughton se lanzó en busca de nuevas

oportunidades en el mercado, mismas que se fueron dando mediante el sistema
operativo base.

3
La incipiente subsidiaria fracasó en sus intentos de ganar una oferta con Time-
Warner, sin embargo el equipo concluyó que el mercado para consumidores
electrónicos smart y las cajas Set-Up en particular, no eran del todo eficaces. La
subsidiaria Proyecto verde fue amortizada por la compañía Sun a mediados de
1994.

Afortunadamente, el cese del Proyecto Verde coincidió con el nacimiento del

fenómeno mundial WEB. Al examinar las dinámicas de Internet, lo realizado por el
ex equipo verde se adecuaba a este nuevo ambiente.

Patrick Naughton procedió a la construcción del lenguaje de programación Java

que se accionaba con un browser prototipo. El 29 de septiembre de 1994 se
termina el desarrollo del prototipo de HotJava. Cuando se hace la demostración a
los ejecutivos de Sun, esta vez, se reconoce el potencial de Java y se acepta el
proyecto.

Con el paso del tiempo HotJava se convirtió en un concepto práctico dentro del
lenguaje Java y demostró que podría proporcionar multiplataformas para que el
código pueda ser bajado y corrido del Host del World Wide Web y que de otra
forma no son seguros.
Una de las características de HotJava fue su soporte para los "applets", que son
las partes de Java que pueden ser cargadas mediante una red de trabajo para
después ejecutarlo localmente y así lograr soluciones dinámicas en computación
acordes al rápido crecimiento del ambiente WEB.

El 23 de mayo de 1995, en la conferencia SunWorld `95, John Gage, de Sun

Microsystems, y Marc Andreessen, cofundador y vicepresidente de Netscape,
anunciaban la versión alpha de Java, que en ese momento solo corría en Solaris,
y el hecho de que Java iba a ser incorporado en Netscape Navigator, el
navegador más utilizado de Internet.

Con la segunda alpha de Java en Julio, se añade el soporte para Windows NT y

en la tercera, en Agosto, para Windows 95.
En enero de 1995 Sun forma la empresa Java Soft para dedicarse al desarrollo de
productos basados en las tecnologías Java, y así trabajar con terceras partes
para crear aplicaciones, herramientas, sistemas de plataforma y servicios para
aumentar las capacidades del lenguaje. Ese mismo mes aparece la versión 1.0
del JDK.

Netscape Communications decide apoyar a Java applets en Netscape Navigator

2.0. Ese fue el factor clave que lanzó a Java a ser conocido y famoso.
Y como parte de su estrategia de crecimiento mundial y para favorecer la
promoción de la nueva tecnología, Java Soft otorgó permisos para otras
compañías para que pudieran tener acceso al código fuente y al mismo tiempo
mejorar sus navegadores.
También les permitía crear herramientas de desarrollo para programación Java y
los facultaba para acondicionar máquinas virtuales Java (JVM), a varios sistemas
operativos.

4
Muy pronto las licencias o permisos contemplaban prestigiosas firmas como: IBM,
Microsoft, Symantec, Silicon Graphics, Oracle, Toshiba y Novell.

Los apples Java (basados en JDK 1.02) son apoyados por los dos más populares
navegadores web (Nestcape Navigator 3.0 y Microsoft Internet Explorer 3.0.
I.B.M./Lotus, Computer Asociates, Symantec, Informix, Oracle, Sybase y otras
poderosas empresas de software están construyendo Software 100% puro JAVA,
por ejemplo el Corel Office que actualmente está en versión Beta.

Los nuevos proyectos de Java son co-patrocinados por cientos de millones de

dólares en capital disponible de recursos tales como la Fundación Java, un fondo
común de capital formado el verano pasado por 11 compañías, incluyendo Cisco
Systems, IBM, Netscape y Oracle.

Hoy en día, puede encontrar la tecnología Java en redes y dispositivos que

comprenden desde Internet y superordenadores científicos hasta portátiles y
teléfonos móviles; desde simuladores de mercado en Wall Street hasta juegos de
uso doméstico y tarjetas de crédito: Java está en todas partes.

Programación Java

El lenguaje para la programación en Java, es un lenguaje orientado a objeto, de

una plataforma independiente.

El lenguaje para la programación en Java, fue desarrollado por la compañía Sun

Microsystems, con la idea original de usarlo para la creación de páginas WEB.

Esta programación Java tiene muchas similitudes con el lenguaje C y C++, así
que si se tiene conocimiento de este lenguaje, el aprendizaje de la programación
Java será de fácil comprensión por un programador que haya realizado
programas en estos lenguajes.

Con la programación en Java, se pueden realizar distintos aplicativos, como son

applets, que son aplicaciones especiales, que se ejecutan dentro de un
navegador al ser cargada una página HTML en un servidor WEB, Por lo general
los applets son programas pequeños y de propósitos específicos.

Otra de las utilidades de la programación en Java es el desarrollo de aplicaciones,

que son programas que se ejecutan en forma independiente, es decir con la
programación Java, se pueden realizar aplicaciones como un procesador de
palabras, una hoja que sirva para cálculos, una aplicación grafica, etc. en
resumen cualquier tipo de aplicación se puede realizar con ella. Java permite la
modularidad por lo que se pueden hacer rutinas individuales que sean usadas por
más de una aplicación, por ejemplo tenemos una rutina de impresión que puede
servir para el procesador de palabras, como para la hoja de cálculo.

5
La programación en Java, permite el desarrollo de aplicaciones bajo el esquema
de Cliente Servidor, como de aplicaciones distribuidas, lo que lo hace capaz de
conectar dos o más computadoras u ordenadores, ejecutando tareas
simultáneamente, y de esta forma logra distribuir el trabajo a realizar.

Comentarios

En Java hay tres tipos de comentarios:

// comentarios para una sola línea

/* comentarios de una o
más líneas
*/

/** comentario de documentación, de una o más líneas

*/

Los dos primeros tipos de comentarios son los que todo programador conoce y se
utilizan del mismo modo. Los comentarios de documentación, colocados
inmediatamente antes de una declaración (de variable o función), indican que ese
comentario ha de ser colocado en la documentación que se genera
automáticamente cuando se utiliza la herramienta de Java, javadoc. Dichos
comentarios sirven como descripción del elemento declarado permitiendo generar
una documentación de nuestras clases escrita al mismo tiempo que se genera el
código.

En este tipo de comentario para documentación, se permite la introducción de

algunos tokens o palabras clave, que harán que la información que les sigue
aparezca de forma diferente al resto en la documentación.

Identificadores
Los identificadores nombran variables, funciones, clases y objetos; cualquier cosa que el
programador necesite identificar o usar.

En Java, un identificador comienza con una letra, un subrayado (_) o un símbolo

de dólar ($). Los siguientes caracteres pueden ser letras o dígitos. Se distinguen
las mayúsculas de las minúsculas y no hay longitud máxima.

Serían identificadores válidos:

identificador
nombre_usuario
Nombre_Usuario
_variable_del_sistema
$transaccion

6
y su uso sería, por ejemplo:

int contador_principal;
char _lista_de_ficheros;
float $cantidad_en_Ptas;

Palabras clave

Las siguientes son las palabras clave que están definidas en Java y que no se
pueden utilizar como identificadores:

abstract continue for new switch

boolean default goto null synchronized
break do if package this
byte double implements private thread safe
by value else import protected throw
case extends instance of public transient
catch false int return true
char final interface short try
class finally long static void
const float native super while

Palabras Reservadas
Además, el lenguaje se reserva unas cuantas palabras más, pero que hasta ahora
no tienen un cometido específico. Son:

cast future generic inner

operator outer rest var

Literales

Un valor constante en Java se crea utilizando una representación literal de él.

Java utiliza cinco tipos de elementos: enteros, reales en coma flotante, booleanos,
caracteres y cadenas, que se pueden poner en cualquier lugar del código fuente
de Java. Cada uno de estos literales tiene un tipo correspondiente asociado con
él.

Enteros:

byte 8 bits complemento a dos

short 16 bits complemento a dos
int 32 bits complemento a dos
long 64 bits complemento a dos
Por ejemplo: 21 077 0xDC00

Reales en coma flotante:

7
 float 32 bits IEEE 754
double 64 bits IEEE 754
Por ejemplo: 3.14 2e12 3.1E12

Booleanos:

true
false

Caracteres:

Por ejemplo: a \t \u???? [????] es un número unicode

Cadenas:

Por ejemplo: "Esto es una cadena literal"

Arrays
Se pueden declarar en Java arrays de cualquier tipo:

char s[];
int iArray[];

Incluso se pueden construir arrays de arrays:

int tabla[][] = new int[4][5];

Los límites de los arrays se comprueban en tiempo de ejecución para evitar

desbordamientos y la corrupción de memoria.

En Java un array es realmente un objeto, porque tiene redefinido el operador [].

Tiene una función miembro: length. Se puede utilizar este método para conocer la
longitud de cualquier array.

int a[][] = new int[10][3];

a.length; /* 10 */
a[0].length; /* 3 */

Para crear un array en Java hay dos métodos básicos. Crear un array vacío:

int lista[] = new int[50];

o se puede crear ya el array con sus valores iníciales:

String nombres[] = {
"Juan","Pepe","Pedro","Maria"
};

Esto que es equivalente a:

String nombres[];

8
 nombres = new String[4];
nombres[0] = new String( "Juan" );
nombres[1] = new String( "Pepe" );
nombres[2] = new String( "Pedro" );
nombres[3] = new String( "Maria" );

No se pueden crear arrays estáticos en tiempo de compilación:

int lista[50]; // generará un error en tiempo de compilación

Tampoco se puede rellenar un array sin declarar el tamaño con el operador new:

int lista[];
for( int i=0; i < 9; i++ )
lista[i] = i;

Es decir, todos los arrays en Java son estáticos. Para convertir un array en el
equivalente a un array dinámico en C/C++, se usa la clase vector, que permite
operaciones de inserción, borrado, etc. en el array.

Operadores
Los operadores de Java son muy parecidos en estilo y funcionamiento a los de C. En la
siguiente tabla aparecen los operadores que se utilizan en Java, por orden de
precedencia:

. [] ()
++ --
! ~ instanceof
* / %
+ -
<< >> >>>
< > <= >= == !=
& ^ |
&& ||
? :
= op= (*= /= %= += -= etc.) ,

Los operadores numéricos se comportan como esperamos:

int + int = int

Los operadores relacionales devuelven un valor booleano.

Para las cadenas, se pueden utilizar los operadores relacionales para

comparaciones además de + y += para la concatenación:

String nombre = "nombre" + "Apellido";

9
El operador = siempre hace copias de objetos, marcando los antiguos para
borrarlos, y ya se encargará el garbage collector de devolver al sistema la
memoria ocupada por el objeto eliminado.

Separadores
Sólo hay un par de secuencias con otros caracteres que pueden aparecer en el código
Java; son los separadores simples, que van a definir la forma y función del código. Los
separadores admitidos en Java son:

() - paréntesis. Para contener listas de parámetros en la definición y llamada a

métodos. También se utiliza para definir precedencia en expresiones, contener
expresiones para control de flujo y rodear las conversiones de tipo.

{} - llaves. Para contener los valores de matrices inicializadas automáticamente.

También se utiliza para definir un bloque de código, para clases, métodos y
ámbitos locales.

[] - corchetes. Para declarar tipos matriz. También se utiliza cuando se

referencian valores de matriz.

; - punto y coma. Separa sentencias.

, - coma. Separa identificadores consecutivos en una declaración de variables.

También se utiliza para encadenar sentencias dentro de una sentencia for.

. - punto. Para separar nombres de paquete de subpaquetes y clases. También se

utiliza para separar una variable o método de una variable de referencia.

Clases y objetos

Cuando se escribe un programa en un lenguaje orientado a objetos, definimos

una plantilla o clase que describe las caracterísiticas y el comportamiento de un
conjunto de objetos similares. La clase automóvil describe las características
comunes de todos los automóviles: sus atributos y su comportamiento. Los
atributos o propiedades se refieren a la marca o fabricante, el color, las
dimensiones, si tienen dos, tres, cuatro o más puertas, la potencia, si utiliza como
combustible la gasolina o gasoil, etc. El comportamiento se refiere a la posibilidad
de desplazarse por una carretera, frenar, acelerar, cambiar de marcha, girar, etc.

Luego, tenemos automóviles concretos, por ejemplo el automóvil propio de una

determinada marca, color, potencia, etc., el automóvil del vecino de otra marca,
de otro color, etc., el automóvil de un amigo, etc.

10
Una clase es por tanto una plantilla implementada en software que describe un
conjunto de objetos con atributos y comportamiento similares.

Una instancia u objeto de una clase es una representación concreta y específica

de una clase y que reside en la memoria del ordenador.

Atributos

Los atributos son las características individuales que diferencian un objeto de otro
y determinan su apariencia, estado u otras cualidades. Los atributos se guardan
en variables denominadas de instancia, y cada objeto particular puede tener
valores distintos para estas variables.

Las variables de instancia también denominados miembros dato, son declaradas

en la clase pero sus valores son fijados y cambiados en el objeto.

Además de las variables de instancia hay variables de clase, las cuales se aplican
a la clase y a todas sus instancias. Por ejemplo, el número de ruedas de un
automóvil es el mismo cuatro, para todos los automóviles.

Comportamiento

El comportamiento de los objetos de una clase se implementa mediante funciones

miembro o métodos. Un método es un conjunto de instrucciones que realizan una
determinada tarea y son similares a las funciones de los lenguajes estructurados.

Del mismo modo que hay variables de instancia y de clase, también hay métodos
de instancia y de clase. En el primer caso, un objeto llama a un método para
realizar una determinada tarea, en el segundo, el método se llama desde la propia
clase.

El proyecto

El proyecto consta de dos archivos, el primero contiene la clase Rectangulo que

se guarda en el archivo Rectangulo.java y no tiene el método main. La última
casilla del asistente de creación de clases New Java File debe de estar
desactivada.

La otra clase, es la que describe la aplicación RectanguloApp1 y se guarda en el

archivo RectanguloApp1.java, esta clase tiene que tener el método main, por lo

11
tanto, la última casilla del asistente de creación de clases New Java File debe de
estar activada.

Un proyecto puede constar de varias clases (normalmente se sitúa cada clase en

un archivo) pero solamente una tiene el método main y representa la aplicación.
Para distinguir la clase que describe la aplicación de las demás le hemos añadido
el sufijo App.

rectangulo1: Rectangulo.java, RectanguloApp1.java

La clase

Para crear una clase se utiliza la palabra reservada class y a continuación el

nombre de la clase. La definición de la clase se pone entre las llaves de apertura
y cierre. El nombre de la clase empieza por letra mayúscula.

class Rectangulo{
//miembros dato
//funciones miembro
}

Los miembros dato

Los valores de los atributos se guardan en los miembros dato o variables de

instancia. Los nombres de dichas variables comienzan por letra minúscula.

Vamos a crear una clase denominada Rectangulo, que describa las

características comunes a estas figuras planas que son las siguientes:

• El origen del rectángulo: el origen o posición de la esquina superior izquierda del

rectángulo en el plano determinado por dos números enteros x e y.
• Las dimensiones del rectángulo: ancho y alto, otros dos números enteros.

class Rectangulo{
int x;

12
 int y;
int ancho;
int alto;
//faltan las funciones miembro
}

Las funciones miembro

En el lenguaje C++ las funciones miembro se declaran, se definen y se llaman. En

el lenguaje Java las funciones miembro o métodos solamente se definen y se
llaman.

El nombre de las funciones miembro o métodos comienza por letra minúscula y

deben sugerir acciones (mover, calcular, etc.). La definición de una función tiene
el siguiente formato:

tipo nombreFuncion (tipo parm1, tipo parm2, tipo parm3){

//...sentencias
}

Entre las llaves de apertura y cierre se coloca la definición de la función. Tipo

indica el tipo de dato que puede ser predefinido int, double, etc., o definido por el
usuario, una clase cualquiera.

Para llamar a una función miembro o método se escribe

retorno=objeto.nombreFuncion(arg1, arg2, arg3);

Cuando se llama a la función, los argumentos arg1, arg2, arg3 se copian en los
parámetros parm1, parm2, parm3 y se ejecutan las sentencias dentro de la
función. La función finaliza cuando se llega al final de su bloque de definición o
cuando encuentra una sentencia return.

Cuando se llama a la función, el valor devuelto mediante la sentencia return se

asigna a la variable retorno.

Cuando una función no devuelve nada se dice de tipo void. Para llamar a la
función, se escribe

objeto.nombreFuncion(arg1, arg2, arg3);

Estudiaremos más adelante con más detalle cómo se definen las funciones.

Una función suele finalizar cuando llega al final del bloque de su definición

void funcion(....){
//sentencias...
}

13
Una función puede finalizar antes del llegar al final de su definición

void funcion(....){
//sentencias...
if(condicion) return;
//sentencias..
}

Una función puede devolver un valor (un tipo de dato primitivo o un objeto).

double funcion(....){
double suma=0.0;
//sentencias...
return suma;
}

Cualquier variable declarada dentro de la función tiene una vida temporal,

existiendo en memoria, mientras la función esté activa. Se trata de variables
locales a la función. Por ejemplo:

void nombreFuncion(int parm){

//...
int i=5;
//...
}

La variable parm, existe desde el comienzo hasta el final de la función. La variable

local i, existe desde el punto de su declaración hasta el final del bloque de la
función.

Se ha de tener en cuenta que las funciones miembro tienen acceso a los

miembros dato, por tanto, es importante en el diseño de una clase decidir qué
variables son miembros dato, qué variables son locales a las funciones miembro,
y qué valores les pasamos a dichas funciones. Los ejemplos nos ayudarán a
entender esta distinción.

Hemos definido los atributos o miembros dato de la clase Rectangulo, ahora le

vamos añadir un comportamiento: los objetos de la clase Rectangulo o
rectángulos sabrán calcular su área, tendrán capacidad para trasladarse a otro
punto del plano, sabrán si contienen en su interior un punto determinado del
plano.

La función que calcula el área realizará la siguiente tarea, calculará el producto

del ancho por el alto del rectángulo y devolverá el resultado. La función devuelve
un entero es por tanto, de tipo int. No es necesario pasarle datos ya que tiene
acceso a los miembros dato ancho y alto que guardan la anchura y la altura de un
rectángulo concreto.

class Rectangulo{
int x;
int y;
int ancho;
int alto;
int calcularArea(){

14
 return (ancho*alto);
}
}

A la función que desplaza el rectángulo horizontalmente en dx, y verticalmente en

dy, le pasamos dichos desplazamientos, y a partir de estos datos actualizará los
valores que guardan sus miembros dato x e y. La función no devuelve nada es de
tipo void.

class Rectangulo{
int x;
int y;
int ancho;
int alto;
void desplazar(int dx, int dy){
x+=dx;
y+=dy;
}
}

La función que determina si un punto está o no en el interior del rectángulo,

devolverá true si el punto se encuentra en el interior del rectángulo y devolverá
false si no se encuentra, es decir, será una función del tipo boolean. La función
necesitará conocer las coordenadas de dicho punto. Para que un punto de
coordenadas x1 e y1 esté dentro de un rectángulo cuyo origen es x e y, y cuyas
dimensiones son ancho y alto, se deberá cumplir a la vez cuatro condiciones

x1>x y a la vez x1<x+ancho

También se debe cumplir

y1>y y a la vez y1<y+alto

Como se tienen que cumplir las cuatro condiciones a la vez, se unen mediante el
operador lógico AND simbolizado por &&.

class Rectangulo{
int x;
int y;
int ancho;
int alto;
boolean estaDentro(int x1, int y1){
if((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho)){
return true;
}
return false;
}
}

En el lenguaje Java, si la primera condición es falsa no se evalúan las restantes

expresiones ya que el resultado es false. Ahora bien, si la primera es verdadera
true, se pasa a evaluar la segunda, si ésta el falsa el resultado es false, y así
sucesivamente.

15
Los constructores

Un objeto de una clase se crea llamando a una función especial denominada

constructor de la clase. El constructor se llama de forma automática cuando se
crea un objeto, para situarlo en memoria e inicializar los miembros dato
declarados en la clase. El constructor tiene el mismo nombre que la clase. Lo
específico del constructor es que no tiene tipo de retorno.

class Rectangulo{
int x;
int y;
int ancho;
int alto;
Rectangulo(int x1, int y1, int w, int h){
x=x1;
y=y1;
ancho=w;
alto=h;
}
}

El constructor recibe cuatro números que guardan los parámetros x1, y1, w y h, y
con ellos inicializa los miembros dato x, y, ancho y alto.

Una clase puede tener más de un constructor. Por ejemplo, el siguiente

constructor crea un rectángulo cuyo origen está en el punto (0, 0).

class Rectangulo{
int x;
int y;
int ancho;
int alto;
Rectangulo(int w, int h){
x=0;
y=0;
ancho=w;
alto=h;
}
}

Este constructor crea un rectángulo de dimensiones nulas situado en el punto (0,

0),

class Rectangulo{
int x;
int y;
int ancho;
int alto;
Rectangulo(){
x=0;
y=0;
ancho=0;

16
 alto=0;
}
}

Con estas porciones de código definimos la clase, y la guardamos en un archivo

que tenga el mismo nombre que la clase Rectangulo y con extensión .java.

public class Rectangulo {

int x;
int y;
int ancho;
int alto;
public Rectangulo() {
x=0;
y=0;
ancho=0;
alto=0;
}
public Rectangulo(int x1, int y1, int w, int h) {
x=x1;
y=y1;
ancho=w;
alto=h;
}
public Rectangulo(int w, int h) {
x=0;
y=0;
ancho=w;
alto=h;
}
int calcularArea(){
return (ancho*alto);
}
void desplazar(int dx, int dy){
x+=dx;
y+=dy;
}
boolean estaDentro(int x1, int y1){
if((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho)){
return true;
}
return false;
}
}

Los objetos

Para crear un objeto de una clase se usa la palabra reservada new.

Por ejemplo,

Rectangulo rect1=new Rectangulo(10, 20, 40, 80);

17
new reserva espacio en memoria para los miembros dato y devuelve una
referencia que se guarda en la variable rect1 del tipo Rectangulo que
denominamos ahora objeto. Dicha sentencia, crea un objeto denominado rect1 de
la clase Rectangulo llamando al segundo constructor en el listado. El rectángulo
estará situado en el punto de coordenadas x=10, y=20; tendrá una anchura de
ancho=40 y una altura de alto=80.

Rectangulo rect2=new Rectangulo(40, 80);

Crea un objeto denominado rect2 de la clase Rectangulo llamando al tercer

constructor, dicho rectángulo estará situado en el punto de coordenadas x=0, y=0;
y tendrá una anchura de ancho=40 y una altura de alto=80.

Rectangulo rect3=new Rectangulo();

Crea un objeto denominado rect3 de la clase Rectangulo llamando al primer

constructor, dicho rectángulo estará situado en el punto de coordenadas x=0, y=0;
y tendrá una anchura de ancho=0 y una altura de alto=0.

Acceso a los miembros

Desde un objeto se puede acceder a los miembros mediante la siguiente sintaxis

objeto.miembro;

Por ejemplo, podemos acceder al miembro dato ancho, para cambiar la anchura
de un objeto rectángulo.

rect1.ancho=100;

El rectángulo rect1 que tenía inicialmente una anchura de 40, mediante esta
sentencia se la cambiamos a 100.

Desde un objeto llamamos a las funciones miembro para realizar una determinada
tarea. Por ejemplo, desde el rectángulo rect1 llamamos a la función calcularArea
para calcular el área de dicho rectángulo.

rect1.calcularArea();

La función miembro area devuelve un entero, que guardaremos en una variable

entera medidaArea, para luego usar este dato.

int medidaArea=rect1.calcularArea();
System.out.println("El área del rectángulo es "+medidaArea);

Para desplazar el rectángulo rect2, 10 unidades hacia la derecha y 20 hacia

abajo, escribiremos

rect2.desplazar(10, 20);

18
Podemos verificar mediante el siguiente código si el punto (20, 30) está en el
interior del rectángulo rect1.

if(rect1.estaDentro(20,30)){
System.out.println("El punto está dentro del rectángulo");
}else{
System.out.println("El punto está fuera del rectángulo");
}

rect1.dentro() devuelve true si el punto (20, 30) que se le pasa a dicha función
miembro está en el interior del rectángulo rect1, ejecutándose la primera
sentencia, en caso contrario se ejecuta la segunda.

Como veremos más adelante no siempre es posible acceder a los miembros, si

establecemos controles de acceso a los mismos.

public class RectanguloApp1 {

public static void main(String[] args) {
Rectangulo rect1=new Rectangulo(10, 20, 40, 80);
Rectangulo rect2=new Rectangulo(40, 80);
Rectangulo rect3=new Rectangulo();
int medidaArea=rect1.calcularArea();
System.out.println("El área del rectángulo es "+medidaArea);

rect2.desplazar(10, 20);

if(rect1.estaDentro(20,30)){
System.out.println("El punto está dentro del rectángulo");
}else{
System.out.println("El punto está fuera del rectángulo");
}
}
}

La vida de un objeto

En el lenguaje C++, los objetos que se crean con new se han de eliminar con
delete. new reserva espacio en memoria para el objeto y delete libera dicha
memoria. En el lenguaje Java no es necesario liberar la memoria reservada, el
recolector de basura (garbage collector) se encarga de hacerlo por nosotros,
liberando al programador de una de las tareas que más quebraderos de cabeza le
producen, olvidarse de liberar la memoria reservada.

Veamos un ejemplo

public class UnaClase {

public static void main(String[] args) {
Image granImagen=creaImagen();
mostrar(graImagen);
while(condicion){
calcular();

19
 }
}
}

El objeto granImagen, continua en memoria hasta que se alcanza el final de la

función main, aunque solamente es necesario hasta el bucle while. En C o en C+
+ eliminariamos dicho objeto liberando la memoria que ocupa mediante delete. El
equivalente en Java es el de asignar al objeto granImagen el valor null.

public class UnaClase {

public static void main(String[] args) {
Image granImagen=creaImagen();
mostrar(graImagen);
granImagen=null;
while(condicion){
calcular();
}
}
}

A partir de la sentencia marcada en letra negrita el recolector de basura se

encargará de liberar la memoria ocupada por dicha imagen. Así pues, se asignará
el valor null a las referencias a objetos temporales que ocupen mucha memoria
tan pronto como no sean necesarios.

Creamos dos objetos de la clase rectángulo, del mismo modo que en el apartado
anterior

Rectangulo rect1=new Rectangulo(10, 20, 40, 80);

Rectangulo rect3=new Rectangulo();

Si escribimos

rect3=rect1;

En rect3 se guarda la referencia al objeto rect1. La referencia al objeto rect3 se

pierde. El recolector se encarga de liberar el espacio en memoria ocupado por el
objeto rect3.

La destrucción de un objeto es una tarea (thread) de baja prioridad que lleva a

cabo la Máquina Virtual Java (JVM). Por tanto, nunca podemos saber cuando se
va a destruir un objeto.

Puede haber situaciones en las que es necesario realizar ciertas operaciones que
no puede realizar el recolector de basura (garbage collector) cuando se destruye
un objeto. Por ejemplo, se han abierto varios archivos durante la vida de un
objeto, y se desea que los archivos estén cerrados cuando dicho objeto
desaparece. Se puede definir en la clase un método denominado finalize que
realice esta tarea. Este método es llamado por el recolector de basura
inmediatamente antes de que el objeto sea destruido.

20
Identificadores

Cómo se escriben los nombres de las variables, de las clases, de las funciones,
etc., es un asunto muy importante de cara a la comprensión y el mantenimiento
de código. En la introducción a los fundamentos del lenguaje Java hemos tratado
ya de los identificadores.

El código debe de ser tanto más fácil de leer y de entender como sea posible.
Alguien que lea el código, incluso después de cierto tiempo, debe ser capaz de
entender lo que hace a primera vista, aunque los detalles internos, es decir, cómo
lo hace, precise un estudio detallado.

Vemos primero un ejemplo que muestra un código poco legible y por tanto, muy
difícil de mantener

public class Cuen{

private int ba;

Cuen(int ba){
this.ba=ba;
}
public void dep(int i){
ba+=i;
}
public boolean ret(int i){
if(ba>=i){
ba-=i;
return true;
}
return false;
}
public int get(){
return ba;
}
}

Las abreviaciones empleadas solamente tienen significado para el programador

en el momento de escribir el código, ya que puede olvidarse de su significado con
el tiempo. Otros programadores del grupo tienen que descifrar el significado del
nombre de cada variable o de cada función. El tiempo extra que se gasta en
escribir con claridad el nombre de los diversos elementos que entran en el
programa, se ahorra más adelante durante su desarrollo, depuración, y mejora, es
decir, durante todo el ciclo de vida del programa.

public class CuentaBancaria{

private int balance;
CuentaBancaria(int balance){
this.balance=balance;
}
public void depositar(int cantidad){
balance+=cantidad;
}
public boolean retirar(int cantidad){
if(balance>=cantidad){

21
 balance-=cantidad;
return true;
}
return false;
}
public int obtenerBalance(){
return balance;
}
}

Este es una programa sencillo de una cuenta bancaria. El tipo de dato puede ser
entero (int o long), si la unidad monetaria tiene poco valor como la peseta, o un
número decimal (double) si la unidad monetaria es de gran valor como el Euro y
el Dólar.

El código de las funciones miembro es muy sencillo y su significado se hace

evidente al leer el programa. La función retirar es de tipo boolean, ya que no
(false) estamos autorizados a retirar una cantidad mayor que la existente en ese
momento en el banco. Sin embargo, si (true) estamos autorizados a retirar una
cantidad menor que la que tenemos en la cuenta.

BIBLIOGRAFIA
http://sunsite.dcc.uchile.cl/java/docs/JavaTut/Cap1/progra.html

Hora de consulta: 14:35 p.m.

http://www.lenguajes-de-programacion.com/programacion-java.shtml

Hora de consulta: 14:46 p.m.

http://www.cad.com.mx/historia_del_lenguaje_java.htm

Hora de consulta: 14:51 p.m.

http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/clases1/clases.htm

Hora de consulta: 15:05 p.m.

22