Diapositivas curso programación orientada a objetos en Java

Universidad Autónoma del Carmen
Diapositivas
Título: “Programación Orientada a Objetos”
Curso: Programación Orientada a Objetos
Academia de Programación
Programación Orientada a Objetos 1

Integrante:
MCC. José Ángel Pérez Rejón
Ciudad del Carmen, Campeche, Febrero 2016
Tema I
Introducción
Tema II
Clases y objetos
Tema III
Relaciones entre clases
Secuencia de Aprendizaje 1 / 1
Programación Orientada a Objetos
2

Contenido
•Identificadores
•Tipos de Datos Primitivos
•Asignación
•Conversiones
•Asignación entre variables
•Ámbito de las variables
•Valores por defecto de las variables
•Paso de variables a métodos
•Operadores
•Estructuras de control
•Bibliografía
3

Identificadores

Identificadores
Técnicamente los identificadores deben ser
formados solamente con caracteres UNICODE,
números y caracteres $, y caracteres como el
guión bajo (_)
Los identificadores debe iniciar con una letra, un
símbolo $ o un guión bajo.
Los identificadores no pueden iniciar con un
número
Después del primer carácter los identificadores
pueden contener cualquier combinación de otros
caracteres, números, caracteres $, y guiones
bajos.

Identificadores
En la practica no hay un limite de
caracteres para formar un identificador.
No se pueden utilizar las palabras
reservadas del lenguaje Java como un
identificador (ver tabla de palabras
reservadas)
Los identificadores en Java son sensitivos
a letras mayúsculas y minúsculas; por
ejemplo: no es el mismo identificador foo
que Foo

Palabras reservadas
Lista completa de palabras reservadas de Java
(assert es agregado en la version1.4, enum es agregado en la version 1.5)
abstract boolean break byte case catch
char class const continue default do
double else extends final finally float
for goto if implements import instanceof
int interface long native new package
private protected public return short static
strictfp super switch synchronized this throw
throws transient try void volatile while
assert enum

Ejemplos de identificadores
Ejemplos de identificadores válidos:
int _a;
int $c;
int ______2_w;
int _$;
int this_is_a_very_detailed_name_for_an_identifier;
Ejemplos de identificadores no válidos, ¿porque?:
int :b;
int -d;
int e#;
int .f;
int 7g;

Convenciones en Java
El 80% del tiempo en que se desarrolla un
sistema se utiliza para darle mantenimiento y
mejorar cada una de las piezas de código que lo
forman
Las convenciones son estándares de código que
ayudan a reducir el esfuerzo en las etapas de
prueba, mantenimiento, y mejoras sobre las
piezas de código.

CamelCase
CamelCase es la práctica de escribir frases o palabras
compuestas eliminando los espacios y poniendo en mayúscula
la primera letra de cada palabra. El nombre viene del parecido
de estas mayúsculas, entre las demás letras, con las jorobas de
los camellos.
Existen dos tipos de CamelCase:
UpperCamelCase, cuando la primera letra de todas está escrita
en mayúscula. Ej: EjemploDeUpperCamelCase
lowerCamelCase, la primera letra de la primera palabra está
escrita en minúscula y las primeras letras de las demás palabras
están escritas en mayúsculas. Ej: ejemploDeLowerCamelCase
Se trata de un estándar en varios lenguajes de programación.Programación Orientada a Objetos 10

Convenciones
Clases:
El nombre de las clases debe iniciar con la
primera letra capitalizada, se utiliza la notación
UpperCamelCase
Los nombres de las clases deben ser
típicamente sustantivos
Ejemplos:
Dog
Account
PrintWriter

Convenciones
Interfaces:
Se aplica el mismo criterio que en las clases,
se utiliza la notación UpperCamelCase
El nombre de las interfaces debe ser un
adjetivo
Ejemplos:
Serializable
Runnable

Convenciones
Métodos:
El nombre de un método debe formarse con la
primera letra en minúsculas, y se deben
aplicar la notación lowerCamelCase
Por lo regular el nombre de los métodos debe
ser verbo-sustantivo
Ejemplos:
getBalance
getAccount
setCustomerName

