LENGUAJE DE PROGRAMACION

ORIENTADO A OBJETOS

CONCEPTOS BASICOS

Facultad de Ingeniería Industrial y de Sistemas

Angel Chata Tintaya (angel.chata@gmail.com)

http://aulaportal.googlepages.com

1
 Características de Java
Simple: Reduce en un 50% los errores más comunes de programación en
lenguajes como C y C++ al eliminar aritmética de punteros, referencias,
necesidad de liberar memoria.
Robusto: Java realiza verificaciones en busca de problemas tanto en tiempo
de compilación como en tiempo de ejecución.
Arquitectura neutral: El código compilado tiene un formato independiente de
la arquitectura de la máquina en que se ejecutará.
Seguro: No usa punteros para prevenir el acceso ilegal a la memoria.
Interpretado: Requiere un runtime (JRE) para ser ejecutado, lo que lo hace
10 veces mas lento que un programa C compilado.
Orientado a objetos: Soporta las tres características propias del paradigma
de la orientación a objetos: encapsulamiento, herencia y polimorfismo
Distribuido: Se ha construido con extensas capacidades de interconexión
TCP/IP, presenta librerías con protocolos http y ftp para obtener
información a través de la red.

2
Compilación en Java

3
Características de un programa Java
1. El nombre de la clase debe ser igual al nombre del archivo.
2. El nombre del archivo tiene extensión java.
3. Los comentarios se colocan entre /* y */ o se inician con //
4. La clase se encierra entre { y }
5. Los métodos también se encierran entre { y }, como el método
main.
6. Las sentencias (acciones) se terminan con punto y coma.
7. Se usa el punto para evocar atributos o métodos de una clase.
8. Los argumentos de los métodos se colocan entre ( y ).
9. Se usa la identación para obtener un código mas legible.

C:\java> notepad Hola.java

/* Primer programa java */
public class Hola {
public static void main(String[] args) {
System.out.println("Hola desde java");
}
}
4
4
 Ejecución de un programa Java
1. Para compilar un programa java se usa el javac.exe
C:\java>javac Hola.java
2. Para ejecutar el programa ya compilado (seudo compilado) se
usa el java.exe
C:\java>java Hola
Hola desde java
4. Al ejecutar un programa java, el JVM empieza a buscar el método
main de la clase principal para ejecutarlo.
3. Se debe respetar las mayúsculas y minúsculas puesto que es
"case sensitive"

5
5
 Variables
1. Es una unidad básica de almacenamiento.
2. En Java debe ser declarada antes de utilizarse.
3. Cada variable tiene un tipo y un identificador.
4. Es un nombre simbólico con un valor.
5. Las variables pueden ser iniciadas.
6. La plantilla de declaración de variables es:
tipo identificador = valor;
7. Ejemplos de declaración de variables:
int miEdad = 36;
boolean estaAprobado = true;
double costoMaximo = 17.98;

6
6
 Estándares
1. Nombres de archivos fuente: Cliente.java, Hola.java, Producto.java
2. Nombres de programas, clases: Cliente, Hola, Producto.
3. Nombres de métodos, funciones: obtenerCliente, imprimirHola,
alquilarProducto.
4. Nombres de variables: nombreCliente, limiteCreditoCliente.
5. Nombres de constantes: PI, MÁXIMO_NUMERO_ITEMS,
ANCHO_MINIMO.
6. Java es “case-sensitive” por lo que:
“cliente” es diferente de “Cliente” y es diferente de “CLIENTE”.

7
7
 Nombre de Variables
1. Deben empezar con una letra del alfabeto ingles o subrayado.
2. Los siguientes caracteres pueden ser dígitos.
3. No se deben usar palabras reservadas.
4. Las palabras reservadas son aquellas propias del lenguaje Java
como:
public, void, static, boolean, float, int, class,
true, false, null, for, if, else, extends ...
5. El estándar es iniciar con minúscula y usar mayúsculas para
nuevos significados.
6. Ejemplos de nombre de variables

costo costo_Item costo#item

