Download está la primera parte de java

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