Convenciones
Variables:
Aplica la misma notación que los métodos, la
lowerCamelCase.
Deben ser por lo regular nombres cortos y
manejables
Ejemplos:
myVar
buttonWidth
accountBalance

Convenciones
Constantes:
Estas son creadas para identificar variables
estáticas (static) o finales (final)
Estas deben ser nombradas utilizando sólo
letras mayúsculas, si el nombre contiene mas
de una palabra estas deben ser separadas
mediante un guión bajo (_)
Ejemplos:
MIN_HEIGHT
MAX_HEIGHT
Índice

Tipos de datos
primitivos

Tipos de datos enteros
Rango de valores para una variable de tipo
entero
Tamaño Tipo Rango Valores
8 bits byte -27 to 27-1 -128 a 127
16 bits short -215 to 215 -1 -32768 a 32767
32 bits int -231 to 231 -1 -2147483648 a
2147483647
64 bits long -263 to 263 -1 -9223372036854775808
a
9223372036854775807

Tipo de datos flotante
Rango de valores permitido para una
variable de tipo flotante
Tipo Tamaño Rango
float 32 bits +/-3.40282347E+38F
double 64 bits +/- 1.79769313486231570E+308

Valores literales
Una valor literal es la representación en el
código fuente de un valor para un tipo de
dato primitivo:
'b'
42
false
2546789.343
// char literal
// int literal
// boolean literal
// double literal

Valores Literales para tipos enteros
Existen tres manera de representar valores
literales para el tipo int en Java:
Literales decimal
Literales octales
Literales hexadecimales
Las literales decimales se representan de
manera sencilla:
int longitud = 350;Programación Orientada a Objetos 20

Valores literales para tipos enteros
Los valores octales sólo utilizan dígitos
entre el 0 y 7.
Ejemplo:
class Octal {
public static void main(String [] args) {
int six = 06; // Equal to decimal 6
int seven = 07; // Equal to decimal 7
int eight = 010; // Equal to decimal 8
int nine = 011; // Equal to decimal 9
System.out.println("Octal 010 = " + eight);
}
}Programación Orientada a Objetos 21

