Introducción a la

Programación con JAVA

MSc. Lic. Carla Salazar Serrudo

Carreras de Informática y Sistemas
UMSS - 2020

1
Índice
 Bibliografía
 Introducción
 Algoritmos
 Tipos de datos y operadores
 Control de flujo
 Programación orientada a objetos (POO)
 Arreglos y Cadenas
 Características avanzadas de POO
2
Bibliografía

• Como programar en Java, Prentice-Hall

Hispanoamericana, S.A., Deitel y Deitel (1998)

• [Link]

3
 Introducción

 Computadora
Máquina que procesa datos
 Hardware Equipo
 Software Instrucciones
Copiar
 Programa Cjto. Instrucciones Calcular
Comparar

4
 Hardware

Si puedes tocarlo es hardware

 Dispositivos entrada
 Dispositivos salida
 Unidad de procesamiento
 Memoria y discos
 Tarjetas adicionales
5
 Software
Si no puedes tocarlo es software
 Instrucciones para una computadora
 Ejemplos:
 Sistema operativos
 MSOffice
 Websiss
 Gestores de base de datos
 Gestores de email
6
 La computadora

 Uso de la computadora para resolver

problemas más o menos complejos.
 La computadora realiza operaciones tales
como: aritméticas, comparaciones,
almacenamiento, transferencia de datos,
etc.
 Dichas operaciones se realizan por medio
de instrucciones o comandos.
7
 Instrucción
 Una instrucción es una sentencia u orden
 Las instrucciones pueden ser:
 de entrada de datos (y recuperación)
 operaciones sobre los datos (manipulación)
 de salida (presentación) de resultados y
almacenamiento

8
 Programa
 Un programa es una lista de
instrucciones.
 Un programa es una descripción de
pasos a dar para resolver un problema.
 El programa (software) dirige el
funcionamiento del ordenador
(hardware).

9
 Los algoritmos
 Descripción exacta de la secuencia de pasos
a aplicar para encontrar una solución a un
problema a partir de unos datos.
 Un algoritmo debe ser correcto y completo
 Método de resolución general de un
problema.
 Ej.: receta de cocina (freír papas)

10
Ejercicio algoritmo 1
 Un campesino debe extraer 6 litros de
agua de río, pero al hacerlo se da
cuenta de que solo tiene 2 recipients de
capacidad de 9 y 4 litros. Cómo puede
llevar a cabo su tarea?

11
Solución 1
 Solo 2 medidas
 Balde 9 litros : 0 litros / 9 litros
 Balde 4 litros : 0 / 4 litros
 Solo 2 operaciones
 Vaciar balde
 Llenar balde

12
Solución 1
 B9 B4
1. 0 0
2. 9 0
3. 5 4
4. 5 0
5. 1 4
6. 1 0
7. 0 1
8. 9 1
9. 6 4
10. 6 0 13
Ejercicio algoritmo 2
 En la orilla de un río se encuentra un lobo, un repollo
y una oveja al cuidado de un pastor, quien debe
trasladarlos a la otra orilla del río. Para esto dispone
de un bote con capacidad de para 2 pasajeros, uno
de los cuales deberá ser el propio pastor.
 En ningún momento el pastor puede dejar solos al
lobo y oveja ó a la oveja y repollo, pues el lobo
comería a la oveja o la oveja se comería al repollo.
 Indique cómo debe el pastor realizar los traslados

14
Solución 2
 Izquierdo Derecho
1. LORP -
2. RL PO
3. PRL O
4. L POR
5. LOP R
6. O PLR
7. PO LR
8. - POLR

15
Algoritmo: Cambiar un foco
1. Inicio
2. Conseguir foco bueno
3. Conseguir escalera
4. Subir escalera
5. Desenroscar foco malo
6. Enroscar foco bueno
7. Fin
16
 Programas (1)
 Para programar hay que analizar el
problema y diseñar una estrategia de
resolución.
 Hay que contemplar todas las
alternativas lógicas posibles (no dejar
cabos sueltos).
 Problema  Algoritmo  Programa

17
 Programas (2)
 Un programa es la codificación de un
algoritmo en un lenguaje de
programación concreto.
 Características:
 completo
 correcto
 eficiente
 robusto

18
 Descripción de programas
 Pseudocódigo
 descripción verbal en lenguaje “casi natural”.
 Diagramas de flujo
 descripción gráfica
 cada símbolo representa una acción (entradas,
salidas, procesos, comparaciones...)
 todos los símbolos tienen una flecha de entrada y
otra de salida (al menos), salvo los símbolos inicial
y final.

19
 Ejemplo pseudocódigo
 Ejemplo: sumar dos números
programa Suma
leer(n1)
leer(n2)
suma = n1 + n2
escribir(“suma es ”, suma)
fin

20
Diagramas de flujo

Inicio n1, n2 suma = n1 + n2

Cálculo suma
Entrada
Salida (pantalla)
Fin

21
 Estructuras básicas

ASIGNACION ENTRADA/SALIDA
longitud = 2 * 3.14 * radio leer(edad)
x=x+1 imprimir(valor)

CONDICION
si (edad < 18) entonces
imprimir(“No puedes votar”)
si no
voto = leer(“Elija su voto”)
fin si
22
Programando con Java

MSc. Lic. Carla Salazar Serrudo

Carreras Informática y Sistemas
UMSS - 2020

23
 Características de Java

 Orientado al objeto (tendencia en boga)

 Simple (similar a C, sin complejidades)
 Multiplataforma (Windows, PowerMac, Unix)
 Robusto (hace chequeos, elimina punteros)
 Recolección de basura automática
 Bibliotecas estándares
 Realmente portable en un 100%
 Facilidades para programación en redes

24
 Compilador e intérprete de Java

Salida
[Link] del
[Link]
Prog.

Compilador de Java (específico x plataforma) javac [Link]

Intérprete de Java (específico x plataforma) java P1 (class)

25
 Compilador e intérprete
 El compilador analiza la sintaxis del
código fuente (con extensión .java). Si
no hay errores, genera bytecodes
 > javac [Link]
 El intérprete es la Máquina Virtual Java
que ejecuta los bytecodes (con
extensión .class) creados por el
compilador
 > java P1
26
 Un primer programa en Java
