Usuario:Iho jose/diccionario/Z/Zona de estudios/2

Notas de clase de asistencias a curso de Java 8.

IhoJose Studios...📺

0-9

A

Animes
Archivo
Artículos

B

C

D

E

F

G

H

I

J

K

L

M

N

Ñ

O

P

Premios

Q

R

Rango

S

T

Título con estilo

U

Útiles

V

W

X

Y

Z

Zona de pruebas
Zona de estudios
2, 3, 4, 5, 6, 7

editar

Wrapper clases[editar]

Tipo de variable	Wrapper clase
int	Integer
double	Double
float	Float
long	Long
short	Short
boolean	Boolean

Conversión[editar]

public void hacer1() {
    Perro p = new Perro();
    hacer2(p);
    System.out.println(p.pata)
}

public void hacer2(Perro p) {
    
}

Get and Set[editar]

public void setNombre(String nombre) {
    this.nombre = nombre;
}

public void getNombre() {
    return this.nombre;
}

Constructores[editar]

Son usados para inicializar campos en un objeto. (Generalmente se usa para construir un objeto)

Este puede recibir argumentos.
No hay límite de contructores en una clase.

Puede hacerse sobrecarga de constructores.

public class Perro {
    private Perro(String nombre) {
        super(); // Está inplicito
    }
    public Perro(int a) {
        this("Hola"); // Llamado de constructores
    }
}

Comparando entre datos String[editar]

public class Employees {
    public String name1 = "Fred Smith";
    public String name2 = "Sam Smith";

    public void areNamesEquals() {
        if (name1.equals(name2)) {
            System.out.println("Same name");
        } else {
            System.out.println("Diferentes");
        }
    }

    public void withIgnore() {
        String a = "H";
        String b = "h";

        if (a.equalsIgnoreCase(b)) {
        }
    }
}

if (++x > 2 & y-- < 1) {
    // Y inclusiva
} else if (++x > 2 && y-- < 1) {
    // Y exclusiva
}

Clase 5[editar]

Herencia[editar]

public class Clothing {
    public void display() {...}
    public void setSize(char size) {...}
}

// ----------------------------------------
public class Shirt extends Clothing {...}

Se usa extenteds, implements, instance of, is-a, para herencia. La herencia se usa para recibir comportamientos de la clase padre. El que hereda es superclase y la clase que recibe la herencia se llama subclase.

public class Animal {
    public void dormir() {
        System.out.println("Duerme")
    }
    // Constructor
    public Animal(int a) {
    }
}

public class Perro extends Animal {
    public static void main() {
        dormir();
        super.dormir();
    }
    public Perro() {
        super(1);
    }
}

public class Gato extends Animal {
}

Sólo existe herencia multiple. private solo se usa en la misma se usa por la misma clase, public donde sea, protected por paquete y herencia, default solo por paquete.

Sobreescritura[editar]

public class Animal {
    protected void dormir() {
        System.out.println("Dormir");
    }
    public Animal comer() {
    }
}

public class Perro extends Animal {
    public void dormir() {
        System.out.println("Duerme un reno");
    }

    public Animal comer() {
    }

    public Gato ronronea() { 
        // Llamado entre hermanas
    } 
}

public class Test {
    public static void main(String[] args) {
        Perro p = new Perro();
        p.dormir();

        Animal a = new Animal();
        a.dormir();

        Animal q = new Perro();
        ((Animal) q).dormir();
    }
}

Se sobreescribe si es igual o más permisivo.

public class Empleado {
    public void dormir() {
    }
}

public class Perro {
    public void metodo(Empleado e) {
        if (a instanceof Ingeniero) {
            int sume = 10000;
        } else if (a instanceof Abogado) {
            int sume = 5000;
        } else {
            int sume = 2000;
        }
    }
}

Clases abstractas[editar]

Son clases que pueden contener métodos abstractos, además de ser las únicas que pueden hacerlo.

public abstract class Clase {...}