Valores literales para tipos enteros
Los valores hexadecimales son construidos
por 16 símbolos diferentes:
0 1 2 3 4 5 6 7 8 9 a b c d e f
Ejemplo:
class HexTest {
public static void main (String [] args) {
int x = 0X0001;
int y = 0x7fffffff;
int z = 0xDeadCafe;
System.out.println("x = " + x + " y = " + y + " z = " + z);
}

Valores literales para tipos flotante
Los números de punto flotante están
formados por un numero en base decimal y
una serie de números que son la parte
fraccionaria:
double d = 11301874.9881024;
El valor 11301874.9881024 es un valor
literal.

Las literales de punto flotante son definidos
por default como un double (64 bits). Si
queremos asignar un valor literal punto
flotante a una variable del tipo float,
debemos utilizar como sufijo la letra F o f.
float f = 23.467890; // Compiler error, possible loss
// of precision
float g = 49837849.029847F; // OK; has the suffix "F"

Si queremos ser explícitos en la declaración
de literales de tipo double, podemos
agregar el sufijo D o d al valor literal
double d = 110599.995011D; // Optional, not required
double g = 987.897; // No 'D' suffix, but OK because the
// literal is a double by default
int x = 25,343; // Won't compile because of the comma

Valores literales para boolean
Los valores literales que sólo puede aceptar
una variable de tipo boolean son: true ó
false
boolean t = true; // Legal
boolean f = 0; // Compiler error!
Uso de valores boolean:
int x = 1;
if (x) { } // Compiler error!

Valores literales para char
Un valor literal para un tipo de dato char, es
un carácter entre comillas simples
char a = 'a';
char b = '@';
Es posible utilizar valores literales en
formato Unicode:
char letterN = 'u004E'; // The letter 'N'

Valores literales para char
Hay que recordar que el tipo de dato char
utiliza 16 bits, por tal motivo es posible
asignarle valores numéricos a una variable
del tipo char siempre y cuando no exceda el
rango de 65535 o menos.
char a = 0x892; // hexadecimal literal
char b = 982; // int literal
char c = (char)70000; // The cast is required; 70000 is
// out of char range
char d = (char) -98; // Ridiculous, but legalProgramación Orientada a Objetos 28
Índice

Asignación

Operador de Asignación
Para poder realizar una asignación de un
valor literal a una variable de tipo primitivo,
esta se realiza de manera directa:
int a = 100;
Una variable es conjunto de bits (bit holder)
de un tipo de dato designado, los bits
representan un valor.

Asignación de variables de tipo primitivo
Ejemplo: una variable de tipo byte utiliza 8 bits para
almacenar un valor, supongamos que la variable x
guarda el valor 6, en realidad lo que almacena la
variable es un patrón de bits como: 00000110 que
representan el valor 6
(byte holder)
byte x = 6;
00000110

Asignación de variables referencia
¿Que hay dentro de una variable que recibe un
objeto?
Button a = new Button(“Aceptar”);
Este tipo de variables no contienen al objeto,
contienen el camino para llegar al objeto, es
decir una referencia al objeto, por ello se les
denomina variables de referencia. Ellas
guardan al igual que las variables de tipo
primitivo un patrón de bits.

Si la variable de referencia no ha sido asignada
esta contiene un valor null, que indica que esta
variable no apunta a ningún objeto.
Button b = null; // esta variable
// no apunta a ningún objeto

Asignación de tipos de datos primitivos
Operadores de asignación
= Asignación a = b
++ Incremento en 1 a++ o ++a
-- Decremento en 1 a-- o --a
+= Suma y asignación a+=b
Asignación -= Resta y asignación a-=b
Multiplicación y
*= asignación a*=b
/= División y asignación a/=b
%= Módulo y asignación a%=b

Asignación de tipos entero
La asignación de un valor primitivo a una variable
primitiva se puede hacer directamente o a través
del resultado de una expresión:
int x = 7; // literal assignment
int y = x + 2; // assignment with an expression
// (including a literal)
int z = x * y; // assignment with an expression
Nota: Hay que recordar el valor literal 7 implícitamente
representa un tipo de dato int.

La asignación de valores literales a una variable
byte es:
byte b = 27;
Para el caso anterior el compilador pone de manera
automática el cast (conversión) para convertirlo a
byte, de la siguiente manera:
byte b = (byte) 27; // Explicitly cast the int literal to a byte

Ejemplos válidos donde es posible la asignación
directa de un valor int a un byte:
byte a = 127;
byte a = -128;
Ejemplos inválidos:
byte a = 128;
//dentro del rango
//dentro del rango
//fuera del rango

El resultado de una expresión que involucra
tipos int o menores (short, byte), dará como
resultado por default un valor de tipo int.
Por ejemplo la suma de dos variables de tipo
byte, su resultado será un tipo int.
La división de un int entre un byte da como
resultado un int

byte b = 3; // No problem, 3 fits in a byte
byte c = 8; // No problem, 8 fits in a byte
byte d = b + c; // Should be no problem, sum of the two bytes
// fits in a byte
La última línea no compila, debido a que el resultado de sumar
dos variables de tipo byte su resultado es de tipo int. Para
corregir el problema se debe hacer una conversión:
byte d = (byte) b + c;
TestBytes.java:5: possible loss of
precision found : int
required: byte
byte c = a + b;
^Programación Orientada a Objetos 39
Índice

Conversiones

Conversiones de tipos de datos primitivos
Java permite la conversión de un tipo de dato
primitivo a otro, esta conversión puede ser de
manera implícita o explicita.
De manera implícita:
int a = 100;
long b = a; // Implicit cast,
// an int value always fits in a long
De manera explicita:
float a = 100.001f;
int b = (int)a; // Explicit cast, the float could lose info

Un valor entero puede asignarse a un tipo flotante a
través de una conversión (cast) implícita:
double d = 100L; // Implicit cast
Conversión explicita necesaria:
class Casting { class Casting {
public static void main(String [] args) public static void main(String [] args)
{ {
int x = 3957.229; // illegal int x = (int )3957.229; // llegal
} }
} }Programación Orientada a Objetos 42

Asignado tipos de datos grandes a tipos más
pequeños:
class Casting {
long l = 56L;
byte b = (byte)l;
System.out.println("The byte is " + b);
}}
En el código anterior funciona correctamente, el resultado
de la ejecución es:
The byte is 56Programación Orientada a Objetos 43