public class Ejemplo {
public static void main(String args[ ])
{
[Link](“Introducción a
la Programación con Java”);
}
}

27
Un primer programa en Java (2)
 Todo programa se escribe en el método
estático llamado main en una clase cualquiera
 Este método se empieza a ejecutar cuando se
invoca el intérprete de Java para una clase
dada
 args es un arreglo de Strings que contiene los
parámetros con los que fue invocado el
programa

28
Estructura de un programa
// Este es el esqueleto de un programa en Java

class <nombre del Programa>

Se utiliza para abrir
{ un bloque de
instrucciones.
/* Definiciones globales*/

/* Metodo Principal*/

/* Otros Métodos*/
Se utiliza para
} cerrar un bloque
de instrucciones
29
Comentarios
Si sólo quiero comentario de una línea coloco // al inicio de esta

// Este es el esqueleto de un programa en Java

class <nombre del Programa>

{
Si quiero comentario de más de una línea
/* Definiciones globales*/
coloco /* al inicio del comentario y */ al final
/* Este es el
Método Principal*/

/* Otros Métodos*/

30
 Variables y métodos
class <nombre del Programa> Deben seguir las
{ convenciones utilizadas en
algoritmo.

/* Definiciones globales*/
Aquí se definen las variables que yo
deseo que se puedan utilizar en todo
mi programa.
/* Método Principal*/

Cada aplicación de Java debe tener

un método principal llamado
/* Otros Métodos*/ main, que define donde comienza el
flujo del programa.
}

31
 Sintaxis del método main
// Este es el esqueleto de un programa en Java
class <nombre del Programa>
{
/* Definiciones globales*/
Todo el código de un
método estará entre la llave
public static void main (String args[]) de apertura
{ ( { ) y la correspondiente
llave de cierre ( } ).
/* Definiciones locales*/
...
...
/* cuerpo de instrucciones */
...
...

}
}
32
 Sintaxis del método main
La palabra public es un especificador de
acceso. En este caso el main debe ser
// Este es el esqueleto de un programa en Java declarado public ya que es llamado por
class <nombre del Programa> código que está fuera de su clase, cuando el
{
/* Definiciones globales*/
programa comienza.

public static void main (String args[])

La palabra static permite que main sea
{ llamado por el intérprete de Java antes de
que se cree cualquier objeto .
/* Definiciones locales*/
...
La palabra void indica al compilador que
...
/* cuerpo de instrucciones */ main no devuelve ningún valor.
...
...
} String args[], declara una variable args que
} es una especie de vector que puede contener
cadenas de caracteres.
33
 Sintaxis del método main
// Este es el esqueleto de un programa en Java
class <nombre del Programa>
{
/* Definiciones globales*/

public static void main (String args[])

{ Aquí se definen las variables que
solo voy a utilizar en el método
principal.
/* Definiciones locales*/
...
...
/* cuerpo de instrucciones */
Después de cada instrucción se coloca ;
...
...
}
}
34
 Identificadores
 Nombran variables, funciones, clases y
objetos
 Comienza con una letra, un subrayado (_) o
un símbolo de dólar ($). Los siguientes
caracteres pueden ser letras o dígitos
 No se permiten vocales acentuadas ni ñ
 Se distinguen las mayúsculas de las
minúsculas
35
 Identificadores (2)

 No tienen longitud máxima

 La forma básica de una declaración de
variable, por ejemplo, sería:
 tipo identificador [ = valor]
[,identificador [= valor] ...];

 Ejemplo de constante:
 final double PI = 3.14159;

36
 Identificadores (3)
No existen reglas, pero es conveniente seguir unas
normas para que el código sea más legible:
 nombre de CLASE empieza por Mayúsculas

 nombre de MÉTODOS y ATRIBUTOS por

minúsculas
 las CONSTANTES con mayúsculas completamente

 cuando empieza una nueva palabra la ponemos

en mayúsculas ej: dibujarRectangulo

37
 Variables y constantes
 Variables: zona de memoria cuyos
valores van a cambiar durante la
ejecución
 Ej: int x, y, z;
 Constantes: zona de memoria cuyos
valores no cambian
 Ej: final double PI = 3.14159265;

38
Tipos de datos
 En Java existen dos tipos de datos:
 Tipos primitivos
 Tipos referencia
 Los tipos primitivos son:
 Lógico (boolean), texto (char), entero
(byte, short, int, long) y real (float, double)
 Los tipos referencia son punteros a
objetos

39
 Tipos primitivos de datos
 El tipo de un objeto determina cuánto espacio
ocupa en memoria y cómo puede ser usado
 Los tipos de datos primitivos en Java son:

 byte, short, int, long enteros

 float, double números punto flotante
 char caracter
 boolean valores lógicos

40
 Enteros

