Operadores logicos y aritmeticos
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sn = new Scanner(System.in);
int option = 0;
System.out.println("Seleccione una opción:");
option = sn.nextInt();
switch(option){
case 1:
System.out.println("Opcion 1");
break;
case 2:
System.out.println("Opcion 2");
break;
}
}
}Son condicionales en una sola linea
// Teoria
// variable = (condicion) ? valor_si_verdadero : valor_si_falso
int vehiculoId = 5;
String vehiculoTipo;
vehiculoTipo = (vehiculoId <= 3) ? "Auto" : "Moto";
System.out.println(vehiculoTipo);int i = 0;
while (i < 5) {
System.out.println(i);
i++;
}for(init; condicion; mod){
}
for(int i=0; i<=10; i++)int vector [] = new int [5];
vector[0] = 1;Double matriz [][] = new Double[4][4];
matriz[0][0] = 4Double a entero y long
double num = 1.97;
int numInt = (int) num; // double a entero
System.out.println(numInt); // 1
long numLong = (long) num; // double a long
System.out.println(numLong); // 1String a entero y double
String cant = "15"; //String es una clase
String price = "150.27";
int cantInt = Integer.parseInt(cant);
double priceDouble = Double.parseDouble(price);
System.out.println(cantInt + priceDouble);Entero y double a String
int age = 30;
double height = 1.67;
String ageString = String.valueOf(age);
String heightString = String.valueOf(height);
System.out.println(""+ageString+" / "+heightString);Pablabra clave utilizada para definir un tipo de dato especial que representa un conjunto fijo de constantes. Estas constantes son valores predefinidos que representan elementos distinto de un conjunto.
Entre sus metodos estan:
- name(): Devuelve String con el nombre de la constante
- ordinal(): Devuelve un entero con la posición del enum
- values(): Devuelve un array con todos los elementos
- valesOf(String name): Obtener constante del nombre indicado
enum Days {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
Days day = Days.MONDAY;
System.out.println(""+day+" / "+ day.ordinal());
System.out.println("----------------");
for (Days d : Days.values()) {
System.out.println(d);
}
System.out.println("----------------");- Son un tipo particular de clase que no pueden ser instanciadas.
- Se usan como molde para nuevas clases usando herencia.
- Uno de sus metodos debe ser abstracto, para que las clases hijas las hereden e implementen como quieran.
- Puede ser public o protected, pero no private.
- Una clase no puede heredar de varias clases abstractas a la vez.
- Indicas es "ES/SER" de un objeto.
public abstract class Figura{
protected double x;
protected double y;
public abstract double calcularArea();
}
public class Cuadrado extends Figura{
@Override
public double calcularArea(){
//custom mehod
}
public class Circulo extends Figura{
@Override
public double calcularArea(){
//custom method
}
}- Son una coleccion de metodos abstractos con atributos constantes
- Una interfaz solamente puede extender o implementar otras interfaces (herencia multiple)
- Solo da a conocer metodos abstectos publicos
- Solo puede tener variables public static final (constantes)
- Indican que puede hacer un objeto
public interface ICalculable {
int iva = 19;
int physicalDiscount = 14;
int digitalDiscount = 20;
int getTotalPurchase();
int discount();
int getTotal();
}Es cuando una clase tiene dos metodos llamados igual, pero con distintos parametros de entrada, ya sea por cantidad o tipo de dato entrante.
public class Calculator {
// dos integers
public int add(int a, int b) {
return a + b;
}
// tres integers
public int add(int a, int b, int c) {
return a + b + c;
}
// dos double
public double add(double a, double b) {
return a + b;
}
}Metodo de una clase hija que tambien es declarado como metodo abstracto en la clase abstracta(@Override). Hace uso de herencia y polimorfismo.
En este ejemplo, la clase "Dog" y "Cat" heredan de "Animal"
public abstract class Animal {
public abstract void makeNoise();
}class Dog extends Animal {
@Override
public void makeNoise() {
System.out.println("Woof! Woof!");
}
}
class Cat extends Animal {
@Override
public void makeNoise() {
System.out.println("Meow! Meow!");
}
}Animal genericAnimal = new Animal();
Animal dog = new Dog();
Animal cat = new Cat();
Animal cow = new Cow();
genericAnimal.makeNoise();
dog.makeNoise();
cat.makeNoise();Son estructuras similares a los arreglos, pero con las principal caracteristica de que son "dinamicos" en tamaño y cantidad de elementos. Estas se emplean mediante la interfaz "Collection", que permite emplear distintos metodos.
Tipos de colecciones:
- List
- Set
- Queue
- Map
Conjunto de elemenntos relacionados entre si que tienen determinado orden. Su tamaño es dinamico y existen de tipo:
- ArrayList
- LinkedLists
- Stack.
Tipos de orden que pueden tener las listas:
- FIFO (First in first out)
- LIFO (Last in first out)
- Son una clase que se representa como una matriz dinamica que permite almacenar elementos
- Hereda de la clase AbstractList, la cual implementa la interfaz List
- Permite colecciones o duplicados
- El orden de los registros es el orden en que fueron insertados(FIFO)
- Permite indice y es de manipulacion lenta(recorre todo el arraylist para hacer el cambio).
//Declarar arraylist de clase Persona(num, nombre, edad)
//List<Persona> list;
List<Persona> lista = new ArrayList<Persona>();
//Agregar elemento a la lista
lista.add(new Persona(1, "John", 23));
//Recorrer lista por indice
for(int i=0; i<lista.size(); i++){
System.out.println(lista.get(i).getNombre());
}
//Recorrer con foreach
for(Persona p:lista){
System.out.println(p.getNombre());
}
//recorrer la lista con una función lambda
lista.forEach(listar - >{
System.out.println(listar + " " ) ;
}) ;
// Borrado de elementos
lista.remove(1);- Es una clase que representa a una lista doblemente enlazada
- Permite duplicados
- Mantiene orden de insercion (FIFO)
- Puede ser tratada como una lista, pila o cola
- Permite hacer inserciones o eliminaciones al principio o final de la colección
//Declarar linkedList
List<Persona> lista = new LinkedLists<Persona>();
//Agregar elemento a la LinkedLists
lista.add(new Persona(1, "John", 23));
//Agregar elemento al principio LinkedLists
lista.add(0, new Persona(2, "Max", 21));
//Recorrer con foreach
for(Persona p:lista){
System.out.println(p.getNombre());
}
// Borrado de elemento
for (Persona p : listaLinked) {
if (p.getNombre().equals("Gabriel")) {
lista.remove(p);
break;
}
}
//Obtener primer y ultimo
lista.getFirst().toSring();
lista.getLast().toSring();//Tamaño en ambos
lista.size();
//Otros
lista.clear();
lista.isEmpty();Hace referencia a cuando tienes una "pila de objetos"
Stack<Integer> pila = new Stack<Integer>();
// esta vacia?
pila.isEmpty();
//agregar
pila.push(1);
//recorido
for(Integer p:pila){
sout(p);
}
pila.search(2); //Buscar por posicion
pila.pop(); //Elimina el ultimo registro
pila.peek(); //Ver ultimo elementoColeccion de par llave-valor, equivalente a diccionario en Python.
- put(C clave, V valor: Agregar un par clave-valor a la collection Map
- get(Object clave): Devuelve el valor asociado a la clave brindada o null si la clave no existe.
- containsKey(Object clave): Verifica si el Map contiene la clave especificada
- containsValue(Object valor): Comprueba si el Map contiene el valor especificado, devuelve boolean.
- remove(Object clave): Elimina el registro asociado a la clave brindada.
- keySet(): Devuelve un conjunto de todas las claves en el Map.
- values(): Devuelve una colección de todos los valores que contiene el Map.
- clear()
- size()
// Declarar Hash Map
Map<integer, String> mapEmployee = new HashMap<>();
// Agregar
mapEmployee.put(1, "John Rambo")
// contains
boolean isEmployee = mapEmployee.containsValue("John Rambo");
boolean isEmployeeKey = mapEmployee.containsKey(1);
// Devuelve valores como array/lista
mapEmployee.values();
mapEmployee.keySet();
for (integer i : mapEmployee.values()) {
System.out.println(i);
}Ejemplo relación Cliente-Ticket, la relación se hace desde la segunda entidad (en este caso, ticket)
public class Ticket {
public int number;
public int row;
public int seat;
public Date purchase_date;
public Date validity_date;
public int price;
// Relacion con cliente, con sus getter y setters
public Customer customer;
}Ejemplo relación Auto-Cliente (Un auto puede tener varios clientes) y la relación se hace desde el "1"
public class Car {
public Long id;
public String brand;
public String model;
// Relación con cliente, con sus getter y setters
public List<Customer> listCustomers;
}Car car = new Car();
car.setId(1L);
car.setBrand("Kia");
car.setModel("K4 Sedán 2025");
List<Customer> listCustomers = new ArrayList<Customer>();
Customer customer = new Customer();
customer.setId(35);
customer.setName("John Rambo");
listCustomers.add(customer);
car.setListCustomers(listCustomers);