1 Apunte de clase

APUNTE DE CLASE
UNIDAD 2 (1)
LENGUAJES DE
PROGRAMACIÓN
2 Apunte de clase

Índice

I. Introducción ........................................................................................... 3

II. Estructura Básica de Lenguaje Java .................................................. 5

III. Identificadores: Variables y Constantes ............................................. 8

IV. Entrada y Salida ............................................................................... 12

V. Métodos Accesadores ...................................................................... 14

VI. Métodos Mutadores .......................................................................... 15

VII. Métodos Propios ............................................................................... 16

VIII. Conclusiones ................................................................................. 20

IX. Bibliografía ........................................................................................ 21

3 Apunte de clase

I. Introducción Fundamentos de JAVA

Java es un lenguaje orientado a objetos, característica compartida por los

principales lenguajes de programación modernos (como C#, C++, Object C o

Python) o al menos implementada en casi todos ellos (lenguajes híbridos, que

permiten programación orientada a objetos, pero también otros paradigmas, como

son PHP, Visual Basic .NET). Gracias a su plataforma JVM (Java Virtual Machine)

es un lenguaje multiplataforma, es decir el código creado puede ser ejecutado en

diferentes sistemas como son Windows, Android, iOS, Linux, etc.

En rigor, Java no es un lenguaje que produzca archivos binarios (como es el

resultado de un programa realizado en C) sino que produce archivos intermedios,

denominados de ByteCodes (en archivos de extensión .class) que ya han pasado

por un proceso de depuración de errores (al menos en cuanto a sintaxis) y que

son tomados y ejecutados por el JRE (Java Runtime Environment) que es parte de

la JVM y está disponible en la plataforma en la que se desee ejecutar. (García,

2010)

Normalmente, un programa en Java, será integrado en un único archivo