 Los tipos de datos enteros pueden ser: byte,

short, int y long
 Todos los tipos tienen signo. El cero se considera
positivo.
 Los enteros se representan así:
 Decimal: 2, 156, 564545
 Octal: 077, 077700 (empiezan con cero)
 Hexadecimal: 0xABFF, 0xCC00 (empiezan con 0x)
 Long: 156L
41
 Punto flotante
 Existen dos tipos de datos reales: float
(32 bits) y double (64 bits)
 Un número es de punto flotante si lleva:
 Un punto decimal: 3.14159, 2.0
 Una E o e (valor exponencial): 105e25,
1.05E27
 Una F o f (float): 279F, 2.79f
 Una D o d (double): 279D, 2.79d
42
 Caracteres y valores lógicos
 El tipo de datos boolean (8 bits) puede tomar
dos valores posibles: true y false.
 El tipo boolean no toma valores numéricos
 El tipo char (16 bits) representa sólo un
carácter Unicode (caracteres gráficos de
todos los idiomas).
 Caracteres simples: ‘a’
 Caracteres especiales: ‘\t’, `\n`
 Caracteres Unicode: `\u00BF`

43
 Tipos de datos primitivos

Valor por defecto

Tipo Valores
(atributos de la clase )
boolean false true o false
char ‘\u0000’ (null) ‘\u0000’ a ‘\uFFFF’
byte (byte) 0 -128 a +127
short (short) 0 -32,768 a +32,767
int 0 -2,147,483,648 a +2,147,483,647
long 0L -9,223,372,036,854,775,808 a
+9,223,372,036,854,775,807
float 0.0f -3.40292347E+38 a
+3.40292347E+38
double 0.0d -1.79769313486231570E+308 a
+1.79769313486231570E+308

44
 Declaraciones de variables
int i, k;
int j = 1, x;
double pi = 3.14159;
char c = ‘a’;
boolean somosFelices = true;
String email = “jorge123@[Link]”
 Las declaraciones de variables pueden ir en
cualquier parte del programa, pero siempre
antes de que la variable sea usada.
45
Declaración de variables
/* Este programa declara algunas variables */
class declaraVar {
public static void main (String args[])
{
int x, y = 1;
double w =8.4445;
boolean bandera = true;
char c = ´A´;
String st1 =“María”;
}
}

46
 Asignación de valores a
variables
• Se puede dar valores a las variables en el
momento de su declaración
• O en una instrucción de asignación
independiente una vez que ha sido declarada
•Se utiliza el signo = en ambos casos. Ej:
int x =5;
boolean t;
t = true;

47
 Asignación de valores a
variables
 Las asignaciones también pueden ser
expresiones
 Ejemplo:
monto = pvp * cantidad ;
 Donde pvp y cantidad deberán ser

variables anteriormente declaradas y con

valor previo asignado

48
 Asignación de valores a
variables (2)
/* Este programa asigna valores a variables */
class AsignaValorVar {
public static void main (String args[])
{
int x, y, z;
x = 2;
y = 4;
z = x * y;
[Link](“El valor de z es “ + z);
}
}
49
 Asignación de valores a
variables (3)
Algunas de las operaciones a utilizar en la asignación:

() indica prioridad de ejecución

* multiplicación
/ división decimal
+,- suma, resta

Ejemplo:
impuesto = ( (pvp * cantidad) * porc) ) / 100;

50
 Expresiones y asignación

 Aritméticas:
 suma + 20 * c / (mod % 3)
 Relacionales:
 a > b, b >= c, c != 4, a == 0
 Lógicas:
 true && false, a || b, !true
 Cadenas:
 “hola “+ nombre + “ hoy es “+ dia + “de”+mes3

51
 Expresiones y asignación (2)

 Asignación:
 a = 1;
 Asignación como operador:
 a = b = c = d = 0;
 boolean cero = ( b = c - 10) == 0;
 Otros:
 a == 1 ? a+1 : a-1

52
 Operadores
Operadores Asociatividad Tipo

() izquierda a derecha paréntesis

++ -- + - ! derecha a izquierda unarios
* / % izquierda a derecha multiplicativos
+ - izquierda a derecha aditivos
< <= > >= izquierda a derecha relacionales
== != izquierda a derecha de igualdad
&& izquierda a derecha AND lógico
|| izquierda a derecha OR lógico
= += -= *= /= %= derecha a izquierda asignación
ej. x += y  x = x + y;

53
 Conversiones de tipo

 Java no reclama si un tipo de menor rango se

convierte a uno de mayor rango.

byte < short < int < long < float < double

 int i = 1;
 long l = i; //ok
 CAST:
 (int) ([Link]()*100)+1)
54
 Ejemplos

 l = 1000000000000;
 float f = l; //ok
 double d= 1.0e24;
 int i = d; // Error
 float f = 1.0f;
 int i = f; // Error
 short s = i; //Error
55
 Ejemplos (2)

 double d = 1.0;
int i = (int)d; //ok
 int i = 256;
 byte b = (byte)i; /*ok pero
b ==0 */

56
 Salida de datos
 Para mostrar un texto por pantalla se usan
las siguientes instrucciones:
• [Link] (texto);
• [Link] (texto);

 La primera imprime “texto” en la pantalla y

deja el cursor en la siguiente línea
 La segunda imprime “texto” en la pantalla y
deja el cursor inmediatamente después de
texto.

57
 Lectura de datos

 Para obtener los valores de las variables desde

teclado, usamos la librería Scanner:
 import [Link];
Scanner lector = new Scanner([Link]) ;
Ejemplos:
int numero1 = [Link]();
double numero2 = [Link]();
String nombre = [Link]();
char estadoCivil = [Link]().charAt(0);
58
 Ejemplo de programa (1)

// Programa que lee dos números y los suma

import [Link];
class Sumar {
public static void main (String args[]){
Scanner lector = new Scanner([Link]);
int v1, v2;
[Link]("Introduzca v1");
v1 = [Link]();
[Link]("Introduzca v2");
v2 = [Link]();
[Link](“Suma es: "+ (v1+v2));
}
}

59
 Ejemplo de programa (2)

// Programa que calcula área de un círculo

import [Link];
class AreaCirculo {
public static void main (String args[]){
Scanner lector = new Scanner([Link]);
int radio;
double área;
[Link]("Introduzca radio");
radio = [Link]();
area = [Link] * radio * radio;
[Link](“área es” + area);
}
}

60
 Programación estructurada
 Simplifica la estructura de un programa
 Reduce las opciones y facilita la legibilidad de los
programas
 Estructuras tienen:
 Un punto de entrada y
?
 Un punto de salida

 Permite estructuras anidadas

 Focaliza la atención en un punto cada vez

61
 Agrupación de sentencias
 Donde se puede escribir una sentencia,
se puede escribir un grupo de
sentencias agrupadas dentro de llaves

 sentencia //simple

{sentencia;
sentencia; …;
sentencia;} //compuesta

62
 ; es un terminador
 Toda sentencia en Java debe terminar con
un ;
 Existe la sentencia vacía, por lo cual podemos
poner varios ; seguidos ;;;;;
 Algunas estructuras como switch no van
seguidas de ;

63
 Programación estructurada
 Estructura secuencial
 acción1; acción2; acción3;
 Estructuras condicionales
 if (condición) acción1 [else acción2]
 switch (selector) {case valor1; acción1;
case valor2; acción2; … ;
case valorn: acciónN}
 Estructuras repetitivas
 while (condición) acción;
 do {acción} while condición;
 for (inicialización; condición; actualización) acción;

64
Estructuras de control
 A veces es necesario alterar el orden en
que se ejecutan las instrucciones de un
programa.
 Las estructuras de control son:
 Estructuras de selección: Permiten
seleccionar entre un conjunto de
instrucciones y otro.
 Estructuras de repetición: Permiten repetir
un conjunto de instrucciones.
65
Estructura condicional
if (condición) {
condición acción1;
True }else {
False
acción2;
}
acción2 acción1

66
 Estructuras condicionales
 De acuerdo al resultado de la evaluación de una
condición se realiza una acción u otra
 Sintaxis:
 if (condición) acción;

