ATAJOS (se activan con TAB)
psvm = public static void main (String[] args){}
sout = [Link]("");
PARA LEER LO QUE INGRESA EL TECLADO
import [Link]
static Scanner teclado = new Scanner ([Link]);
Métodos asociados
variable = [Link]() //lee el texto del teclado
variable = [Link]() // Lee un número entero
variable = [Link]() // Lee un número con decimal
variable = [Link]() //permite el uso del espacio en un String.
IMPORTANTE: Si antes se llamo a un nextInt o nextFloat para usar el nextLine hace
falta hacerlo dos veces. Esto es porque queda el "Enter" como último caracter
guardado en el objeto Scanner.
COMPORTAMIENTO DEL .next()
Cada vez que ingresamos un espacio en blanco cuando utilizamos el método next() los
caracteres que siguen al espacio en blanco son recuperados en la siguiente llamada
al método next()
METODO PARA COMPARAR STRINGS
[Link](String2)
El método es Case Sensitive.
[Link](String2)
El método NO es Case Sensitive.
TIPOS DE VARIABLES
int = Enteros
String = Texto
Double = Decimales
TIPOS DE DATOS
PRIMITIVOS
NUMERICOS ENTEROS
byte
short
int
long
NUMERICOS EN PUNTO FLOTANTE
float
double
BOOLEANOS
bool
CARACTERES
char
CADENAS DE CARACTERES
String
VECTORES
Array
NULOS
void
ESTRUCTURADOS (CLASES)
Clases de la biblioteca Estándar de Java
Clases de terceros
Clases propias
ENVOLTORIO (WRAPPER)
TIPOS PRIMITIVOS "ENVUELTOS" EN UNA CLASE
Objetos
CONVERTIR A OTRO TIPO DE DATOS
String uno = "444";
int dos = [Link](uno); CONVERTI DE STRING A INTEGER
String tres = [Link](dos); CONVERTI DE INTEGER A STRING
OPERACIONES ARITMETICAS
int uno = 2;
int dos = 3;
int suma = uno + dos
int resta = uno - dos
int multi = uno * dos
double div = uno / dos
int modulo = uno & dos EL RESTO DE UNA DIVISION
double potencia = [Link](2 ,5)
[Link](potencia);
o bien
[Link](uno + dos);
[Link](uno - dos);
[Link](uno * dos);
[Link](uno / dos);
[Link](uno & dos);
int uno = 10;
int uno+= uno; ES LO MISMO QUE uno = uno + uno
int uno+= 30; SUMARLE TREINTA
int uno-=6; Y TODAS LAS OPERACIONES ARITMETICAS
FUNCIONES RELACIONALES (DEVUELVEN TRUE O FALSE)
int uno = 10
int dos = 20
[Link](uno == dos); QUIERO SABER SI uno ES IGUAL A dos
[Link](uno != dos); QUIERO SABER SI uno ES DISTINTO A dos
[Link](uno < dos); QUIERO SABER SI uno ES MENOR A dos
[Link](uno > dos); QUIERO SABER SI uno ES MAYOR A dos
[Link](uno <= dos); QUIERO SABER SI uno ES MENOR O IGUAL A dos
[Link](uno >= dos); QUIERO SABER SI uno ES MAYOR O IGUAL A dos
OPERADOR CONDICIONAL
int uno = 10
int dos = 20
if(uno = dos){
[Link]("Los números son" + uno + "y" + dos ". Los números son
iguales")
}
else{
[Link]("Los números son" + uno + "y" + dos ". Los números no son
iguales")
}
OPERADORES LÓGICOS
int uno = 10
int dos = 20
int tres = 30
AND
[Link](uno == dos && dos < tres); AMBAS CONDICIONES DEBEN CUMPLIRSE
OR
[Link](uno == dos || dos < tres); AL MENOS UNA CONDICION DEBE CUMPLIRSE
XOR (O EXCLUSIVO)
[Link](uno == dos ^ dos < tres); SOLO UNA CONDICION DEBE CUMPLIRSE
INVERTIR OPERADOR
[Link](!(uno == dos)); SI ES TRUE VA A DEVOLER FALSE Y VICEVERSA
OPERADORES INCREMENTALES
int uno = 1;
uno++; LE AGREGA UNA UNIDAD A LA VARIABLE uno LUEGO DE LEERLA
++uno; LE AGREGA UNA UNIDAD A LA VARIABLE uno ANTES DE LEERLA
uno--; LE RESTA UNA UNIDAD A LA VARIABLE uno LUEGO DE LEERLA
--uno; LE RESTA UNA UNIDAD A LA VARIABLE uno ANTES DE LEERLA
OPERADORES CONCATENACION
String uno = "Tomasson";
int dos = 89
[Link](uno + dos) CONCATENA DIFERNTES TIPOS DE DATOS: Tomasson89
OPERADORES DE BITS
<< A << B; DESPLAZA A A LA IZQUIERDA EN B POSICIONES
>> A >> B; DESPLAZA A A LA DERECHA EN B POSICIONES (TIENE EN CUENTA SIGNO)
>>> A >>> B; DESPLAZA A A LA DERECHA EN B POSICIONES (NO TIENE EN CUENTA SIGNO)
& A & B; OPERACION AND A NIVEL DE BITS
| A | B; OPERACION OR A NIVEL DE BITS
^ A ^ B; OPERACION XOR A NIVEL DE BITS
~ A ~ B ; OPERACION COMPLEMENTO A NIVEL DE BITS
PREGUNTAR POR instanceof
ESTRUCTURAS DE CONTROL CONDICIONAL
IF
int uno = 100
if(uno = 99){
[Link]("ES CORRECTO")
}
else{
[Link]("NO ES CORRECTO")
}
SWITCH
int uno = 5
switch(uno) {
case 1: [Link]("El valor es 1");break;
case 2: [Link]("El valor es 2");break;
case 3: [Link]("El valor es 3");break;
case 4: [Link]("El valor es 4");break;
case 5: [Link]("El valor es 5");break;
case 6: [Link]("El valor es 6");break;
case 7: [Link]("El valor es 7");break;
default: [Link]("El valor no está entre 1 y 7");break;
}
TRY
try{
uno = 4/0;
} catch(Exception e) {
[Link](e);
}
CON ESTE CODIGO EL PROGRAMA INFORMA EL ERROR PERO NO SE DETIENE, CONTINUA
ESTRUCTURAS DE CONTROL ITERATIVA
WHILE
int uno = 1;
while(uno<7){
[Link]("El valor " + uno + " no es suficiente. Sumando una unidad.");
uno++;
}
DO WHILE
do{
[Link]("El valor " + uno + " no es suficiente. Sumando una
unidad.");
uno++;
}while(uno<7)
FOR
for(int i = 1; i < 10; i++){
[Link]("El valor es " + i + ". Sumando unidad.")
}
FOR EACH (RECORRIENDO UN ARRAY)
String[]semana = {"Lunes", "Martes"; Miércoles", "Jueves", "Viernes"};
for (String i:semana){
[Link](i); ME VA A IMPRIMIR TODOS LOS DIAS DE LA SEMANA
}
FOR CON IF DENTRO
for (int uno=1; uno<=10; uno++){
if (uno==5) { EL IF ROMPE EL FOR Y TERMINA EL ALGORITMO CUANDO uno = 5
break;
}
if (uno > 2 && uno < 4){ EN ESTE CASO SE VA A SALTAR LA ACCION CUANDO uno = 3
continue;
}
}
ARRAYS o VECTORES
Un vector es una estructura de datos que permite almacenar un CONJUNTO de datos del
MISMO tipo.
String[]semana =
{"Lunes","Martes","Miercoles","Jueves","Viernes","Sabado","Domingo"};
String[]semana = new String[7]; ASIGNO CUANTOS ELEMENTOS VA A TENER
ASIGNAR VALORES
semana[0] = "Lunes";
semana[1] = "Martes";
semana[2] = "Miercoles";
semana[3] = "Jueves";
semana[4] = "Viernes";
semana[5] = "Sabado";
semana[6] = "Domingo";
[Link](semana[4]); ESTO VA A DAR "Viernes"
PUEDE SER CUALQUIER TIPO DE DATO
int[]ID_producto = {1,2,3,4,5,6};
Es conveniente llenar o imprimir datos de un vectores con un ciclo For, ya que
conocemos la cantidad de campos que tiene el mismo.
LLENAR DATOS DE UN VECTOR
for(int f=0;f<5;f++) {
[Link]("Ingrese valor del componente:");
sueldos[f]=[Link]();
}
IMPRIMIR DATOS DE UN VECTOR
public void imprimir() {
for(int f=0;f<5;f++) {
[Link](sueldos[f]);
}
}
IMPORTANTE: Se puede usar [Link] como atributo para referirse al tamaño del
vector (esto sirve porque si cambiamos el tamaño del vector no hay que cambiar
todos los algoritmos para ajustar ese cambio). También para cuando el tamaño del
vector lo decide el usuario.
HASHTABLE (Tabla con Identificador y Campo)
import [Link];
Hashtable<Integer, String> vendedores = new Hashtable<Integer, String>;
[Link](1,"Marcos");
[Link](2,"Hernan");
[Link](3,"Franco");
[Link](4,"Jose");
[Link](5,"Veronica");
[Link]([Link](3));
ARRAYS MULTIDIMENSIONALES
int [][] valores = new int[2][2]; TRES FILAS Y TRES COLUMNAS
valores[0][0] = 1 ;
valores[0][1] = 2 ;
valores[0][2] = 3 ;
valores[1][0] = 4 ;
valores[1][1] = 5 ;
valores[1][2] = 6 ;
valores[2][0] = 7 ;
valores[2][1] = 8 ;
valores[2][2] = 9 ;
[Link]([Link]([1][2]) FILA 2 COLUMNA 3 (VALOR = 6)
OTRA FORMA DE INVOCAR UNA TABLA
int[][]valores={{1,2,3}{4,5,6}{7,8,9}};
ARRAYS DENTRO DE ARRAYS (MATRICES)
int[][][]valores={
1{
{1,2,3}{4,5,6}{7,8,9}
}
2{
{10,11,12}{13,14,15}{16,17,18}
}
3{
{19,20,21}{22,23,24}{25,26,27}
}
};
SI QUIERO LLAMAR AL 22
[Link]([Link]([2][1][0]));
LOS DATOS EN UNA MATRIZ SE COMPLETAN CON UN FOR ANIDADO
for(int f=0;f<3;f++) {
for(int c=0;c<5;c++) {
[Link]("Ingrese componente:");
mat[f][c]=[Link]();
}
}
donde f es la fila y c la columna.
PARA IMPRIMIR SUS DATOS TAMBIEN USO EL FOR ANIDADO
for(int f=0;f<3;f++) {
for(int c=0;c<5;c++) {
[Link](mat[f][c]+" ");
}
[Link]();
}
}
IMPORTANTE: [Link](); representa un salto de línea
Las Matrices son OBJETOS y tienen atributos.
[Link] = cantidad de Filas de la Matriz
CREANDO UNA MATRIZ NUEVA
[Link]("Cuantas fila tiene la matriz:");
int filas=[Link]();
[Link]("Cuantas columnas tiene la matriz:");
int columnas=[Link]();
mat=new int[filas][columnas];
CREAR MATRICES IRREGULARES
Primero creamos la cantidad de filas dejando vacío el espacio que indica la
cantidad de columnas:
mat=new int[3][];
Luego debemos ir creando cada fila de la matriz indicando la cantidad de elementos
de la respectiva fila:
mat[0]=new int[2];
mat[1]=new int[4];
mat[2]=new int[3];
ARRAYLIST
import [Link]; IMPORTO LA CLASE
ArrayList<String> tabla = new ArrayList<String>;
[Link]("Lunes");
[Link]("Martes");
[Link](2,"Miercoles"); ACA ESTOY DETERMINANDO EL INDICE AL QUE AGREGO EL STRING
[Link]([Link]((2)); ME DA MIERCOLES
[Link]([Link](); CUANTOS ELEMENTOS TIENE
[Link]([Link]("Martes"); BUSCAR ELEMENTO EN LA TABLA (ME DA
TRUE O FALSE)
[Link]([Link]("Martes"); BUSCAR EN QUE INDICE ESTA EL DATO (En
este caso es 1)
[Link]([Link]("Martes"); EMPIEZA A BUSCAR DESDE EL FINAL AL
PRINCIPIO
[Link](1); BORRO MARTES, AHORA MIERCOLES ES INDICE 1
[Link](); LIMPIA TODOS LOS CAMPOS DE LA TABLA
[Link]([Link](); SABER SI ESTA VACIA, ME DA TRUE OR FALSE
DOS FORMAS DE COPIAR UNA TABLA
ArrayList tabla2 = (ArrayList) [Link]();
ArrayList <String> tabla2 = new ArrayList <String>(tabla);
CONVERTIR ARRAYLIST EN ARRAY
String[] tabla3 = newString[[Link]()];
[Link](tabla3)
[Link](tabla[1]); VUELVO A PEDIR DATOS COMO EN UN ARRAY
CLASES
LAS CLASES TIENEN PROPIEDADES Y METODOS
EJEMPLO MASCOTA: PROPIEDADES (VARIABLES): NOMBRE, EDAD, PESO
METODOS (FUNCIONES): MOSTRAR NOMBRE, CALCULAR FECHA
NACIMIENTO, COSAS QUE HACE LA MASCOTA
OBJETOS
LOS OBJETOS SON UNA INSTANCIACION CONCRETA DE LA CLASE.
object GATO{
Maga
11
5
}
CREAR CLASE Y ASIGNARLE UN PAQUETE
Click derecho en Proyecto: New > New Java Class... DEFINIMOS NOMBRE Y PAQUETE
PUBLIC es un MODIFICADOR, significa que se puede acceder desde diferentes paquetes.
También puede ser PROTECTED o PRIVATE.
CREAR CLASE
package Paquete1;
public class Producto{
int ID_Producto;
String Nombre_Producto;
double Precio;
}
ESTRUCTURA DE UNA CLASE
class [nombre de la clase] {
[atributos o variables de la clase]
[métodos o funciones de la clase]
[main]
}
CONSTRUCTOR DE OBJETOS DE UNA CLASE
El constructor tiene las siguientes características:
Tiene el mismo nombre de la clase.
Es el primer método que se ejecuta.
Se ejecuta en forma automática.
No puede retornar datos.
Se ejecuta una única vez.
Un constructor tiene por objetivo inicializar atributos.
public Producto(int ID, String nom, double P){ ENTRE PARENTESIS LOS PARAMETROS
ID = ID_Producto
nom = Nombre_Producto
P = Precio
}
CREAR OBJETO
Producto Escoba = new Producto(1,"Escoba Genérica",45.00); ENTONCES ES Clase
Objeto = new Clase(Parámetros);
[Link](Escoba.ID_Producto); ME TIENE QUE DAR 1
CREAR METODO
public void remarcar(double NuevoPrecio){ CON VOID LE INDICO QUE NO TIENE QUE
DEVOLVER UN VALOR, SOLO REALIZAR LA ACCIÓN
NuevoPrecio = Precio
Es decir, la estructura es
SI NO RETORNA DATO
public void [nombre del método]([parámetros]) {
[algoritmo]
}
SI RETORNA DATO
public [tipo de dato] [nombre del método]([parámetros]) {
[algoritmo]
return [tipo de dato]
}
USANDO EL METODO
[Link](50.00); LA ESCOBA PASA A VALER 50pe
HERENCIA DE CLASE
public class Clase 1{
String Nombre;
String Apellido;
public class Clase2 extends Clase1{ CON ESTO LE DIGO QUE HEREDE TODOS LOS CAMPOS Y
METODOS DE LA CLASE1, ES DECIR QUEDAN YA DECLARADOS
}
SE PUEDE HEREDAER DE UNA CLASE SOLA
POLIMORFISMO
EL MISMO METODO PUEDE TENER DIFERENTES INSTRUCCIONES EN UNA CLASE QUE LO HEREDA SI
SE ESPECIFICA
CREAR CONSTANTES
final int = 4; SOBRE ESTA CONSTANTE NO SE PUEDE OPERAR
LEER LOS INPUT DEL USUARIO
[Link];
[Link]("Ponga un nombre, por favor.");
Scanner lectura = new Scanner ([Link]);
String nombre = [Link]();
[Link](nombre)
[Link]("Ponga un número, por favor.");
Scanner lectura = new Scanner([Link]);
String nombre = [Link]();
[Link](nombre)
FORMA DE ORGANIZAR UN PROGRAMA QUE PIDE DATOS
- IMPORTO SCANNER
- DECLARO CLASE
- DEFINO VARIABLES
- CREO METODOS QUE CUMPLEN FUNCIONES DE PEDIR DATOS O RESOLVER
- EN EL METODO PRINCIPAL CREO UN NUEVO OBJETO DE LA CLASE y LLAMO A LOS METODOS
PARA RESOLVER EL PROBLEMA.
import [Link];
public Class Programa {
private Scanner teclado;
int num1, num2, num3;
public void inicializar() {
teclado=new Scanner([Link]);
[Link]("Pedir Datos Num1");
num1=[Link]();
[Link]("Pedir Datos Num2");
num2=[Link]();
[Link]("Pedir Datos Num3");
num3=[Link]();
}
public void resolver() {
ACA VAN LAS OPERACIONES CON LOS NUMEROS
OPERADORES LOGICOS; NUMERICOS; CONDICIONALES, ETC
[Link]("LA RESPUESTA ES BLABLA")
}
public static void main (String[] ar) {
Programa numero1;
numero1 = new Programa();
[Link]();
[Link]();
}
}
METODOS DE LA CLASE STRING
[Link](String2) ES UN BOOLEAN
[Link](String2) ES UN BOOLEAN
[Link](String2) ES UN INTEGER da 0 si es menor alfabeticamente >0 si es
mayor alfabeticamente
[Link](int pos) ES UN CHAR, devuelve el caracter que ocupa la posición que
designamos entre paréntesis
[Link]() ES UN INTEGER, cantidad de caracteres del String
[Link](int pos1,int pos2) Es otro String. Retorna un recorte entre los
caracteres que designamos para pos1 y pos2
[Link](String2) ES UN INTEGTER. Retorna -1 si no String2 no esta contenida
en String1. Si esatá contenido retorna la posición donde comienza a repetirse.
[Link]()
[Link]()
Protected es como Private pero permite que las subclases accedan a esos atriutos.