Java

• Java nació el año 1991, por un par de ingenieros de la Sun Microsystems

• Desarrollaron un código independiente del de la CPU (electrodoméstico), el cual se ejecuta sobre una máquina hipótetica o virtual (JVM)

• Existen muchas clases pre-existentes de Java, por lo cual se dice que no parte de 0.

• Hay un número importante de clases que pertenecen a Java, esta se conoce con el nombre de API

• Java incorpora muchos aspectos que otros lenguajes no consideraban como (threads, seguridad, componentes, ejecución remota, acceso a base de datos, etc.)

• El objetivo principal de Java es poder ser un nexo Universal, el cual pueda conectar independientes del contexto, ya sea de manera remota, por web, o a través del acceso a una base de datos

La aplicacion Hello World

• Crear un archivo llamado Hello.java con: public class Hello { Public static void main (String[] args) { System.out.println("Hello World!"); } } • Compilar con: javac Hello.java • Ejecutar con: java Hello

Experimento 1: cambio de nombre.

• Borre el archivo Hello.class

• Cambie el nombre del programa de Hello.java a Hola.java

• Recompile con: javac Hola.java

• Restaure nuevamente el nombre a Hello.java

Experimento 2: main sin argumentos.

• Suprima el argumento ``String[] args'' en main( ... )

• Recompile y ejecute. • En java hay sobrecarga de métodos: un método

se identifica por su nombre, el número de argumentos y tipo de argumentos que recibe. El método main() es distinto del método main(String[]).

• Vuelva colocar ``String[] args'' en main( ... )

Tipos primitivos en Java

• Java posee tipos primitivos casi idénticos a los de C:

• Tipos idénticos: int, long, short, float, double.

• El que cambia: char, sólo almacena caracteres.

• Los nuevos tipos: byte: un entero de un byte.

• boolean: para alamacenar true o false

Constantes

• Usan la misma sintaxis de C:

• Constantes enteras: 1, 0, 1024, -5, 1L, etc.

• Constantes reales: 1.0, -3.14159, 1.5e4, 1.0f, etc.

• Constantes de caracteres: 'a', '1', '+', etc.

• Constantes de strings: "Hola, ", "12 de Noviembre de 1996", etc.

• Constantes booleanas: true y false.

Declaraciones

• Para los tipos primitivos la sintaxis es la misma de C:

• int i; // Un entero • int i= 1; // Un entero inicializado • double pi= 3.14; // Un número real• char c= 'a'; // Un caracter • boolean end= false; // Un valor de verdad• Las declaraciones son instrucciones y por lo

tanto se pueden mezclar declaraciones con otras instrucciones sin problemas

Expresiones

• Las expresiones se forman con casi los mismos operadores de C:

• Aritméticos: a + 2 * c / ( d % 3)

• Lógicos de bits: (~(a>>3) & (b | 1)) << 3

• Pre y postincremento: i++, j++, --i, ++j

• Relaciones: a>=1, b<5, c!=4, d==-1, etc.

• Booleanos: a>1 || a==2 && ! c==1

• Casts: (int) pi

• Otros: a==1 ? a+1 : a-1

Operadores de asignación

• Se usa la misma sintaxis de C: a= 1;

• = es un operador como en C: a=b+2;

• También existen: += -= *= ...

• Java realiza conversiones implícitas, pero es más estricto que C.

Conversiones implícitas

• El rango de un tipo numérico es el intervalo de valores que se pueden almacenar en variables de ese tipo.

• Java no reclama cuando se convierte de un tipo de rango menor a uno de mayor rango.

• Obs: byte < short < int < long < float < double

• int i= 1;

• long l= i; // Ok

• l= 1000000000000;

• float f= l; // Ok.

• Java no acepta conversiones de tipos de menor rango a tipos de mayor rango

• double d= 1.0e24;

• int i= d; // Error durante la compilación float f= 1.0f;

• int i= f; // Error durante la compilación short s= i; // Error durante la compilación

• Java sí acepta cualquier conversión usando casts:

• double d= 1.0; int i= (int)d; // Ok en compilación

• Java no avisa en caso de errores de conversión numéricos.

• int i= 256; byte b= (byte)i; // b==0!

Instrucciones

• Java posee prácticamente las mismas instrucciones de C:

• Instrucción condicional if.

• Ciclos while y do ... while.

• Ciclos for.

• Selección switch/case.

Ejercicio

• Crear un programa en Java que calcule el factorial de 6

Factorial de 6

public class Fact { public static void main (String[] args) { int n= 6; int f= 1; // También puede ser double

for (int i= 1; i<= n; i++) f= f*i;

System.out.println("El factorial de "+n+" es "+f); // Consola.esperar(); }}

Strings

Declaración de un string:

String s, t; // Declaración

String r= "Hola"; // Declaración con asignación

Despliegue de un string:

System.out.println(r);

String

• Asignación de strings:

s= r;

t= "que tal";

• Concatenación de strings:

s= r+t; // "Holaque tal"

s= r+" "+t; // "Hola que tal"

String

• Tamaño de un string: s.length()

• k-ésimo caracter: s.charAt(k)

• subsecuencias: s.substring(begin, end)

• comparación de strings: s.equals("Hola")

• comparación de referencias: s=="Hola"

String

• Conversiones implícitas:

int n= 5; String s;

s= "La variable n es " + n; System.out.println(s); System.out.println("n= "+n);

String

• Los strings no se pueden modificar:

• s[0]= 'h'; // error, s no es un arreglo s.charAt(0)= 'h'; // error

• Java no posee aritmética de punteros:

• s= s+1; // agrega "1" al final de s