 if (condición) {acción1; acción 2;…;acciónN}

 if (condición) acción1 else acción2;

 if (condición) {acción1; …;acciónN}

else{acción21; ..;acción2N}

67
 Ejemplo de condicional
…
if(calif >= 70)
[Link](“Aprobado”);
else {
[Link](“Reprobado”);
[Link](“Cursar de nuevo materia”);
}
…

68
 Raíces ecuación segundo grado
class Raices2g {
...
D=(b*b) - (4*a*c);
if (D>=0) { // raices reales
x1=((-b)+[Link](D))/2*a;
x2=((-b)-[Link](D))/2*a;
[Link]("x1= "+x1);
[Link]("x2= "+x2);}
else {//soluciones imaginarias
r = -b/(2*a);
i = ([Link](-D)/2*a);
[Link]("x1= "+r+" + "+i+"i");
[Link]("x2= "+r+" - "+i+"i");}
... 69
Condiciones anidadas
if (calif>=90)
[Link](“A”)
else if (calif>=80)
[Link](“B”)
else if (calif >= 70)
[Link](“C”)…

70
Ejemplo condicionales anidados
{
int mes;
if (mes==1) [Link] println (“Enero”);
else if (mes == 2) [Link] (“ Febrero”);
...
else if (mes == 12) [Link] (“Diciembre”)
else [Link] (“ Error”);
...
}

71
 Condicionales anidados
 Muchos if anidados dificultan la comprensión
del programa
 Problemas de ambigüedad en el anidamiento
de ifs:
if (C1) if (C1)
if (C2) acción1 if ( C2) acción1
else acción2 else acción2

72
 Condicionales anidados
 El compilador de Java siempre asocia un else con el if
más cercano:
if (condición1) acción;
if (condición2) acción2;
else acción 3;
 Para cambiar esta regla debemos usar llaves
if (condición1) {acción1;
if(condicion2) accion2;
} else acción3;

73
 Ejecución if-else
if (p) Ejecución
a; Condiciones instrucciones
else { p q
b; V V a
if (q) V F a
c; F V b, c
else F F b, d
d;
}

74
Ejecución if-else (2)
if (p) {
a; Ejecución
if (q) Condiciones instrucciones
b; p q r
else
c; V V -- a, b, d
d; V F -- a, c, d
} else { F -- V e, f, h
e;
if ( r ) F -- F e, g, h
f;
else
g;
h;
} 75
Sentencia switch
 Caso general de if
 switch (selector) {
case valor1: acción1;
case valor2: acción2;
…;
case valorn: acciónN;
[default : acciónM] }
76
Sentencia switch
int llave;  llave puede ser de tipo
......  byte, char, short, int,
switch (llave) {
case 3 : ......
long
break;  Ejecuta a partir del case
case 2: ...... que cumpla.
break;
 llave == valor
......
case <valor>: .......  Hay que insertar break
break; para no ejecutar los
default:......
break;
siguientes casos
}...  El default es opcional
77
 Sentencia switch: case
 El selector debe ser un valor constante
 case 2

 case 1+1

 case uno + 1 // uno constante entera que vale 1

 Se pueden poner varios cases juntos:

 case ‘d’: case ‘D’

 se ejecutan las sentencias asociadas si la

expresión de control coincide con alguna de los

valores del case

78
 Sentencia switch: case (2)
 El último case no necesita break, pero se
suele poner por simetría y claridad
 Si se escribe más de una sentencia, no se
necesitan escribirlas entre llaves ({})
 Si escribimos dos case con el mismo valor
de selector, se produce un error en tiempo
de compilación

79
Calculadora
//Calculadora
import [Link];
class Calculadora {
public static void main (String args[]) {
Scanner lector = new Scanner ([Link]);
char operador;
int n1,n2, resultado;

n1= [Link]();
operador= [Link]().charAt(0);
n2= [Link]();
...
80
Calculadora (2)
switch (operador) {
case ‘+’: resultado= n1 + n2;
break;
case ‘-’: resultado= n1- n2;
break;
case’/’: resultado= n1/n2;
break;
default: resultado=0;
}
[Link] (“->” + resultado);
}
}
81
Estructuras repetitivas
 Permiten la ejecución repetida de un
grupo de sentencias
 Pueden ser:
 while (condición) acción;
 do acción while (condición);
 for (inicialización; condición;
actualización)

82
Estructura while

True
condición acción

False
while (condición) {
acción;
}

83
 Uso de while
//ejemplo simple de while con contador

public class ejemplo {

public static void main(String args[ ]) {

int x = 1;
inicialización
while (x <= 3) {
condición
[Link](“valor es: “ + x)
x = x + 1;
} actualización
int a = -1;
} 84
 Ejemplo while
public class MCD {
//calculo del maximo comun divisor entre 15 y 24
public static void main(String args[ ]) {
int x = 15, y = 24;
while (x != y) {
if (x < y)
y = y - x;
else
x = x - y;
}
[Link](“MCD entre 15 y 24 es “ + x);
}
}

85
Estructura do-while

True

acción do {
acción;
} while (condición);

condición

False
86
 Ej: constante de Euler
// Constante de Euler
class Euler {
public static void main (String arg[]) {
int i;
double e, ei;
i=0; ei=1;
e= ei;
do {
i++;
ei= ei/i; // real / entero -> real
e=e+ei;
[Link] (“e=” + e);
} while (ei> [Link](1, -10));
}
}
87
Estructura for

Inicialización

condición acción actualización

True

False
88
 Estructura for
 for(inicialización; condición; actualización) {
acción;}
 inicialización: se pueden inicializar, e incluso declarar,
cualquier número de variables
 condición: si es verdad se sigue el ciclo (bucle)
 actualización: actualiza varias variables (modifica
valor)
for(int i=0; i<10; i++) {[Link](i);}

for(int i=1, j=2 (j<10)&&(i>2); i++, j=j+i) acción;

89
Ejemplos
 i=1; while (i<=10) {[Link](i); i= i+1}
 i=1; do {System,[Link](i); i: =i+1}
while(i<=10);

