INSTRUCCION DE ASIGNACIÓN

El operador de asiganción es = La sintaxis es

variable = expresion

El tipo de la variable y el de la expresión deben coincidir En algunos casos que veremos java realiza una conversión implícita

int numEntero = 19;
float numFloat;
numFloat=numEntero //Java realiza la conversión
numEntero=numFloat;//Error no deja realizar esta conversion

Examine el siguiente código

public class AsignacionEnteros {
	public static void main(String lista[]){
		int numEntero=10;
		float numFloat;
		numFloat=numEntero; //Java realiza la conversión
		//numEntero=numFloat;//Comentamos esta línea ya que da Error 
		System.out.print("Valor de entero  "+numEntero+" y de float "+numFloat);
	}//End Main
}//End Caracteres

Genera la siguiente salida

Valor de entero  10 y de float 10.0

Conversiones entre tipos

• Las conversiones implícitas se realizan en la asignación
• También tienen lugar en las operaciones aritméticas

Conversiones por cast

• Este tipos de conversiones se fuerzan

la sintaxis para esta conversion es

(tipo_a_convertir)expresion

vamos a considerar expresión un valor o una variable Analicemos el siguiente código

public class Casting {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
       int a=150;
       double d=1235.345675;
       //System.out.println("Valor en formato boolCopi
====Asignacion entre objetos====
<source lang=java>
import java.util.Scanner;
public class Definicion {
	public static void main(String []a){
		String nom;
		Scanner l1,l2;
		l1=new Scanner(System.in);
		l2=l1; //En realidad son el mismo elemento ya que son la misma dirección de memoria
		System.out.println("dame tu nombre que leeré con L2");
		nom = l2.next(); //introduzco Manuel Romero Miguel Perez
		System.out.println("Leyendo de L2 " +nom);// Visualiza Manuel
		System.out.println("dame tu nombre L1");
		nom=l1.next();//No espera ya que todavia tiene en el buffer Romero Miguel Perez 
		System.out.println("Leyendo de L1 " +nom); //Visualiza Romero
        nom = l2.next();
        System.out.println("Resto de  L2 " +nom);//Visualiza Miguel
        nom = l1.next();
        System.out.println("Resto de  L1 " +nom);//Visualiza Lopez
	}
}

Resultados

Salida del código anterior

dame tu nombre que leeré con L2
Manuel Romero Miguel Pérez
Leyendo de L2 Manuel
dame tu nombre L1
Leyendo de L1 Romero
Resto de  L2 Miguel
Resto de  L1 Pérez

Probar a que l1 y l2 sean dos objetos diferentes

l1=new Scanner(System.in);
l2=new Scanner(System.in);

Y no hacemos la asignacion l2=l1

Pregunta

observamos la diferencia? ahora l1 y l2 son dos buffers diferente cada uno guarda historia de lo que almacea

la expresion

Tipos de expresiones

1. un literal
2. expresion booelana
3. expresion aritmética

Un literal

Es un valor directo Pueden ser de los siguientes tipos

1. literal entero
2. literal real
3. literal caracter
4. literal cadena de caracteres String

Literales enteros

Se pueden expresar en 3 sistemas numéricos diferentes Sistema decimal sistema octal sistema hexadecimal

public class Literales {
	public static void main(String []lista){
		System.out.println("Valor del número 10 en decimal "+10);
		System.out.println("Valor del número 10 hexadecimal  "+0x10);
		System.out.println("Valor del número 10 octal en decimal "+010);
	}
}

Literales long

Simplemente le acompañamos al literla de L

long num = 100L;

Literales de números reales

• Para representar números reales una de dos opciones
  • introducimos el punto decimal ç
  • utilizamos la notación científica. Por ejemplo:

double v = 300000.0;  // notación normal
double v = 3.0e+5;     // notación -científica
double v = 3.0E+5;     // notación -científica

El signifiado de v en notación científica es [math]3.0 * 10 ^5[/math]

v=30000D; 
v=30000d;
float a;
a=3009F;
a=3002f;

Literales char

• El valor de esta varialbe es un código Unicode.
• En el código ASCII había escasez de caracteres para cierto alfabetos
• Un literal de tipo char se expresa encerrando el carácter entre comillas simples:

char caracter = 'l';

• Alternativamente se puede expresar directamente con el código Unicode en hexadecimal

char caracter ='\u0064';

El primer byte de la codificación Unicode es la misma que el código ASCII

• Por ejemplo el 64 en hexadecimal es 0x40

public class Literalchar {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
       char arroba='\u0040';//64 en hexadecimal
       System.out.print("Valor de arroba "+arroba);
	}
}

Caracteres especiales

Lo forman dos conjuntos de caracteres

• secuencias de escape
  • empiezan por el caracter \
  • se pueden incluir en cualquier cadena de caracteres literal
  • tendrán el significado asociado
  • la lista son \n \r \t \f \\ \' \" \b

public class SecuenciaEscape {
	public static void main(String []lista){
		System.out.println("Secuencia de escape \t tabula \n nueva línea \r retorno de carro   \\ visualiza la barra");
		System.out.println("Secuencia de escape: \f nueva página  quitar ultima r de carcter\b \' \"");
	}
}

• especificadores de tipo y/o formato
• *Se usan para método con formato
  • también para el método System.out.printf()

%d entero %o entero en octal %f float %t date %c caracter

Literales boolean

• tiene dos valores

true
false

• Forman parte de las palabras reservadas del lenguaje
• No es puede realizar conversiones con tipos entero como ocurre en lenguajes como c