costoItem _costoItem class
costoItem2 costoItemfacturado 2costoItem
costoItemFacturado costoitem costo-item
8
 Tipos de Variables
1. Los principales tipos de variables son:

int Desde -2^31 hasta +2^31 (literal: 7)

long Desde -2^63 hasta +2^63 (literal: 7L)
float Es un numero decimal de 32 bits. (literal: 7.0f)
double Es un numero decimal de 64 bits. (literal: 7.0D)
char Es un solo carácter, como letra o digito o carácter especial.
(literal: ‘A’)
boolean Almacena valores lógicos true o false.
(literal: false)

2. Las cadenas no son un tipo de variable sino una Clase de tipo

String
(literal: “A”)

9
 Tipos Enteros
1. Cuentan con signo
2. Su valor por defecto es cero.
3. Numeros octales tienen prefijo cero: 032
4. Hexadecimales tienen prefijo cero equis: 0x1A
5. Long tiene postfijo L: 12345678987L

Tamaño: 1 byte
1. byte
Rango: -27  27 - 1
Tamaño : 2 bytes
2. short
Rango: -215  215 - 1
Tamaño : 4 bytes
3. int Rango: -231  231 - 1
Tamaño: 8 bytes
4. long
Rango: -263  263 - 1

Mayúsculas y minúsculas son equivalentes en los literales 10

 Tipos de Punto Flotante
1. Son numeros decimales.
2. Pueden tener parte fraccionaria.
3. Se inician en cero por defecto.
4. Float terminan con una efe: 7.1f
5. Double terminan con una de: 7.1D
6. En notacion científica se una la vocal e: 7.1e2
7. Un numero de punto flotante sin una letra final es un double: 7.1
es lo mismo como 7.1d

Tamaño: 4 bytes
1. float Rango: ±1.4 x 10-45 ±3.4 x 1038

Tamaño: 8 bytes
2. double
Rango: ±4.9 x 10-324 ±1.8 x 10308

11
 Tipo Caracter
1. Cualquier carácter sin signo
2. Se inician en cero (/u0000)
3. Algunas teclas pueden ser simuladas con una secuencia
escape:
\b retroceso
\f form feed
\n nueva línea Tamaño:
2 bytes
char
\r retorno de carro Rango:\u0000
è \uFFFF
\t tabulador

4. Algunos caracteres pueden necesitar secuencia escape cuando

se usan en literales String
\" comillas
\’ apostrofe
\\ backslash

Cuales es el rango del código ASCII? 12

 Tipos Boleano
1. Almacena un valor logico
2. Solo puede tener valor false o true
3. Se inicia por defecto en false
4. Un int no puede ser operado con un boolean

Tamaño:1 byte
boolean
Rango: true | false

Basta un byte para almacenar un boolean?

13
 Tipos Boleano
1. Almacena un valor logico
2. Solo puede tener valor false o true
3. Se inicia por defecto en false
4. Un int no puede ser operado con un boolean

Tamaño:1 byte
boolean
Rango: true | false

Basta un byte para almacenar un boolean?

14
 Declaración de Variables
1. La forma básica de declarar variables es:
tipo identificador = valor;
2. Las variables de instancia se pueden usar en cualquier lugar de
la clase.
3. Las variables locales se pueden usar solo en el ámbito donde son
declarados.

public class Variables {

/* Variables instancia */
public static int peliculasAlquilados = 0;
public static void main(String[] args) {
/* Variables locales */
double tasaDeInteres = 0.15;
int peliculasEnStock = 50;
int numeroDeDias = 3;
char categoriaDePelicula = 'G';
System.out.println(peliculasAlquilados);
System.out.println(tasaDeInteres);
System.out.println(peliculasEnStock);
System.out.println(numeroDeDias);
System.out.println(categoriaDePelicula);
}
}
15
 Operador de asignación
1. La expresión de la derecha se asigna a la variable de la
izquierda.
2. La expresión de la derecha se evalúa antes de la asignación.

int costo = 0, total = 0;