 for (i=0; i <=10; i =i +5) {[Link] (i);

}

Ejemplo: cálculo del factorial de un número entero

 fact= 1; for(i= n; i >= 1; i--) {fact = fact *i;}

90
Elección de estructura
 Si 1 ó más veces, elegir do { } while ();
 Si 0 ó más veces, elegir while () {}
 Si número fijo de veces, elegir for

 Aunque en realidad todo se puede escribir

con for´s y resulta más cómodo y
compacto.

91
Programación orientada a
objetos

MSc. Lic. Carla Salazar Serrudo

Carreras de Informática y Sistemas
UMSS - 2020

92
 Orientación a Objetos

 El concepto surge en los lenguajes de

programación
 Se organiza el software como una colección
de objetos discretos que encapsulan datos y
comportamiento.
 Un programa orientado a objetos funciona
mediante la colaboración entre los objetos
que se comunican entre sí

93
 Orientación a Objetos (2)

 El concepto se extiende a los métodos de

análisis y diseño
 Se utilizan los objetos del mundo real como
base para construir modelos
 Los elementos que forman los sistemas del
mundo real se corresponden con objetos
software

94
Conceptos POO
 Clases: patrones que indican cómo
construir los objetos
 Objetos: instancias de las clases en
tiempo de ejecución
 Ej: plano de un casa vs casa hecha
 Miembros de una clase:
 Atributos: propiedades de los objetos
 Métodos: comportamiento de los objetos

95
 Clases y objetos Lavadora
marca
 Clase modelo
capacidad: integer
 Atributos ...
 Operaciones Programar()
PonerRopa()
CerrarPuerta()
 Objeto Lavar(...)

 Valores de los atributos

ID:Lavadora
 Estado
 Identidad marca=“Lapava”
 Comportamiento invocable capacidad=5
estado=centrifugando

96
Clases y objetos (2)

97
Clases y objetos (3)

98
Atributos
 Son características de los objetos
 Se representan con variables tipadas
 Ejemplo:
 String color;
 color = “rojo”;
 int velocidad;
 velocidad = 280;

99
 Métodos
 Los métodos son bloques de código
(subprogramas) definidos dentro de una
clase
 Un método tiene acceso a todos los
atributos de su clase
 Pueden ser llamados desde cualquier
sitio.
 Todos los programas se inician main
100
 Definición de métodos
<tipoRetorno> <nombreMétodo> (<lista de
argumentos>) {
<bloqueCódigo>
}
 <TipoRetorno>: Tipo de dato que retorna el

método. Puede ser primitivo o referencia. Sino

devuelve valor, debe ser void

 <lista de argumentos>: Argumentos

separados por comas: (tipo1 var, tipo2 var2, ...)
101
Definición de métodos (2)
 <bloqueCódigo> : Conjunto de sentencias que
implementan la tarea que debe realizar el método
 Si devuelve un valor, se debe usar la sentencia
return:
 return <valor>