public class LiteralBool {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
       boolean seguir = false;
       System.out.print("Valor de seguir "+seguir);
	}
}

Literales String

String es una clase de java.util Como clase que es tiene métodos que iremos estudiando Un valor String se expresa entre cadena de caracters dobles Existe el operador + sobrecargado para concatenar String

String curso = "Programador de aplicaciones orientada a objetos";

Ejemplos de valores literales

Las expresiones

Una expresión la definimos como un predicado con operandos y operadores susceptible de ser evaluada y retornar un valor de un determinado tipo

La expresion tiene

1. tipo en función de los operandos y operadores
2. operando/s en función del tipo de expresion
3. operadores en función del operando

• A continuación estudiaremos los operandos, puesto que los operadores son valores ya vistosç

Operador de asignación

=

Operadores aritméticos

• Realizan las operaciones aritméticas básicas:
• Son operaciones binarias
  • suma (+)
  • resta (-) también el operador unario cambio de signo

a=-8

• • multiplicación (*)
  • división (/)ç

(entera si los operandos son enteros y real si son reales 5/6=0 5.0/6.0=0.83

• • módulo (%)

public class Aritmetica{
	public static void main(String[] args){
		int i      = 12;
		int j      = 10;
		System.out.println(i+"+"+j+"="+(i+j));
		System.out.println(i+"-"+j+"="+(i-j));
		System.out.println(i+"*"+j+"="+(i*j));
		System.out.println(i+"%"+j+"="+(i%j));
		System.out.println("Division entera "+i+"/"+j+"="+(i/j));
		System.out.println("Division real "+i+"/"+j+"="+((float)i/(float)j));
		System.out.println("Cambio de signo de "+i+"="+(-i));
		System.out.println("Cambio de signo de "+j+"="+(-j));
	}
}
 
*Observamos la siguiente operacion
*Analicemos el resultado
public class IntGrande{
	public static void main(String[] args){
		int j = 2147483647;
		int i = j + 1;
		System.out.println("El valor obtenido es " + i);
 
	}
 
}
 
 01111111111111111111111111111111 : 2147483647 en números binarios.
 00000000000000000000000000000001 : le sumamos 1
 10000000000000000000000000000000 : Resultado: -2147483648 complemento a 2
 
 
*Esta situación se la conoce como “overflow” (desbordamiento).
{{Pregunta||Que ocurre al dividir por 0
Ocurre lo mismo en division entera que en float
Lo probamos}}}
 
==Operadores aritméticos unarios==
*cambiar el signo del valor '''(+ -)'''
*Operador de autoinclremento y autodecremento
*Pueden ser prefijos y sufijos
 int i = 1; 
 i++; 
 ++i; 
 i--;
 --i;
 
En el caso de prefijo primero hace el incremento/decremento y luego evalúa el valor
En el caso de postfijo primero evalúa el operador y luego realiza en incremneto/decremento
 
<source lang=java>
public class PrePostIncremento{
	public static void main(String[] args){
		int i = 2;
		int j = 2;
		System.out.println(i++);
		System.out.println(++j);
		System.out.print("Estado Final (i) :");
		System.out.println(i);
		System.out.print("Estado Final (j) :");
		System.out.println(j);
	}
}

Asignación y operación en la misma instrucción

En la asignación puedo aplicar una operación con la propia variable asignándole a la misma el resultado

a+=1; ==> a=a+a ==> a++ ==> ++a
b-=a;== b=b-a;
c*=8;==>c=c*8;
d%=6;==>d=d%6
b/=2;==> b=b/2

Operacores Relacionales

• En java disponemos de los operadores relacionales
• Son expresiones que tienen un tipo booleano asociado
• Estos operadores verificas si se cumple o no una comparación entre términos
• Una expresión relacional me devuelve un valor booleano
  • true si la condición de comparación es cierta
  • false en caso de que no sea cierta

Aquí tenemos un programa para ver el funcionamiento de estos operadores :

public class relaciones {
   public static void main(String args[]){
       int    i = -3;
       byte   b = 5;
       float  f = 1e-10f;
       double d = 3.14;
       boolean b1 = i > i;
       boolean b2 = i < b;
       boolean b3 = b <= f;
       boolean b4 = f >= d;
       boolean b5 = d != 0;
       boolean b6 = 1 == f;

       System.out.println("b1: " + i + " > " + i + " = " + b1);
       System.out.println("b2: " + i + " < " + b + " = " + b2);
       System.out.println("b3: " + b + " <= " + f + " = " + b3);
       System.out.println("b4: " + f + " >= " + d + " = " + b4);
       System.out.println("b5: " + d + " != " + 0 + " = " + b5);
       System.out.println("b6: " + 1 + " == " + f + " = " + b6);
   }

}

• Los caracteres también se pueden comparar
• Internamente están almacenados con el código unicode numérico

char a = 'A';
char b = 'B';
boolean x = a > b;

Entre los booleanos solo se permiten los operadores de equivalencia, es igual (==) o es distinto (!= )

boolean x = true;
boolean y = x == x;
boolean z = x != y;

Expresiones Booleanas con operadores booleanas

• Otro tipo de expresion booleana nos la dan las expresiones en las que intervienen operadores booleanos
• En la tabla siguiente se muestran los operadores booleanos
• es muy importante ver la diferencia entre & (no cortocircutado) y && (funciona con cortocircuito)

Como deben suponer, trabajan con operandos booleanos. Realizan las operaciones lógicas de conjunción (AND), disyunción (OR), negación (NOT) y la disyunción exclusiva (XOR).