java. java nació el año 1991, por un par de ingenieros de la sun microsystems
Post on 28-Jan-2016
225 Views
Preview:
TRANSCRIPT
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
top related