Conversión de tipos de datos primitivos
¿Cuál es el comportamiento si asignamos un valor
mayor a 127 a la variable de tipo long?
class Casting {
long l = 130L;
byte b = (byte)l; System.out.println("The byte is " + b);
}
}
En el código anterior funciona correctamente, el resultado
de la ejecución es:
The byte is -126

Asignación de tipos flotante
Si tratamos de asignar un valor double a un tipo
float, el compilador debe marcar un error debido a
que un tipo double utiliza 64 bits y el float solo 32
bits. El siguiente código parece correcto, pero no
compilará:
float f = 32.3;
Aparentemente el valor cabe perfectamente dentro
de la variable float, pero el compilador marcará un
error de perdida de precisión:
Índice

Asignación entre
variables

Asignación entre variables de tipo primitivo
Cuando se asigna una variable a otra, el valor de la
primera se copia a la segunda:
int a = 10;
int b = a;
La asignación puede leerse de la siguiente manera:
“El patrón de bits que almacena la variable a,
tómala y cópiala en la variable b”
La relación que existe entre la variable a y b es que
almacenan el mismo patrón de bits

Ejemplo de asignación entre variables
class ValueTest {
int a = 10; // Assign a value to a
System.out.println("a = " + a);
int b = a;
b = 30;
System.out.println("a = " + a + " after change to b");
}
}
The output from this program is:
C:java ValueTest
a = 10
a = 10 after change to b
Las variables a y b no apuntan a la misma localidad de memoria.

Nosotros podemos asignar un objeto nuevo a una
variable referencia de la siguiente manera:
Button b = new Button(“Aceptar”);
El código anterior realiza lo siguiente:
Crea una variable referencia llamada b, del tipo Button
Crea un nuevo objeto en el “heap”
Asigna la referencia del nuevo objeto creado a b

Nosotros podemos asignarle a una variable referencia el valor
null, que indica que esta variable no apunta a ningún objeto.
Button b = null;
Nosotros podemos asignar a una variable un objeto que es
subclase del tipo declarado, por ejemplo:
public class Foo {
public void doFooStuff() { }
}
public class Bar extends Foo {
public void doBarStuff() { }
}
class Test {
Foo reallyABar = new Bar(); // Legal because Bar is a subclass of Foo
Bar reallyAFoo = new Foo(); // Illegal! Foo is not a subclass of Bar
}
}

Asignación entre variables referencia
Las variables referencia guardan el “camino” hacia un objeto dentro
del “heap”.
Cuando se asignamos a una variable referencia otra variable
referencia, esta recibe una copia de la ubicación del objeto, esto
implica que dos variables puede apuntar al mismo objeto.
import java.awt.Dimension;
class ReferenceTest {
Dimension a = new Dimension(5,10);
System.out.println("a.height = " + a.height);
Dimension b = a;
b.height = 30;
System.out.println("a.height = " + a.height + " after change
to b");
}
}
Índice

Ámbito de las
variables

Ámbito de las variables
class Layout { // class
static int s = 343; // static variable
int x; // instance variable
{ // initialization block
x = 7;
int x2 = 5;
}
Layout() { // constructor
x += 8;
int x3 = 6;
}
void doStuff() { // method
int y = 0; // local variable
for(int z = 0; z < 4; z++) { // 'for' code block
y += z + x;
}
}
}

Del código anterior observamos lo siguiente:
s es una variable estática, las variables estáticas tienen el
ámbito mas largo de todas las variables, estas son creadas
cuando se cargan las clases. Esto quiere decir que ellas
están “vivas” mientras las clases estén cargadas en la JVM.
Las variables de instancia como x, tienen el siguiente nivel
de supervivencia, es decir ellas son creadas cuando se crea
una instancia, y existen hasta que la instancia sea
removida.
Las variables locales son un tercer nivel, estas variables son
colocadas en el stack, por ejemplo las variables x2 y y
Por ultimo el ámbito de bloque es aquel donde las variables
sólo están disponibles dentro de un bloque de código { },
que pertenece a un método o una sentencia de control o un
bloque de inicialización, por ejemplo las variables x2 y z.