costo = 50;
total = costo + 10;
total = total + 5;
int var1 = 0, var2 = 0;
var1 = var2 = total = 50;

16
 Operadores aritméticos
1. Realizan las operaciones aritméticas básicas.
2. Trabajan sobre variables numéricas.

int a, b, c, d;
a = 2 + 2; // adicion
b = a * 3; // multiplicacion
c = b - 2; // substraccion
d = b / 2; // division
e = b % 2; // resto de la division (modulo)
a = a – 1;

Los datos byte, char y short se convierten en int después de una

operación
Si un operando es long, el otro se convierte en long y la respuesta
será long.

byte b1 = 1, b2 = 2, b3;
b3 = b1 + b2 // error el resultado es entero

17
Operadores Incremento y Decremento
1. El operador ++ incrementa en 1 la variable que acompaña.
2. El operador - - decrementa en 1 la variable que acompaña.

int var1 = 3;
var1 ++;
int var1 = 3, var2 = 0;
var2 = ++var1; //Se incrementa var1 luego se asigna a var2;
var2 = var1++; //Se asigna a var2 luego se incrementa var2;

int nota = 17, pendientes = 10;

nota++; // es idéntico a nota = nota + 1;
pendientes--; // es idéntico a pendientes = pendientes - 1;

18
 Operadores de Comparación
1. Son relaciones de igualdad y desigualdad.
2. Se debe diferenciar el operador de comparación con el operador de
asignación

boolean valor;
int a = 1, b = 2, c = 3, d = 4, e = 3;
valor = b > a; // mayor que
valor = b >= a; // mayor igual que
valor = c < d; // menor que
valor = c <= d; // menor igual que
valor = a != d; // diferente que
valor = c == e; // igual que

int nivelBuenCredito = 3;
int nivelCreditoCliente;
boolean esBuenCredito = false;
esBuenCredito = (nivelCreditoCliente == nivelBuenCredito);

19
 Operadores Lógicos
1. Los resultados de las operaciones de comparación pueden
combinarse con operadores lógicos.

boolean valor;
int a = 1, b = 2, c = 3;
valor = (b > a) || (a > b) ; // operación logica OR
valor = (b > a) && (c > b); // operación logica AND
valor = !(a > b); // operación logica NOT

OR AND NOT
F || F = false F && F = false !F = true
F || T = true F && T = false !T = false
T || F = true T && F = false
T || T = true T && T = true

20
 Operadores Compuestos
1. La operación de asignación puede combinarse con operadores aritméticos
como + y -
//
int total = 0, cantidad = 10;
total += cantidad; // asignación con incremento
total -= 3; // asignación con decremento
total *= 2; // asignación con multiplicación
//
int diasDeAlquiler;
diasDeAlquiler = diasDeAlquiler + 3;
diasDeAlquiler += 3;
//
double total = 0, num = 1;
double porcentaje = 0.50;
total = total + num;
total += num;
total -=num;
total *= porcentaje;

21
 Operadores con Cadenas.
1. A la colección de caracteres se les llama cadenas.
2. Los datos de tipo String almacenan cadenas.
3. El operador + tambien puede encadenar dos datos de tipo String.

String nombre = "Isaac";

String apellido = "Asimov";
String nombreCompleto = nombre + apellido;
String letras = "Hola, soy una cadena";
char letrita = 'c';

22
 Casting
1. El casting crea un nuevo valor que permite ser tratado como un tipo
diferente al original
2. Java implícitamente puede convertir desde un tipo mas restringido a
un tipo mas amplio
3. Para cambiar a un tipo de menor tamaño se debe realizar cast
explícitamente.

int d; double f;
int a, b; short e; long g;
short c; e = (short)d; f = g;
a = b + c; g = f; //error

Por que el error al final?

23
 Casting Implícito vs. Explicito
1. El casting implícito es automático cuando no hay perdida de
información.
2. Es posible asignar byte -> short -> int -> long -> float -> double
3. Se requiere casting explicito cuando existe una "potencial" perdida
de exactitud.

