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

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íaProgramación Orientada a Objetos

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; Programación Orientada a Objetos 8

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 -9223372036854775808a

9223372036854775807 Programación Orientada a Objetos 17

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);

}} Programación Orientada a Objetos 22

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 definidospor default como un double (64 bits). Siqueremos asignar un valor literal puntoflotante 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! Programación Orientada a Objetos 26

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 bytebyte c = 8; // No problem, 8 fits in a bytebyte 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 56 Programació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 Programación Orientada a Objetos 44

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 { public static void main (String [] args) {

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. Programación Orientada a Objetos 48


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 changeto b");

}


Índice

Á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() { // constructorx += 8;int x3 = 6;

}

void doStuff() { // method

int y = 0; // local variablefor(int z = 0; z < 4; z++) { // 'for' code block

y += z + x;

}}

}Programación Orientada a Objetos 53


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 {

public static void main(String [] args) { 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



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


public class BirthDate { int year; // Instance variable public static void main(String [] args) {

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 Programación Orientada a Objetos 60

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;

} public static void main(String [] args) {

Book b = new Book() ;

System.out.println("The title is " + b.getTitle());

}

}

The title is null Programació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; } public static void main(String [] args) {

Book b = new Book();

String s = b.getTitle(); // Compiles and runsString t = s.toLowerCase(); // Runtime Exception!

}}Programación Orientada a Objetos 62

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

public class TimeTravel {


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;

public class TimeTravel { public static void main(String [] args) {

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 error Programació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 { public static void main(String [] args) { 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 { public static void main(String[] args) {

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

public static void main(String[] args) {

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; String37int 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; public static void main (String [] args) { 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 2 Programació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



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ónboolean.

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;



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 {

public static void main(String [] args) { 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, editorialOsborne Mc Graw Hill. 2001.

•Allen, Mark. Estructuras de datos JAVA. Primera edición, editorialAddison Wesley. 2004.


Índice

Software

Diapositivas curso programación orientada a objetos en Java