El siguiente código muestra un error común al querer
acceder a una variable que esta fuera del alcance del
método:
class ScopeErrors {
int x = 5;
public static void main(String[] args) {
x++; // won't compile, x is an 'instance' variable
}
}

Cuando queremos acceder a una variable desde un método
anidado:
class ScopeErrors {
ScopeErrors s = new ScopeErrors();
s.go() ;
}
void go() {
int y = 5;
go2() ;
y++; // once go2() completes, y is back in scope
}
void go2() {
y++; // won't compile, y is local to go()
}
}

Cuando queremos acceder a una variable que solo tiene
de ámbito un bloque de código:
void go3() {
for(int z = 0; z < 5; z++) {
boolean test = false;
if(z == 3) {
test = true; break;
}
}
System.out.print(test); // 'test' is an ex-variable,
// it has ceased to be...
Índice

Valores por defecto
de las variables

Valores por defecto de las variables
Java nos permite crear variables inicializadas o no
inicializadas, cuando queremos acceder a una de esas
variables el comportamiento puede variar dependiendo
del tipo de dato, y del ámbito de la variable.
Las variables tiene valores por defecto cuando son
creadas, ya sean de tipo primitivo o de referencia:
Variable Type Default Value
Object reference null (not referencing any object)
byte, short, int, long 0
float, double 0.0
boolean false
char 'u0000'Programación Orientada a Objetos 59

Valores por defecto de las variables
public class BirthDate {
int year; // Instance variable
BirthDate bd = new BirthDate( );
bd.showYear();
}
public void showYear() {
System.out.println("The year is " + year);
}
}
Cuando la programa es ejecutado, la variable year no es
inicializada, por tal motivo el resultado de la ejecución
es:
The year is 0

Valores por defecto de los objetos
Cuando utilizamos variables referencia que no son
inicializadas el comportamiento es diferente:
public class Book {
private String title; // instance reference variable
public String getTitle() {
return title;
}
Book b = new Book() ;
System.out.println("The title is " + b.getTitle());
}
}
The title is nullProgramación Orientada a Objetos 61

Accediendo a variables con valor null
Cuando accedemos a una variable que tiene un valor
null, se dispara error en tiempo de ejecución:
Exception in thread "main" java.lang.NullPointerException at
Book.main(Book.java:9)
public class Book {
private String title; // instance reference variable
public String getTitle() {
return title;
}
Book b = new Book();
String s = b.getTitle(); // Compiles and runs
String t = s.toLowerCase(); // Runtime Exception!
}

Valores por defecto de variables arreglo
Un arreglo es un objeto.
Una instancia de un arreglo que sólo se declaró y no ha sido
explícitamente inicializada tiene el valor null.
Si el arreglo ha sido al menos inicializado, los elementos del
arreglo contendrán el valor default del tipo que almacenan.
public class BirthDays {
static int [] year = new int [100] ;
for(int i=0;i<100;i++)
System.out.println("year[" + i + "] = " + year[i]);
}

Variables locales de tipo primitivo
Se considera a una variable como local, aquella que pertenece
a un método, incluyendo los parámetros del método.
Una variable local siempre, siempre, siempre debe ser
inicializada con un valor antes de querer usarla.
Java no les da a las variables locales un valor por default, es
responsabilidad nuestra asignarle un valor de manera explicita.
public class TimeTravel {
int year; // Local variable (declared but not initialized)
System.out.println("The year is " + year); // Compiler error
}
}

Variables locales de tipo primitivo
int year; // Declared but not initialized
int day; // Declared but not initialized
System.out.println("You step into the portal.");
year = 2050; // Initialize (assign an explicit value)
System.out.println("Welcome to the year " + year);
}
}
Es posible declarar y después inicializar explícitamente una
variable local.
Nótese que la variable day no es inicializada, el programa
ejecuta bien, la única diferencia es que la variable day no es
utilizada.

Variables locales de referencia a objetos
De manera similar a las variables locales de tipo primitivo,
estas no son inicializadas con el valor por defecto, para el caso
de objetos el valor null, por tal motivo debemos inicializar de
manera explicita a un objeto.
import java.util.Date;
Date date;
if (date == null)
System.out.println("date is null");
}
}
C:javac TimeTravel.java
TimeTravel.java:5: Variable date may not have been initialized.
if (date == null) 1 errorProgramación Orientada a Objetos 66
Índice