public abstract void setColorCode(char colorCode);

No se pueden instanciar. Reglas:[editar]

No se pueden instanciar.
Pueden tener constructores.
Se llaman a través de herencia.
Se deben implementar los métodos de la superclase (clase abstracta).
Una clase abstracta no tiene que implementar los métodos abstractos.

public abstract class Animal {
    public abstract void dormir();
}

public abstract class Mamifero extends Animal {
}

Clase concreta:

public class Perro extends Mamifero {
    public static void main(String[] args) {
        public void dormir() {
            
        }
    }
}

Interfaces[editar]

Son contratos con otras clases o interfaces, la interface es un elemento en el cual yo determino los comportamientos que puede tener una clase.

Una interface solo maneja variables estáticas y constantes estáticas, (Yo puedo heredar de una interface). Implícitamente tienen abstract

public interface Animal {
    public void dormir();
}

public interface Mamifero extends Animal {
    public void hacer();
}

public class Perro implements Animal {
    public void dormir() {
    }

    public void hacer() {
    }
}

Reglas de interfaces:[editar]

No tiene métodos concretos.
Los métodos descritos son implícitamente public y abstract
No pueden tener métodos estáticos ni final
No puede implementar a una interface ni a una clase abstracta ni concreta.
Los atributos son public static final.
El modificador de la interface abstract por defecto
Manejan modificadores public y por defecto.
Son utilizados bajo implementos
No tienen constructores
Cuando se implementan los métodos deben tener el mismo modificador del método o más permisivo
Pueden implementarse más de una interface separadas por comas ",".

// Clase animal

// public class Animal extends Object {
public class Animal extends Object { // Default
    public void comer() {
        // ...
    }
}

// Clase perro
public class Perro extends Animal {
    String nombre;
    // Sobreescritura
    public void comer() {
    }

    public boolean equals(Object a) {
        Perro b = (Perro) a;
        return this.nombre.equals(a.nombre);
    }

    public String toString() {
        return nombre;
    }
}

// Test
public class Algunos {
    Perro p = new Perro();
    Perro p2 = new Perro();
    Perro p3 = new Perro();
    p.nombre = "1";
    p2.nombre = "2";
    p3.nombre = "3";
    
    if (p.equals(p2)) {
        
    }

    System.out.println(p);
}

List[editar]

Diamod "<>";
List<> es una interface.
ArrayList<>() es una clase concreta.

List<String> lista = new ArrayList<>();

// Otro
String[] a = {"1", "2", "3"};
List<String> listaNumeros = new Arrays.asList(a);

// Otro
List<String> miLista = new ArrayList<>();
miLista.add("1");
miLista.add("2");
miLista.add("3");

Regla[editar]

No permite tipos de datos primitivos.

SI	NO
Integer	int
Boolena	boolean
Double	double
Float	float
Long	long
Char	char
Short	short

String [] a = {"a", "q", "c"};
List<String> lista = Arrays.asList(a);

Using a Lambda Expression with replaceAll (Usando una expresión Lambda con replaceAll)[editar]

String[] a = {"a", "q", "c"};
List<String> lista = Arrays.asList(a);

lista.replaceAll(a -> a.toUppercase); // Unary Operator


// forma
lista.replaceAll((String a) -> {return a.toUppercase();})

Reglas:[editar]

Necesita parámetros de entrada.
Debe tener un cuerpo.
Siempre tendrá un valor de retorno.
Sólo usa operadores unitarios.
Sólo devuelve valores del mismo tipo de dato del valor de entrada.

The Predicate Lambda Type[editar]

Puede resibir cualquier tipo de dato y devuelve un boolean.

removeIf: toma una expresión de tipo Predicate y permite verificar los datos para remover datos condicionados.

// Remover si encuentra el String "Rick" en a
lista.removeIf(a -> a.equals("Rick"));

// Remover si a es menor a 5 caracteres.
lista.removeIf(a -> a.length() < 5);