 <valor>: Debe ser del mismo <tipoRetorno>

con que se ha declarado el método.
 Si se necesitan, se pueden declarar variables locales

102
Ejemplos
double areaCirculo(double r) {
return r*r*[Link];
}
void imprimirHola() {
[Link](“hola”);
}
String horaFormato(int h, int m){
return h+ “:”+ m;
}

103
Paso de argumentos
 En Java solo existe el paso de
argumentos por valor
 El método recibe una copia de los
argumentos
 El valor de los argumentos de tipo
primitivo no cambia fuera del método
 El valor de los argumentos de tipo
referencia no cambia fuera del método

104
Ejemplo método en una clase
class Numero{
public static void main (String arg[]){
int n = 3;
int resultado = factorial (n);
[Link](“factorial es:” + resultado);
}
public static int factorial (int x) {
int i, f= 1;
for (i = 1; i <= x; i++)
f = f* i;
return f;
}
}
105
NroCombinatorio: n!/(k!*(n-k)!)
class NumeroCombinatorio {
public static void main (String arg[]){
int n, k; n = 3; k= 2; // n >k
int nc = factorial (n) /(factorial (k) * factorial (n-k));
[Link](“factorial es:” + resultado);
}
public static int factorial (int x) {
int i, f= 1;
for (i = 1; i <= x; i++)
f = f* i;
return f; }
}
106
Ejemplo métodos (2)
class MCD{
public static void main (String arg[]){
int a = 30; int b = 25;
int resultado = mcd (a, b);
[Link](“mcd es:” +resultado);
}
public static int mcd(int x, int y) {
while (x != y) {
if ( x > y)
x = x – y;
else
y = y – x;
}
return x; }
} 107
Ámbito de las variables
 Se disponen de tres tipos de variables:
 Variables miembro pertenecientes a una
clase
 Argumentos de un método de la clase
 Variables locales de un método de la clase
 Los argumentos de un método
funcionan como variables locales

108
Ejemplo
class AmbitoVar {
int x; //variable miembro

void metodo1( int y) {//argumento

int z; // variable local
x = y + z;
}
}

109
Ámbito de variables (2)
 Las variables miembro son visibles desde
cualquier parte de la clase
 Los argumentos y variables locales sólo son
visibles dentro del método al que pertenecen.
Dejan de existir al terminar el método.
 Dentro de un método, si coincide el
identificador de un argumento o variable local
con el de una variable miembro, sólo se
accede a la variable del método
110
Puntero this
 Se usa para apuntar al objeto actual
dentro de un método
 Con this se hace accesible una variable
miembro cuyo identificador coincide con
una variable local

111
Ejemplo
main ... {
int a=4; EjThis obj = new EjThis();
obj.x = 1;
[Link](a);
...
}
class EjThis {
int x;
void metodo (int y) {
int x=2;
y = 3*this.x + y – x;
[Link](y) // y = 5 }
}
112
Conceptos POO (2)
 Cada objeto tiene características
reconocibles
 Un empleado tiene CI, nombre, sueldo, ...
 Cada objeto es único:
 El empleado1 es Juan Pérez con CI 335566
y sueldo 3000 Bs.
 Los objetos realizan operaciones sobre
sus atributos

113
Ejemplo clase y objeto

Empleado
Clase
int CI= 336655
Atributos
Métodos MostrarCI();
MostrarNombre();

114
Sintaxis de clase

class < NombreClase> {

// declaración de atributos
<tipo> <variable>;
// declaración de métodos
<tipo> <nombreMétodo>(<argumentos>)
{ ... }
}

115
Sintaxis de clase (2)
 El nombre del fichero Java debe
coincidir con el de la clase definida en
él. Ej: [Link]
 Es recomendable definir una clase por
cada fichero Java

116
Ejemplo de clase
class Hora {
// atributos
int hora, min, seg;
// métodos
void asignarHora (int h){
if (h >= 0 && h <= 23)
hora = h;
else hora = 0;}
int mostrarHora() {
return hora; }
… 117
 Ejemplo de clase (2)
void asignarMinuto(int m){
if (m >= 0 && m <= 59)
min = m;
else min = 0;}
int mostrarMinuto() {
return min; }
void mostrar() {
[Link](hora + “:”+ min);
}
} // fin clase Hora
118
Creación de un objeto
 Se utiliza la palabra reservada new
 <refObjeto> = new <NombreClase>();
 Ejemplo:
Hora clases;
clases = new Hora();

hora 0xFF000000
min clases
seg
119
Acceso a los miembros de un
objeto
 Usando el operador punto (.) se puede
acceder a los atributos y a los métodos
 <refObjeto>.<atributo>
 <refObjeto>.<método>()
 Ejemplo:
 Hora clases = new Hora();
 [Link] = 14;
 [Link] = 15;
 [Link](11)

120
Ejemplo creación objeto

class Principal {
public static void main (String arg[]) {
Hora clases; //declaración
clases = new Hora (); //creación OO
[Link](5);
[Link](15);
[Link]();
}
}

121
Sobrecarga de métodos
 Varios métodos con la misma tarea,
pero diferentes argumentos.
 Un método se identifica por su nombre,
tipo de retorno, número de argumentos
que tiene y el tipo de cada uno de ellos.
 void mostrarInt(int i) void mostrar(int i)
 void mostrarLong(long l) void mostrar(long l)
 void mostrarFloat(float f) void mostrar(float f)

122
Constructores
 Un constructor es un tipo especial de
método que permite construir una
objeto de una clase
class Hora {
...
public Hora() {...}
public Hora(int h, int m, int s)
{...}

123
Constructores (2)
 Los constructores no tienen tipo de
retorno.
 Se usan con la palabra reservada new
Hora clase = new Hora(14, 15, 0);
 Se pueden sobrecargar y son opcionales
 En el constructor se inicializan variables
miembro

124
Ejemplo constructores
class Hora {
int hora, min;
public Hora(){
asignarHora(0);
asignarMinuto(0);
}
public Hora(int h, int m){
asignarHora(h);
asignarMinuto(m);
}
…

125
Destructores
 No existen destructores de objetos en
Java
 El garbage collector es el que libera la
memoria de objetos

126
Paso de mensajes
 Invocación de métodos
 Medio de colaboración entre objetos
 Ej: un objeto mando a distancia
puede encender un televisor.
También puede sintonizar canales
Conectar()

:MandoADistancia :Televisor
Canal(4)

127
Ejemplo paso mensajes

class Principal {
public static void main (String arg[]) {
Hora clases; //declaración
clases = new Hora (); //creación OO
[Link](5);
[Link](15);
[Link]();
}
}

128
 Ejemplo mínimo de POO
class MinimoPOO {
public static void main (String args[])
{
Pizarra x = new Pizarra();
[Link]();
}
}
class Pizarra {
public void mostrar(){
[Link](“Ejemplo objeto”);
}
}

129
Ejercicio
 Hacer clase Estudiante con atributo
“nota” y sus métodos correspondientes.
 Y luego hacer la clase Curso que tenga
3 estudiantes y se puedan mostrar sus
notas.

130
Arreglos
 Los estructuras de memoria que
almacenan en una variable múltiples
valores del mismo tipo.
 Los arreglos son objetos, se crean con
la palabra new
 Se usan corchetes [] para declarar el
arreglo y para acceder a sus elementos

131
 Arreglos (2)

 Se puede averiguar el largo de un arreglo:

 int largo = [Link];
 length es un campo del objeto arreglo y no
un método.
 El primer elemento del arreglo está en la
posición 0 y el último en la posición length-1
 Se puede asignar un arreglo a otro

132
 Arreglos(3)
 Declaración:
tipoDeElementos[] nombreDelArreglo = new
tipoDeElementos[tamañoDelArreglo];
 Creación:
 un arreglo vacío:
int []lista = new int[50];
 con valores iniciales:
String [] nombres = {
"Juan","Pepe","Pedro"};
133
 Arreglos (4)

 Se pueden declarar como:

 int[] A; int A[];
Esto es la declaración del puntero al
arreglo, no se especifica tamaño en la
declaración;
 Inicialización:
 A = new int[10];
 int[] A = new int[10];

134
Ejemplos
 int [] digitosPares = {0,2,4,6,8}
 String [] dias = {“lunes”, “martes”,
“miércoles”, “jueves” ,“viernes”, “sábado”,
“domingo” }
 Hora [] clases = {new Hora(8,15),
new Hora(9,45), new Hora(11,15),
new Hora(14,15) }
 Recorrido:
 for (int i=0; i < [Link], i++)
[Link](dias[i]);

135
 Llenado de un arreglo
int lista[]; // declaración
lista = new int[3]; // construcción
lista[0] = [Link]();
lista[1] = -1;
lista[2] = 30;

[Link] (lista [0]);

[Link] (lista [1]);
[Link] (lista [2]);

136
Lectura e impresión arreglos
for (int i=0; i < [Link]; i++){
[Link](“ingrese dato:” +i);
lista[i]= [Link]();
}
//impresión
for (int i=0; i < [Link]; i++)
[Link](lista[i]);

137
Búsqueda
//Dado un arreglo lleno
lista = {9, 35, 41, 7, 20, 15};
// y se desea buscar k
// si k=20 => encontrado
// si k= 13 => no existe

138
 Búsqueda secuencial
// recorrer el arreglo hasta encontrar el
elemento k
int k = [Link](); // clave
boolean encontrado = false;
for (i = 0; i<[Link]; i++) {
if (lista[i] == k){
encontrado = true;
i = [Link] + 1; } }
if (encontrado)
[Link] (“encontrado”);
else
[Link] (“no existe”);
139
 Ordenamiento
//Dado un arreglo lleno
lista = {9, 35, 41, 7, 20, 15};

// resultado debería ser:

lista = {7, 9, 15, 20, 35, 41};

140
 Ordenamiento burbuja
// dado un arreglo lista[n] lleno
for (i = 0; i< ([Link]-1); i++)
for (j = i+1; j<[Link]; j++)
if (lista[j] < lista[i]){
aux = lista[j];
lista[j] = lista[i];
lista[i] = aux;
}
// impresión del arreglo ordenado
for (i = 0; i< [Link]; i++)
[Link](lista[i]+ “, ”);
141
 Intercalación simple
//Dados dos arreglos
A1 = {9, 35, 41};
A2 = {7, 20, 25};
// resultado debería ser:
A3 = {9, 7, 35, 20, 41, 25}

142
… continuación
int A1[] = { 9, 35, 41 };
int A2[] = {7, 20, 25 };
int A3[] = new int [6];
int i, j;
j = 0;

for (i = 0; i<[Link]; i++){

A3[j] = A1[i] )
j++;
A3[j] = A2[i] )
j++;
}
143
Intercalación ordenada
//Dados dos arreglos ordenados
A1 = {9, 35, 41}; //i
A2 = {7, 20, 25, 43}; // j
// resultado debería ser:

A3 = {7, 9, 20,25, 35, 41, 43} //k

144
Arreglos multidimensionales
 Los arreglos anteriores eran de una sola
dimensión
 Para tener más dimensiones se necesita
un par de corchetes para cada
dimensión.
 int [] unAño = new int [12]
 int [][] tresAños = new int[3] [12]
 // tresAños es un arreglo de tres
elementos, donde cada elemento es un
arreglo de dimensión 12.
145
Arreglos multidimensionales
 Inicialización:
int [][] matriz = new int [2][3];
matriz[0][0]= 1;
matriz[0][1]= 2;
matriz[0][2]= 3;
matriz[1][0]= 4;
matriz[1][1]= 5;
matriz[1][2]= 6;
 Equivalente a:
int [][] matriz = {{1,2,3},
{4,5,6}};

146
 Clase Math
 La clase Math de Java provee de los métodos
matemáticos típicos:
 [Link](x)
 [Link](x)
 [Link](x,y)
 [Link](x,y)
 [Link] // constante PI
 Math.E // constante E
 No es necesario importarla, está disponible
147
 Clase String

 Permite el manejo de cadenas

 No es necesario importarla, está
disponible
 Creación
 String s = new String(“Hola Mundo”);
 String s = “Hola Mundo”;
 Tamaño de un String:
 int i = [Link]();
148
 Clase String(2)

 k-esimo carácter:
 char c = [Link](k)
 Subsecuencias:
 String sub = [Link](k)
 String sub = [Link](inicio, fin)
 Búsqueda de subsecuencias:
 int i = [Link](“hola”);

149
 Clase String(3)