Paso de variables a
métodos

Paso de variables referencia a métodos
Cuando nosotros pasamos un objeto como parámetro de un
método, estamos pasando la referencia de ese objeto, y no el
objeto como tal.
1. import java.awt.Dimension;
2. class ReferenceTest {
3. public static void main (String [] args) {
4. Dimension d = new Dimension(5,10);
5. ReferenceTest rt = new ReferenceTest();
6. System.out.println("Before modify() d.height = " + d.height);
7. rt.modify(d);
8. System.out.println("After modify() d.height = " + d.height);
9. }
10. void modify(Dimension dim) {
11. dim.height = dim.height + 1; C:java ReferenceTest
12. System.out.println("dim = " + dim.height);
Before modify() d.height = 10
13. }
14. }
dim = 11 After modify() d.height = 11

Paso de variables primitivas a métodos
Cuando pasamos variables primitivas a un método pasamos
una copia del valor que almacena esa variable, por ejemplo:
class ReferenceTest {
int a = 1;
ReferenceTest rt = new ReferenceTest();
System.out.println("Before modify() a = " + a); rt.modify(a);
System.out.println("After modify() a = " + a) ;
}
void modify(int number) {
number = number + 1;
System.out.println("number = " + number);
}
}
Before modify() a = 1
number = 2
After modify() a = 1
Índice

Operadores

Operadores de asignación compuestos
Operadores de asignación compuestos, los mas comunes son
+=, -=, *=, /=
Pero existen %=,
Ejemplos sin operadores compuestos:
y = y - 6;
x = x + 2 * 5;
Ejemplos con operadores compuestos:
y -= 6;
x += 2 * 5;

Operadores relacionales
Los operadores relacionales son:
<, <=, >, >=, ==, !=
El resultado de una expresión que utiliza operadores
relacionales arrojará como resultado un valor boolean (true o
false)
Ejemplo de uso común:
int x = 8;
if (x < 9) {
// do something
}

Operadores relacionales
El resultado de una expresión que utiliza operadores
relacionales puede ser asignado directamente a una variable de
tipo boolean:
class CompareTest {
boolean b = 100 > 99;
System.out.println("The value of b is " + b);
}
}

Operadores de “igualdad”
Java maneja dos operadores denominados de “igualdad”
Este operador compara dos cosas similares y regresan un valor
boolean
Los operadores son:
== (se lee “igual a”)
!= (se lee “no igual a”)
Los operadores de igualdad se aplican a cualquier tipo de dato
primitivo y se aplica a variables referencia, donde los
operadores de igualdad comparan referencias a objetos y no
objetos como tal.

Comparando variables primitivas
Ejemplo de comparación de variables primitivas:
class ComparePrimitives {
System.out.println("char 'a' == 'a'? " + ('a' == 'a'));
System.out.println("char 'a' == 'b'? " + ('a' == 'b'));
System.out.println("5 != 6? " + (5 != 6));
System.out.println("5.0 == 5L? " + (5.0 == 5L));
System.out.println("true == false? " + (true == false));
}
}

Comparando variable referencia
Cuando se utiliza los operadores de “igualdad” entre variables
referencia, se comparan las referencias de los objetos que
intervienen
JButton a = new JButton("Exit");
JButton b = a;
Si consideramos el código anterior a y b tienen la misma referencia
if (a == b) {
System.out.println(“a is equals b”);
}

Comparando Enumeraciones
Se pueden utilizar los operadores de comparación
para saber si dos variables tiene la misma
referencia a una constante.
class EnumEqual {
enum Color (RED, BLUE} // ; is optional
Color cl = Color.RED;
Color c2 = Color.RED;
if(cl == c2) {
System.out.println("==");
}
if(cl.equals(c2)) {
System.out.println("dot equals");
}
}
}