long p = (long) 12345.56; // p == 12345

int g = p; // asignacion ilegal aunque un
// int puede tener 12345
char c = ‘t’;
int j = c; // promocion automatica
short k = c; // error, perdida de precision
short k = (short) c; // cast explicito
float f = 12.35; // cual es el error aqui?

Cual es el error aquí?

24
 Precedencia de operadores
operadores sufijo expr++ expr--
operadores unarios +expr -expr !
multiplicadores * / %
suma/resta + -
relacionales < > <= >=
igualdad == !=
AND lógico &&
OR lógico ||
condicional ? :
asignación = += -= *= /= %=

Determina el orden en el cual se ejecutan los operadores

Operadores con la misma precedencia se realizan de izquierda a derecha
Usa el paréntesis para cambiar este orden.
int var1 = 0;
var1 = 2 + 3 * 4;
var1 = 12 – 6 + 3;

25
 Ejercicio 1
Encuentre los errores en el siguiente código:
1. int class = 200;
2. short texto = 43;
3. short hola mundo;
4. int boolean3 = boolean + boolean + boolean;
5. long almuerzo = entrada + sopa + segundo // falta
postre
6. double viejo = 78.3;
7. doble nuevo = 0.1;
8. boolean consecuezia = true;
9. boolean maximo = 7 > 3;
10. char calle = "Via expresa";
11. char rio = 'N';
12. boolean causa = 7;
13. boolean igualdad = "true";
14. double precio = S/.20.50;
15. int uno = 3;
16. long cinco = uno + uno + uno;
17. boolean comparacion = cinco > uno;

26
 Bloques en Java
El código se ejecuta secuencialmente por defecto
Un conjunto de sentencias requieren de llaves { } para agruparse como
un bloque.
El bloque entre llaves { } se conoce también como sentencia compuesta.
Una sentencia simple es una expresión que termina con punto y coma.
var1 += var2++ + 4;
Cada bloque se ejecuta como una única sentencia dentro del flujo.
{
int i = 0;
boolean termino = true;
System.out.println("i = " + i);
i++;
}

27
 IF y ELSE
Esta sentencia provee una selección de procesos básico. Una expresión boleana controla
que sentencia se ejecutara.
Si la expresión es true, se realizara la primera expresión es false se realizara la segunda.
La cláusula else es opcional.

if ( i % 2 == 0 )
System.out.println("Es par");
else
System.out.println("Es impar");
//
if (diasDeAlquilerTranscurridos > diasAlquilerContratados )
System.out.println("Primero pagar moras por alquiler");
else
System.out.println("Puede alquilar nuevas peliculas");
//
if ( numero > 0 ) {
System.out.println("El numero es positivo");
}
//
if (mes <= 7)
System.out.println("El impuesto es 18%");
else
System.out.println("El impuesto es 19%");

28
 IF anidados
Cuando se requieren muchas condiciones, se pueden anidar sentencias IF.
Debe tener cuidado en el correcto uso de la sentencia ELSE
Este enfoque es utilizado poco, ya que se crea un código algo complicado de
entender
if (velocidad >= 30)
if (velocidad > 100)
System.out.println("Vamos muy rapido");
else
System.out.println("Llegaremos a tiempo.");
else
System.out.println("Que lento vamos");
//
if (velocidad >= 100)
System.out.println("Vas muy rapido");
else if (velocidad > 30)
System.out.println("Vas manejando bien.");
else
System.out.println("Vas muy lento");
//

29
 IF anidados
Es preferible usar las llaves { } para separar los bloques.

//
if (velocidad >= 25) {
if (velocidad > 100) {
System.out.println("Vamos muy rapido!");
}
else {
System.out.println("Llegaremos a tiempo");
}
}
else {
System.out.println("Que lento es la movilidad");
}

30
 Errores comunes.