(normalmente de extensión .jar, que corresponde a un archivo comprimido (similar

al sistema zip o rar) que contienen todos los archivos .class, y que permite su

distribución.

Gráficamente:
4 Apunte de clase

Figura 1: Modelo de Aplicación Java (Material creado para este curso)

Pero, una de las características más importantes para todo nuevo programador

en Java, es que Java está basado en gran medida en el lenguaje C, lo que facilita

enormemente el proceso de aprendizaje del lenguaje. Las instrucciones de

asignación, las condicionales, las instrucciones de control de ciclos, si no son

idénticas, son muy parecidas.

En este documento se presentarán los conceptos básicos de un programa en

Java, se verán los identificadores, instrucciones de entrada y salida, los principales

métodos que se deben utilizar en un programa en Java.

5 Apunte de clase

II. Estructura Básica de Lenguaje Java

Para efectos del presente documento, se instaló Eclipse Photon (edición de

junio de 2018) con la máquina virtual Java-SE 1.8

Figura 2: Pantalla Inicial eclipse Photon (Material creado para el curso)

Un programa en Java siempre será creado en una Clase. Para ello, lo primero

es crear un proyecto (que consiste en el conjunto de clases de objetos que estarán

disponibles para la aplicación).

6 Apunte de clase

Figura 3: Crear un Proyecto Java (Material creado para el curso)

Luego se debe crear una clase, que será la que, de forma a la aplicación,

gracias a un método público (es decir, accesible desde cualquier parte) estático

(es decir, que no requiere ser instanciado) y de retorno vacío (void) que será

denominado Main() (Flórez, 2012).

7 Apunte de clase

Figura 4: Nueva Clase incluyendo “Main” (Material creado para el curso)

Por lo tanto, un programa en Java consistirá de uno o más archivos de

extensión .java, que en conjunto forman un proyecto. Este proyecto podrá utilizar

clases de objetos específicamente creadas para el proyecto, podrá utilizar clases

de objetos previamente creadas (es decir, archivos .java del programador) o

clases de objetos propias de la API (la Interfaz de la Aplicación para Programas)

que ofrece las clases de objetos que son más comúnmente utilizadas. Se debe

tener presente que hay distintas versiones de la JVM, por lo que puede haber

algunas variaciones.
8 Apunte de clase

III. Identificadores: Variables y Constantes

Como se indicó, un objeto contiene datos propios (atributos o propiedades) que

son equivalentes a las variables de otros lenguajes, y funciones para operar con

ellos (métodos o acciones). Además, los métodos pueden contener variables

locales, cuyo alcance corresponde exclusivamente al tiempo de ejecución del

método (el mismo principio de las variables de las funciones en C).

Los atributos de una clase, al igual que las variables en un método, pueden ser

tipos básicos (es decir, int, char, etc) o también otros objetos de clases declaradas

en la API de Java o en los demás archivos de la aplicación Java.

La forma de hacer una declaración de variables en Java es similar a la de C:

<tipo> <identificador_variable>;

O, incluyendo la inicialización de valores:

<tipo> <identificador_variable> = <valor>;

Por ejemplo:

public class miclase {

prívate int propiedadEntera;
prívate int propiedadEnteraInicializada = 1;
public static void main(String[] parametro) {
int variableEntera;
int variableEnteraInicializada = 3;
clase objeto = new clase(valores iniciales);
}
}
9 Apunte de clase

Son propiedades (parte de la clase) propiedadEntera y

propiedadEnteraInicializada; ellas pueden ser utilizadas desde cualquier método

NO estático (los métodos estáticos sólo pueden usar variables locales).

En cambio, variableEntera y variableEnteraInicializada son variables locales al

método main, y por lo mismo, sólo se pueden utilizar en el mismo método.

El último ejemplo, es el de una variable llamada “objeto” que es de tipo “clase” y

que es inicializada instanciándola (creándola) con valores iniciales (los valores

para instanciar una clase son definidos en cantidad y tipo por la misma clase).

(Flórez, 2012).

En Java, al igual que en otros lenguajes, existen palabras reservadas, que no

pueden ser utilizadas para identificar variables (tampoco clases, propiedades o

métodos).

La lista de palabras reservadas en Java es considerada “sorprendentemente

corta” (Perry, 2012) y corresponde a las siguientes palabras:

 abstract (declaración de clases o métodos)

 assert (para depuración)
 boolean (tipo básico de dato)
 break (instrucción de control de flujo)
 byte (tipo básico de dato)
 case (instrucción de control de flujo)
 catch (instrucción de control de flujo)
 char (tipo básico de dato)
 class (declaración de clases o métodos)
10 Apunte de clase

 const (palabra obsoleta, pero aún reservada)

 continue (instrucción de control de flujo)
 default (instrucción de control de flujo)
 double (tipo básico de dato)
 do (instrucción de control de flujo)
 else (instrucción de control de flujo)
 enum (tipo avanzado)
 extends (declaración de clases)
 false (valor lógico falso)
 final (declaración de clases y constantes)
 finally (instrucción de control de flujo)
 float (tipo básico de dato)
 for (instrucción de control de flujo)
 goto (palabra obsoleta, pero aún reservada)
 if (instrucción de control de flujo)
 implements (declaración de clases)
 import (inclusion de paquetes)
 instanceof (operador de pertenencia a clases)
 int (tipo básico de dato)
 interface (declaración de clases)
 long (tipo básico de dato)
 native (declaración de métodos)
 new (inicialización de objetos de una clase)
 null (valor nulo, generalmente asociado a 0)
 package (agrupación de clases)
 private (declaración de encapsulamiento)
 protected (declaración de encapsulamiento)
 public (declaración de encapsulamiento)
 return (instrucción de control de flujo)
 short (tipo básico de dato)
11 Apunte de clase

 static (declaración de métodos)

 strictfp (usada para definir la precisión o redondeo de variables de punto
flotante)
 super (acceso a clases superiores en herencia)
 switch (instrucción de control de flujo)
 synchronized (declaración de métodos con control)
 this (referencia al mismo objeto, usado dentro de métodos)
 throw (instrucción de control de flujo)
 throws (declaración de métodos)
 transient (declaración de propiedades)
 true (valor lógico verdadero)
 try (instrucción de control de flujo)
 void (tipo básico de dato vacío para funciones que no retornan)
 volatile (declaración de propiedades)
 while (instrucción de control de flujo)

Cuando se desea declarar una constante, la forma es parecida a la declaración

de una variable o propiedad, más el valor inicial, pero usa dos palabras

reservadas: “static” (para indicar que está disponible a todo el programa, sin

necesidad de inicializar clase) y “final” (para indicar que el valor no será

modificado):

static final int MESES = 12;

No es obligatorio, pero una norma no escrita de programación establece que las

constantes deben ser escritas en mayúsculas (para diferenciar de las variables y

ubicarlas rápidamente en el código).

12 Apunte de clase

IV. Entrada y Salida

Al igual que en muchos lenguajes (como C) en Java la entrada y salida

estándar de información, es siempre por la “Consola”, es decir, la interfaz de texto

simple. La forma tradicional de entender la consola considera tres grandes

elementos:

1. Entrada Estándar: consiste en el obtener líneas de datos del teclado. Sin

embargo, puede ser redirigida, para que tome los datos de un archivo de texto.

2. Salida Estándar: consiste en colocar resultados (caracteres) en la pantalla.

Sin embargo, se puede redirigir para que coloque los resultados en un archivo de

texto.

3. Error Estándar: es similar a la salida estándar, pero a diferencia de la

anterior, no se puede redirigir. Siempre coloca los resultados en la consola.

El siguiente ejemplo, considera el uso de la entrada y salida estándar (y la

consola aparece abajo a la derecha).

13 Apunte de clase

Figura 5: Uso de entrada y salida estándar (elaboración propia).

La instrucción System.out.println sirve para colocar información en la Salida

Estándar,

Se puede obtener la entrada estándar usando los métodos de System.in (read:

que lee un carácter), sin embargo, para poder acceder al teclado, es mucho más

eficiente usar la clase “Scanner” que facilita el obtener los datos. Cuando se

inicializa la variable teclado, como new Scanner(System.in) se está indicando que

debe hacer lectura de la entrada estándar.

Si se invoca a la salida de error estándar, debe hacerse de manera similar a la

salida estándar, pero en vez de “out”, se denomina “err”. Por ejemplo:

System.err.println(“salida a error estándar”);

14 Apunte de clase

Como dato anecdótico, la consola de Eclipse coloca todas las salidas a error

estándar, de color rojo (para destacarlas).

V. Métodos Accesadores

Cuando se genera una clase, es habitual colocar todas las propiedades como

parte de la interfaz privada, es decir, que sólo sean vistas dentro de los métodos

de la misma clase. Esto garantiza una mejor manera de encapsulamiento, pues

los programadores que usan la clase (no el que la programa) no necesita saber si

en la clase persona, el rut está como un string o como un número (y si se guarda o

no el dígito verificador).

Para que esto funcione, se definen los métodos accesadores, es decir, métodos

públicos (que se ven desde fuera de la clase) que permiten obtener el valor de

determinada propiedad. Por ejemplo:

public class Persona {

prívate int numero;
prívate char digitoVerificador;
public String obtieneRUT() {
String miRUT;
miRUT = integer.toString(this.numero) + '-' + this.digitoVerificador;
return miRUT;
}
}

La clase Persona, define el RUT como un número con Dígito Verificador, pero

en su interfaz indica que el RUT, será entregado a otras clases o partes del

programa a través de un método específico: obtieneRUT, que retorna un String. Y

ese método se encarga de hacer la conversión. Para ello primero convierte el

15 Apunte de clase

número en string a través de la función integer.toString() , y luego agrega un guión

y el dígito verificador. Si más adelante, el programador de la clase persona decide

que no es necesario guardar el dígito verificador del rut en una variable, y que es

más fácil calcularlo cada vez, puede cambiar el método a:

public String obtieneRUT() {

String miRUT;
miRUT = integer.toString(this.numero) + ‘-‘ + this.calculaDigito();
return miRUT;
}

Y los programadores de las demás clases, no tendrán ningún efecto en sus

códigos.

Mención especial debe hacerse al uso de “this.” que es la forma en que se

indica que el método obtieneRUT debe tener acceso a la propiedad número del

propio objeto. La palabra reservada “this.” es equivalente al uso en el lenguaje del

“mi”, es decir cuando digo “mi nombre” indico que es la propiedad nombre, pero

“mia” (no de otro). Nótese que, además, al ser número una propiedad privada, no

se puede tener acceso a la propiedad de otro objeto (por ejemplo, no se puede

pedir otroObjeto.numero, sólo this.numero). (García, 2010)

VI. Métodos Mutadores

Los métodos mutadores, son la contrapartida de los métodos accesadores. Es

decir, también son métodos públicos (deben serlo) pero son aquellos que permiten

asignar o variar los valores de una determinada propiedad. (García, 2010).

16 Apunte de clase

Considerando el mismo ejemplo anterior, el método que permite asignar el

valor del número del RUT; podría tomar algunas versiones diferentes:

public class Persona {

prívate int numero;
prívate char digitoVerificador;
public void asignaRUT(int numero, char digito) {
this.numero = numero;
this.digitoVerificador = digito;
}
}

En esta versión, en cambio, el RUT se recibe como un único String que es

transformado en número y dígito verificador:

public class Persona {

prívate int numero;
prívate char digitoVerificador;
public void asignaRUT(String rut) { // rut = 71.602.500-4
rut = rut.toUpperCase(); // todo a mayúsculas. rut = 71.602.500-4
rut = rut.replace(".", ""); // elimina puntos. rut = 71602500-4
rut = rut.replace("-", ""); // elimina el guión. rut = 716025004
this.numero = Integer.parseInt(rut.substring(0, rut.length() - 1));
this.digitoVerificador = rut.charAt(rut.length() - 1);
}
}

Por supuesto, el algoritmo asume que lo que viene es un RUT y no cualquier

texto (para asegurarse, quizá haya que validar que no haya error al hacer la

conversión de texto a número entero).

VII. Métodos Propios

Un tercer tipo de método, son denominados los Métodos Propios, es decir,

aquellos métodos que son propios de la funcionalidad de la clase (no accesadores

o mutadores). Aunque la mayoría de los métodos propios son –por lo general-

públicos, podrían ser privados (sólo se pueden llamar desde otro método de la
17 Apunte de clase

clase) o protegidos (se pueden llamar desde métodos de la misma clase o de sus

herederas).

Por ejemplo, en el caso de la clase persona, es una función necesaria, la de

validar el dígito verificador del RUT, por lo tanto, se requiere de un método

expresamente creado para ello:

public boolean validaRUT() {

int numero = this.numero;
boolean validacion = false;
int suma = 0, multiplicador = 2;
for (; numero > 0; numero /= 10) {
suma = suma + numero % 10 * multiplicador;
multiplicador++;
if (multiplicador == 8) multiplicador = 2;
}
suma = 11 – suma % 11;
if (suma == 10) {
validacion = this.digitoVerificador == 'K';
} else {
suma += 48; // carácter '0' tiene código numérico 48.
validacion = this.digitoVerificador == (char) suma;
}
return validacion;
}

Una categoría especial de métodos propios, son los “constructores”, que se

refiere al método que será invocado al hacer la creación de un nuevo objeto de la

clase. Y que en Java se denominan igual que la clase. Su uso fundamental, es

asegurar la consistencia del objeto. Por ejemplo, se define que no puede existir

una persona sin nombre (pero se podría aceptar que la persona no tenga, al

menos temporalmente, un número de RUT). Se debe tener presente que, el

método constructor inicializará los valores de las propiedades a partir de dos

grandes ideas: algunas propiedades se deben definir en función de información

18 Apunte de clase

aportada por parámetros (por ejemplo, el nombre de la persona) y otros serán

definidos en función de código (por ejemplo, se asignará 0 al número de RUT,

hasta que sea invocado el método mutador) en ambos casos, se garantiza la

consistencia de los datos de personas. (Flórez Fernández, 2012) (Flórez, 2012)

De acuerdo a lo anterior, y manteniendo el ejemplo de la clase Persona, se crea

un método denominado Persona, que java identifica como constructor de la clase,

que pide como parámetro el nombre de la persona, y asigna 0 al número de RUT:

public class Persona {

private String nombre;
prívate int numero;
prívate char digitoVerificador;
public Persona(String nombre) {
this.nombre = nombre;
this.numero = 0;
this.digitoVerificador = '?';
}
}

Sin embargo, una clase podría tener más de un constructor, es decir, hay

distintas formas de crear un objeto y a veces es útil asegurar que todas las formas

prácticas estén disponibles, ya que esto simplificará la interfaz con otros objetos.

Para este ejemplo, es posible considerar que la clase Persona también puede

ser creada con un Nombre y un RUT:

public class Persona {

private String nombre;
private int numero;
private char digitoVerificador;
public Persona(String nombre) {
this.nombre = nombre;
this.numero = 0;
this.digitoVerificador = '?';
}
public Persona(String nombre, int numeroRUT, char digitoRUT) {
this.nombre = nombre;
this.numero = numeroRUT;
this.digitoVerificador = digitoRUT;
19 Apunte de clase

}
}

Dos aspectos importantes:

1. Se habrá notado que el método constructor tiene una característica

especial: no devuelve ningún tipo de valor, ni siquiera se utiliza la

definición de “void”. Esto porque el método es usado cuando se crea el

objeto y lo que se está devolviendo realmente, es el objeto mismo:

public class HolaMundo {

public static void main (String[] parametro) {
Persona alumno = new Persona("Juan Pérez");
//. . .
}
}

2. Un segundo aspecto importante, es que habiendo más de un constructor,

lo que los diferencia es el tipo de datos de los parámetros. De esta

forma, Java sabe que si hay un llamado a un nuevo objeto Persona con

un único parámetro de tipo String entonces lo entiende como un llamado

al primer constructor y si es con tres parámetros (un string, un número y

un carácter) lo entiende como llamado al segundo constructor.

Un aspecto relacionado con lo anterior es que NO puede haber dos

constructores que reciban los mismos parámetros. Por ejemplo, no se

podría definir un constructor alternativo, que sólo reciba un String con el

RUT como parámetros (sin nombre), porque en ese caso Java no sabría

a cuál de los dos constructores invocar.

20 Apunte de clase

VIII. Conclusiones

Java es un lenguaje completamente orientado a objetos. Entender su estructura

y el funcionamiento de sus métodos para proveer una adecuada interfaz de

usuario, es importante.

Los métodos permiten mutadores y accesadores permiten independizar la

interfaz de la forma en que se resuelven los problemas.

El poder hacer público el qué, independizándolo del cómo, no sólo es útil, sino

que permite mejorar los algoritmos en la medida que se necesitan, sin tener que

corregir código fuera de ese alcance.

Los métodos constructores, garantizan que los objetos sean consistentes. Pero

para que ello ocurra, es necesario hacer una adecuada definición de la

consistencia. En el ejemplo, se acepta que una persona puede no tener RUT (por

ejemplo, un turista) pero tiene que tener un nombre.

Finalmente, cabe destacar que es posible “sobrecargar” métodos a partir de la

interfaz de estos, es decir, de los parámetros que reciben.

21 Apunte de clase

IX. Bibliografía

Flórez, H. (2012). Programación orientada a objetos usando java. Bogotá, Colombia:

Ecoe Ediciones. Recuperado de

http://ebookcentral.proquest.com/lib/bibliouniaccsp/detail.action?docID=3203026

García, L. (2010). Todo lo básico que debería saber: sobre programación orientada a

objetos en Java. Bogotá, Colombia: Ediciones de la U. Recuperado de

http://ebookcentral.proquest.com/lib/bibliouniaccsp/detail.action?docID=3198642

Perry, J. (2012, 3 de diciembre). Conceptos básicos del lenguaje Java. Recuperadode

http://www.ibm.com/developerworks/ssa/java/tutorials/j-introtojava1/index.html
22 Apunte de clase

Si usted desea referenciar este documento, considere la siguiente

información:

Santibáñez, J. (2018). Fundamentos de Java. Apunte de clase unidad 1,

Lenguajes de Programación, Universidad UNIACC.

23 Apunte de clase