Operadores aritméticos
Los operadores aritméticos básicos son:
*, / ,+, -, %
Ejemplos de uso:
int x = 5 * 3;
int y = x - 4;
System.out.println("x - 4 is " + y); // Prints 11
El operador % (residuo de la división)
class MathTest {
int x = 15;
int y = x % 4;
System.out.println("The result of 15 % 4 is the " +
"remainder of 15 divided by 4. The remainder is " + y);
}
}

Operador de concatenación de Strings
El operador + puede ser usado para concatenar cadenas:
String animal = "Grey " + "elephant";
El operador + es más interesante cuando se concatenan
cadenas y números:
String a = "String";
int b = 3; String37
int c = 7;
System.out.println(a + b + c);
Si utilizamos parentesis:
String a = "String";
int b = 3;
int c = 7; String10
System.out.println(a + (b + c));Programación Orientada a Objetos 79

Operadores incremento y decremento
Estos operadores incrementan o decrementan a una variable
en uno:
-- (como prefijo o postfijo)
++ (como prefijo o postfijo)
Ejemplo:
class MathTest {
static int players = 0;
System.out.println("players online: " + players++);
System.out.println("The value of players is " + players);
System.out.println("The value of players is now " + ++players);
}
}
C:java MathTest
players online: 0
The value of players is 1
The value of players is now 2Programación Orientada a Objetos 80

Operadores lógicos
Los operadores lógicos más comúnmente usados son:
&&
||
!
Los operadores lógicos solo trabajan con operandos boolean
if ((2 < 3) && (3 < 4) ) { }
El operador ! Sirve para invertir el valor de una expresión
boolean, inclusive se aplica a variables boolean:
if (!(7 == 5)) { system.out.println ("not equal"); }
El resultado es: not equal
Índice

Estructuras de
control

Estructuras de control
Las estructuras de selección son if y switch.
Para la estructura if la sintaxis es:
if (booleanExpression) {
System.out.println("Inside if statement");
}
La expresión entre paréntesis siempre debe ser una expresión
boolean.
if (x > 3) {
System.out.println("x is greater than 3");
} else {
System.out.println("x is not greater than 3");
}

Expresiones legales e ilegales para una estructura if
int trueInt = 1;
int falseInt = 0;
if (trueInt) // illegal
if (trueInt == true) // illegal
if (1) // illegal
if (falseInt == false) // illegal
if (trueInt == 1) // legal
if (falseInt == 0) // legal

Cuando tenemos muchas estructuras if-else es mas sencillo
utilizar una estructura switch
int x = 3;
switch (x) {
case 1: System.out.println("x is equal to 1");
break;
case 2:
System.out.println("x is equal to 2");
break;
case 3: System.out.println("x is equal to 3");
break;
default:
System.out.println("Still no idea what x is");
}

Las expresiones que son evaluadas por la estructura switch
deben retornar algún tipo char, byte, short, int o enum.
String s = "xyz";
switch (s.length()) {
case 1: System.out.println("length is one");
break;
case 2: System.out.println("length is two");
break;
case 3: System.out.println("length is three");
break;
default:
System.out.println("no match");
}

Ejemplos de declaración ilegales para la estructura switch:
switch(x) {
switch(x) {
case 0 { y =
7;
}
}
0: { }
1: { }
}
La evaluación de cada caso (case) es de arriba hacia abajo,
cuando la constante del case coincide con la expresión del
switch lo podemos considerar un punto de entrada. Esto da
como resultado que se ejecuten todas las instrucciones
subsecuentes (incluyendo las de otros casos) si no existe un
break.

Sin presencia de break
enum Color {red, green, blue}
class SwitchEnum {
Color c = Color.green;
switch(c) {
case red: System.out.print("red ");
case green: System.out.print("green ");
case blue: System.out.print("blue ");
default: System.out.println("done");
}
}
}
Índice

Bibliografía
•Schildt, Herbert. Java 2. Manual de referencia. Cuarta edición, editorial
Osborne Mc Graw Hill. 2001.
•Allen, Mark. Estructuras de datos JAVA. Primera edición, editorial
Addison Wesley. 2004.
Índice

Diapositivas curso programación orientada a objetos en Java

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (13)

Similar a Diapositivas curso programación orientada a objetos en Java

Similar a Diapositivas curso programación orientada a objetos en Java (20)

Diapositivas curso programación orientada a objetos en Java

Notas del editor