Encuentre los errores en los siguientes ejemplos.
//
int x = 3, y = 5;
if ( x >= 0)
if ( y < x )
System.out.println("y es menor que x");
else
System.out.println("x es negativo");
//
int x = 7;
if ( x = 0)
System.out.println("x es cero");
//
int x = 15, y = 24;
if ( x % 2 == 0 && y % 2 == 0 );
System.out.println("x e y son pares");

31
 El operador condicional (?:)
Es una alternativa a la estructura if..else

if (mes <= 7)
impuesto = 0.18;
else
impuesto = 0.19;

Es una expresión que retorna un valor.

Si la expresión logica es verdadera se obtiene el primer valor.
Si la expresión logica es falsa se obtiene el segundo valor.

impuesto = ( mes <= 7 ) ? 0.18 : 0.19;

32
 La sentencia SWITCH
Es usada cuando se requiere tomar una accion entre varias en base a
una expresión.
La expresión debe ser byte, char, short o int.
No puede ser un long, double, float, String o cualquiere otro tipo.
Si la expresión se iguala a una condicion, esta se ejecuta.
Si no se iguala a ninguna condicion, se realiza la sentencia marcada con
default.
Las condiciones deben ser constantes.
Use break para salir del switch
Siempre coloque una opcion default.

33
 La sentencia SWITCH
int dia
switch (dia) {
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("Tienes que ir a trabajar");
break;
case 6:
case 7:
System.out.println("Quedate en casa");
break;
default:
System.out.println("En que planeta vives?");
}

34
 WHILE
El while es la forma mas simple de un bucle.
Tiene la siguiente forma:

int i = 1; // inicializacion
while (i<=10) { // condicion de repeticion
System.out.println(i*3.5); // cuerpo
i++; // iteracion
}

El cuerpo se realizara mientras la condición de repetición sea verdadera true

35
 DO...WHILE
Realiza la condicion de repetición al finalizar el bloque.

Tiene la siguiente forma:

int i = 1; // inicializacion
do {
System.out.println(i*3.5); // cuerpo
i++; // iteracion
} while ( i <= 10 ) // condicion

36
 EL CICLO FOR
Combina en una sentencia la definición de un ciclo repetitivo.
Para el caso del tipo de cambio, el código fuente será:

for (int i=1; i<=10; i++) {

System.out.println(i*3.5);
}

La inicialización y la iteración puede ser compuesta.

for (int i=0, j=10; i<j; i++, j--) {
System.out.println(j-i);
}

Se pueden crear bucles infinitos.

for (;;) {
System.out.println("Hola mundo!");
}

37
 ERRORES COMUNES
El trasbordador espacial se encuentra a una altura de 10 Km y esta en fase de
aterrizaje.
// Caso 1
int altura = 10;
while (altura > 0);
System.out.println(altura--);
System.out.println("Hemos aterrizado");
// Caso 2
int altura = 10;
while (altura > 0)
System.out.println(altura);
altura--;
System.out.println("Hemos aterrizado");
// Caso 3
int altura = 10;
for (; altura > 0; altura--);
System.out.println(altura);
System.out.println("Hemos aterrizado");

38
 LA SENTENCIA BREAK
En todo bucle, la sentencia BREAK transfiere el control fuera del bucle.
Son necesarias cuando se trata de bucles infinitos.

Un empleado ha llegado a su edad de jubilación (65) y ha trabajado desde los 25

años. Su CTS se deposita en un banco que le otorga interes por estos
depositos. Un nuevo gobierno ha decretado que esta liquidación tendra un
maximo de 250,000 soles

while (edad <= 65) {

liquidación = (liquidación + salario)*(1+interes);
if (liquidación >= 250,000)
break;
edad++;
}

39
 LA SENTENCIA CONTINUE
Se usa solo en ciclos FOR.
Abandona la ejecución del cuerpo y continua a la siguiente iteración.

Mostrar todos los años bisiestos del siglo XXI.

for ( int anio=2001; anio <= 3000; anio++ ) {

if ( (anio % 100 == 0) && (anio % 400 != 0) )
continue;
if (anio % 4 == 0)
System.out.println(anio);
}

40
FIN

41