 Comparación:
 boolean iguales = [Link](s2);
 int i = [Link](s2);
//0 si s1==s2, >0 si s1>s2, <0 si s1<s2

150
 Ejemplo de substrings
//Contar las apariciones de “hola” en string s:

public class Cuenta {

public static void main(String args[]) {
int i , apariciones = 0;
String s = “llego y dijo hola”;
while ((i = [Link](“hola”)) != -1) {
++apariciones;
s = [Link](i+1);
}
[Link](“hola aparecio “+
apariciones+ “veces”);
}
}

151
Características avanzadas POO
 Existen tres conceptos avanzados:
 Encapsulación: Permite la protección de ciertas
partes de un objeto del acceso desde otros
objetos externos
 Herencia: Jerarquía de clases basada en la
agrupación de atributos y métodos comunes
 Polimorfismo: Tratamiento generalizado de
todas las clases pertenecientes a una jerarquía de
herencia

152
Encapsulación
 Consiste en el agrupamiento de datos y
su tratamiento en una misma estructura
 Permite la protección de la
manipulación externa de algunas partes
de los objetos
 Un objeto puede tener datos y código
privados de acceso restringido

153
Encapsulación(2)
 Fuerza al usuario a usar una interfaz
para acceder a los datos.
 Hace que el código sea más fácil de
mantener.
 Se tienen modificadores de acceso para
proteger los miembros de un objeto

154
Modificadores para restringir
acceso
 Los modificadores se colocan al
principio del miembro
 [<modificador>] <tipo> <identificador>
 [<modificador>] <tipo> <nombre> (<arg>)
{ ... }
 Los modificadores permiten acceder a
los datos o al código de manera
restringida

155
 Modificadores de acceso
 public: Un miembro con acceso público es
accesible para todos los métodos del programa.
Los miembros públicos son heredados a las
subclases.
 private: Un miembro con acceso privado es
accesible sólo para todos los métodos de la
clase. No se heredan.
 protected: Un miembro con acceso
protegido es accesible por todos los métodos del
paquete. Se heredan.
156
Ejemplo
class Hora {
public int hora;
public int min;
public int seg;
}
...
Hora h = new Hora();
[Link] = 25; // valores incorrectos
[Link] = 61;
[Link] = 100;
...

157
Ejemplo (2) // correcto OO
class Hora {
private int hora;
private int min;
private int seg;
}
...
Hora h = new Hora();
[Link] = 25; // ERROR
[Link] = 61; // ERROR
[Link] = 100; // ERROR
int h1;
h1 = [Link]; // ERROR
}
158
Ejemplo (3)
class Hora {
private int hora;
private int min;
private int seg;
public void setHora(int h){
if (h>=0) && (h<=23)
hora = h;
}
public int getHora(){
return hora;
}
}
...
Hora h = new Hora();
[Link](25); [Link]();
}
159
Clase Fracción
class Fraccion {
private int num;
private int den;

public Fraccion (int n, int d){

setNum(n);
setDen(d);
}
public void setNum(int n){
num = n;}
public int getNum(){
return num;}
160
… continuación (2)
public void setDen(int d){
if (d != 0)
den = d;
else
den = 1; }
public int getDen(){
return den;}

public void mostrar() {

[Link](num + “/” + den);
}

161
… continuación (3)
public Fraccion multiplica(Fraccion x) {
int n,d;
Fraccion fm;
n = num * [Link]();
d = den * [Link]();
fm = new Fraccion (n, d);
[Link]();
return fm;
}
} // fin class

162
Herencia
 Jerarquía de clases basada en agrupar
atributos y/o métodos comunes
 Ej: una lavadora, televisor y plancha
son electrodomésticos
 Las clases descendientes se llaman
subclases
 Las clases ascendientes se llaman
superclases

163
Ejemplo
 Las subclases heredan características y
métodos de las superclases (excepto
constructores)
Electrodoméstico
tensión
consumo
Conectar
Desconectar

Lavadora Televisor Plancha

capacidad numCanales vapor

164
Ejemplo (2)
 Las partes comunes de lavadora,
televisor y plancha se agrupan en una
clase llamada electrodoméstico.
 Las partes no comunes pertenecen a
cada clase en particular
 Las subclases heredan de las
superclases con la palabra extend

165
Relación “es-un”
 Para saber si la relación de herencia es
correcta, se plantea la pregunta ¿la
subclase es una superclase?
 Ej: ¿la plancha es un electrodoméstico?
class Electrodoméstico {
...
}
class Plancha extends Electrodoméstico{
boolean vapor; ...
}
166
Relación “es-un” (2)
class Electrodoméstico {
int tensión;
float consumo;
...
}

class Plancha extends Electrodoméstico {

boolean vapor;
...
}

167
Herencia simple
 Si una clase hereda de una única clase
se considera herencia simple
 Si una clase hereda de varias clases se
considera herencia múltiple
 La herencia simple permite que el
código sea reutilizable

168
Ej. superclase /clase padre
class Persona {
protected String nombre;
protected int edad;
public Persona(String n, int e){
setNombre(n);
setEdad(e );
}
public void setNombre( String n){
nombre = n;
}
public String getNombre() {
return nombre;
} 169
 … continuación
public void setEdad( int e){
if (e >= 0 && e <= 110)
edad = e;
else
edad = 0;
}
public int getEdad() {
return edad;
}
public void mostrar() {
[Link] (“nombre” + nombre);
[Link] (“edad” + edad);
}
170
}
 Ej. subclase / clase hija
class Estudiante extends Persona {
protected int codsis;

public Estudiante(String n, int e, int c){

super(n, e);
setCodigo(c);
}
public void setCodigo( int c){
if (c >2000000)
codsis =c ;
else
codsis = 2000123;
}
171
… continua
public int getCodigo() {
return codsis;
}
public void mostrar(){
[Link]();
[Link](“código sis:” + codsis);
}
} // fin class Estudiante

172
Relación “tiene-un”
 Una clase puede tener referencias a
otros objetos de otras clases
 Se diferencia de la herencia en que es
necesario instanciarlos por separado
 Responde a la pregunta: ¿Contenedor
tiene un contenido?

173
Relación “tiene-un” (2)
class Motor {
...
}
class Chasis {
...
}
class Coche {
Motor m; // coche tiene un motor
Chasis ch; // coche tiene un chasis
...
}

174
 Ejemplo de “tiene-un”
class Agenda {
private Persona ana;
private Persona luis;
public Agenda () {
ana = new Persona(“Ana Casillas”, 30);
luis = new Persona(“Luis Llanos”, 25);
}
public void mostrar(){
[Link]();
[Link]();
}
}
175
 Ejemplo arreglo de objetos
class Agenda {
private Persona lista[];
private int contador;
private int max;
public Agenda (int m) {
setMax(m);
contador = 0;
lista = new Persona[max];}
public void setMax(int m){
if (m > 0)
max = m;
else
max = 1;} 176
… continuación (2)
public void getMax(){
return max;
}
public void insertar(Persona p){
if (contador < max){
lista[contador] = p;
contador++;
}
else
[Link](“Agenda llena”);
}

177
 … continuación (3)
public void quitar(Persona p){
for (int i = 0; i < contador; i++){
if (p = lista[i]){
contador--;
for (; i<contador; i++)
lista[i] = lista[i+1];
}
}
}
public void mostrar(){
for (int i = 0; i< contador; i++)
lista[i].mostrar();}
} // fin class Agenda 178
Polimorfismo
 Polimorfismo indica muchas formas
 Una clase sólo tiene una forma, pero
una variable que hace referencia a la
superclase de una jerarquía puede
tener muchas formas (una por cada
subclase)
 Puede usarse con
 Parámetros polimórficos
 Colecciones heterogéneas
179
 Polimorfismo (2)
Electrodoméstico e1 = new Electrodoméstico();
Electrodoméstico e2 = new Plancha();
Electrodoméstico e3 = new Televisor();
Electrodoméstico e4 = new Lavadora();

[Link] = true // ERROR

((Plancha)e2).vapor = true;

180
Parámetros polimórficos
class Mascota {...}
class Raton extends Mascota {...}
class Gato extends Mascota {...}

class Veterinario {
void vacunar (Mascota m) { ... }
}
...
Veterinario doctor = new Veterinario();
Gato tom = new Gato();
Raton jerry = new Raton();
[Link](tom);
[Link](jerry);
181
Colecciones heterogéneas
 Usando polimorfismo se puede
conseguir que un arreglo contenga
elementos de distinto tipo.
 Se crea el arreglo con el tipo de la
superclase
Mascota [] lista = new Mascota[3];
lista[0] = new Mascota();
lista[1] = new Gato();
lista[2] = new Raton();

182
Colecciones heterogéneas
class Empleado {
int calcularVacaciones() { ...}
}
class Jefe extends Empleado {
int calcularVacaciones() { ...}
}
Empleado [] lista = new Empleado[100];
lista[0] = new Empleado();
lista[1] = new Jefe();
...
lista[99] = new Empleado();
For (int i= 0; i<[Link]; i++)
[Link](lista[i].calcularVacaciones());

183