Iniciación a la Programación

@acmupm

2ᵃ Sesión

1. Clases e instancias.

2. Tipos primitivos y referencia. Memoria: stack y heap. Garbage Collector.

4. Herencia y polimorfismo.

6. Interfaces y clases abstractas.

5. Igualdad entre instancias.

 

 

 

 

@acmupm

Clases e instancias

Clase

Instancia

Coche

Marca

Modelo

Color

Matrícula

Combustible

Kilometraje

Tipo de aceite

@acmupm

Clases e instancias

Clase

Instancia

public class Coche {
    private String marca;
    private String matricula;
    private String color;
    private int kilometros;

    public Coche(String marca, String matricula, 
                 String color) {
        this.marca = marca;
        this.matricula = matricula;
        this.color = color;
        kilometros = 0;
    }

    public String getMarca() {
        return marca;
    }

    public String getMatricula() {
        return matricula;
    }

    public String getColor() {
        return color;
    }

    public int getKilometros() {
        return kilometros;
    }

    public int sumarKilometros(int delta) {
        kilometros += delta;
        return kilometros;
    }

    public void resetKilometros() {
        kilometros = 0;
    }
}
Coche c1 = new Coche("Ford", "8086GPL", 
                     "azul");
Coche c2 = new Coche("Volkswagen", 
                     "1989GHC", "rojo");

System.out.println(c1.getMatricula());
System.out.println(c2.getMarca());

@acmupm

Clases e instancias

public class Coche {
    private String marca;
    private String matricula;
    private String color;
    private int kilometros;

    public Coche(String marca, String matricula, 
                 String color) {
        this.marca = marca;
        this.matricula = matricula;
        this.color = color;
        kilometros = 0;
    }

    public String getMarca() {
        return marca;
    }

    public String getMatricula() {
        return matricula;
    }

    public String getColor() {
        return color;
    }

    public int getKilometros() {
        return kilometros;
    }

    public int sumarKilometros(int delta) {
        kilometros += delta;
        return kilometros;
    }

    public void resetKilometros() {
        kilometros = 0;
    }
}
\big\{
{\big\{

Declaración de la clase

Atributos de instancia

\Big\{
{\Big\{

Constructor

\Bigg\{
{\Bigg\{

Getters y setters (encapsulación)

\Bigg\{
{\Bigg\{

Otros métodos

@acmupm

Clases e instancias

Constructor:

  • Método que es llamado cuando se crea una nueva instancia de una clase.
  • Permite dar un primer valor a los atributos del objeto o realizar cualquier otra acción.
  • En su declaración, no se pone ningún valor devuelto, y su nombre es el de la clase en la que está.
public class Coche {
    private String marca;
    private String matricula;
    private String color;
    private int kilometros;

    public Coche(String marca, String matricula, 
                 String color) {
        this.marca = marca;
        this.matricula = matricula;
        this.color = color;
        kilometros = 0;
    }

//El resto de la clase
}
public class USB {
    private int capacidad;
    private int usado;

    public USB(int capacidad, int usado) {
        this.capacidad = capacidad;
        this.usado = usado;
    }

//El resto de la clase
}

@acmupm

Clases e instancias

Modificadores de acceso:

Determinan desde qué puntos del código se puede tener o no acceso a ciertas clases, métodos o atributos.

Modificador Clase Paquete Herencia Otros ámbitos
private ✓ ✗ ✗ ✗
(sin modificador) ✓ ✓ ✗ ✗
protected ✓ ✓ ✓ ✗
public ✓ ✓ ✓ ✓

@acmupm

Clases e instancias

Encapsulación:

Es un patrón de diseño que consiste en poner todos los atributos private, y obtener y/o establecer su valor a través de métodos llamados getters y setters.

Obligatorio su uso!! (bajo pena de suspenso)

public class Whatever {
    private boolean a;
    private int b;

    public boolean isA() {
        return a;
    }

    public void setA(boolean a) {
        this.a = a;
    }

    public int getB() {
        return this.b;
    }

    public void setB(int b) {
        if (b > 1000) {
            this.b = 1000;
        } else {
            this.b = b;
        }
    }
}

(Aprendéroslo para los exámenes pero escribir esto una y otra vez es un p*** coñazo. Cualquier editor de Java que se precie te los puede generar automáticamente :P)

@acmupm

Clases e instancias

Sobrecarga de métodos:

Consiste en declarar más de un método con el mismo nombre, diferenciándose las diferentes definiciones por el tipo y el número de los parámetros.

public int sumar(int a, int b) {
    return a + b;
}

public double sumar(double a, double b) {
    return a + b;
}

Los constructores también pueden tener sobrecargas:

public class Coche {
    // [...]
    public Coche(String marca, String matricula, 
                 String color, int kilometros) {
        this.marca = marca;
        this.matricula = matricula;
        this.color = color;
        this.kilometros = kilometros;
    }

    public Coche(String marca, String matricula, 
                 String color) {
        this(marca, matricula, color, 0);
    }
}

@acmupm

Clases e instancias

Valor null:

El valor null es la "referencia vacía". Indica una ausencia de instancia.

//Esta variable no apunta a ningún objeto.
Coche c1 = null;
c1.getMarca(); //NullPointerException

@acmupm

Tipos primitivos y referencia

Tipos primitivos

boolean, byte, short,
char, int, long,
float, double
short num2 = 9;
int num1 = 5;
0 0 0 5 0 9
\Bigg\{
{\Bigg\{
\Bigg\{
{\Bigg\{
num1
num2

Tipos referencia

Coche c1 = new Coche("7511BXW", "azul");
Coche c2 = new Coche("0912PJK", "verde");
Coche c3 = c1;

 

"7511BXW"
"azul"
"0912PJK"
"verde"

c1

c2

c3

@acmupm

Stack y Heap

public void loquesea() {
    int a = 6;
    int b = a * 5;

    if (a == 6) {
        int c = 7;
        Coche coche = new Coche("1234BCD", "rojo");
        Coche elmismo = coche;
        Coche otro = new Coche("1234BCD", "rojo");
    }
    int d = 6;
}

Stack

Heap

@acmupm

Stack y Heap

public void loquesea() {
    int a = 6;
    int b = a * 5;

    if (a == 6) {
        int c = 7;
        Coche coche = new Coche("1234BCD", "rojo");
        Coche elmismo = coche;
        Coche otro = new Coche("1234BCD", "rojo");
    }
    int d = 6;
}
7
30
6

Stack

Heap

a

b

c

@acmupm

Stack y Heap

public void loquesea() {
    int a = 6;
    int b = a * 5;

    if (a == 6) {
        int c = 7;
        Coche coche = new Coche("1234BCD", "rojo");
        Coche elmismo = coche;
        Coche otro = new Coche("1234BCD", "rojo");
    }
    int d = 6;
}
0x7ffff9a
7
30
6

Stack

Heap

a

b

c

coche

"1234BCD"
"rojo"

@acmupm

Stack y Heap

public void loquesea() {
    int a = 6;
    int b = a * 5;

    if (a == 6) {
        int c = 7;
        Coche coche = new Coche("1234BCD", "rojo");
        Coche elmismo = coche;
        Coche otro = new Coche("1234BCD", "rojo");
    }
    int d = 6;
}
0x7ffff9a
0x7ffff9a
7
30
6

Stack

Heap

a

b

c

coche

"1234BCD"
"rojo"

elmismo

@acmupm

Stack y Heap

public void loquesea() {
    int a = 6;
    int b = a * 5;

    if (a == 6) {
        int c = 7;
        Coche coche = new Coche("1234BCD", "rojo");
        Coche elmismo = coche;
        Coche otro = new Coche("1234BCD", "rojo");
    }
    int d = 6;
}
0x7ffffab
0x7ffff9a
0x7ffff9a
7
30
6

Stack

Heap

a

b

c

coche

"1234BCD"
"rojo"

elmismo

"1234BCD"
"rojo"

otro

@acmupm

Stack y Heap

public void loquesea() {
    int a = 6;
    int b = a * 5;

    if (a == 6) {
        int c = 7;
        Coche coche = new Coche("1234BCD", "rojo");
        Coche elmismo = coche;
        Coche otro = new Coche("1234BCD", "rojo");
    }
    int d = 6;
}
6

Stack

Heap

d

"1234BCD"
"rojo"
"1234BCD"
"rojo"

Garbage Collector al rescate!

@acmupm

Herencia y polimorfismo

class A {

}

class B extends A {

}

class C extends B {

}

class D extends B {

}

@acmupm

Herencia y polimorfismo

public class A {
    public int metodo() {
        return 3;
    }
}


public class B extends A {
    public int metodo() {
        return 9;
    }
}
new A().metodo(); //Devuelve 3;
new B().metodo(); //Devuelve 9;

A objeto = new A();
objeto.metodo(); //Devuelve 3;

A otro = new B();
objeto.metodo(); //Devuelve 9;

@acmupm

Herencia y polimorfismo

Upcasting y downcasting

Se hace un upcasting de un tipo a otro cuando tenemos la certeza de que un tipo se puede interpretar como otro.

Se hace un downcasting de un tipo a otro cuando no estamos seguros de que un tipo puede ser interpretado como otro.

Vehiculo obj1 = new Coche();
Vehiculo obj2 = new Camion();

Coche c1 = (Coche) obj1;
Camion cam1 = (Camion) obj2;

Coche c2 = (Coche) obj2;

@acmupm

Herencia y polimorfismo

Overriding vs. Shadowing

public class A {
    public int metodo() {
        return otro();
    }

    public int otro() {
        return 5;
    }
}

public class B extends A {
    public int otro() {
        return 9;
    }
}
new A().metodo(); //5
new B().metodo(); //9
public class A {
    public int metodo() {
        return otro();
    }

    private int otro() {
        return 5;
    }
}

public class B extends A {
    public int otro() {
        return 9;
    }
}
new A().metodo(); //5
new B().metodo(); //5
public class A {
    public int valor = 5;
    public int metodo() {
        return otro();
    }

    public int otro() {
        return valor;
    }
}

public class B extends A {
    public int valor = 9;
}
new A().metodo(); //5
new B().metodo(); //5

Overriding

Shadowing

Shadowing

@acmupm

Herencia y polimorfismo

Constructores en clases heredadas.

public class A {
    public A(int a, int b) {
        //Whatever
    }
}

public class B extends A {
    public B(int a, int b) {
        super(a, b);
    }
}

Siempre hay que llamar a los constructores de las clases superiores. Si la clase padre tiene algún constructor sin parámetros, la llamada es implícita. Si no, se llama a través de super(parámetros)

@acmupm

Herencia y polimorfismo

Operador instanceof

Vehiculo v1 = new Coche();
Vehiculo v2 = new Camion();

v1 instanceof Coche; // true
v2 instanceof Camion; // true
v2 instanceof Coche; // false

Es un operador que, a la izquierda toma una instancia, y a la derecha un tipo, y devuelve true si el tipo del objeto de la izquierda es hijo, o implementa el tipo de la derecha.

@acmupm

Interfaces y clases abstractas

interface A {
    int b();
    int c();
}

class B implements {
    public int b() {
        return 6;
    }

    public int c() {
        return 1;
    }
}

class C implements {
    public int b() {
        return 3;
    }

    public int c() {
        return 9;
    }
}

Interfaz

Una interfaz es una estructura que define unos métodos, pero no define su cuerpo (el código). Las interfaces se usan para definir la forma que tienen todas las clases que la heredan.

@acmupm

Interfaces y clases abstractas

public interface Figura {
    int nCaras();
    int nVertices();
}
public interface Figura2D extends Figura {
    int area();
}
public interface Figura3D extends Figura {
    int volumen();
}

@acmupm

Interfaces y clases abstractas

public class Rectangulo implements Figura2D {
    private int base;
    private int altura;

    public Rectangulo(int base, int altura) {
        this.base = base;
        this.altura = altura;
    }

    public int area() {
        return base * altura;
    }

    public int nCaras() { return 1; }
    public int nVertices() { return 4; }
}
public class PoligonoRegular implements Figura2D {
    private static final ANGULO_TOTAL = 2 * Math.PI;
    private double nLados;
    private double apotema;
    private double lado;
    public PoligonoRegular(double nLados, double apotema) {
        this.nLados = nLados;
        this.apotema = apotema;
        this.lado = 2 * apotema * 
                    Math.tan(ANGULO_TOTAL / ( 2 * nLados ));
    }

    public int area() {
        int areaTriangulo = lado * apotema / 2.0;
        return areaTriangulo * nLados;
    }

    public int nCaras() { return 1; }
    public int nVertices() { return this.nLados; }
}
public class Cubo implements Figura3D {
    private double lado;

    public Cubo(double lado) {
        this.lado = lado;
    }

    public double volumen() {
        return lado * lado * lado;
    }

    public int nCaras() { return 6; }
    public int nVertices() { return 8; }
}
public class Tetraedro implements Figura3D {
    private double arista;

    public Tetraedro(double arista) {
        this.arista = arista;
    }

    public double volumen() {
        return (Math.sqrt(2) / 12.0) * 
            arista * arista * arista;
    }

    public int nCaras() { return 4; }
    public int nVertices() { return 4; }
}

@acmupm

Interfaces y clases abstractas

public abstract class Multiplicador {
    public double multiplicar(double numero) {
        return base * altura;
    }

    public abstract double factor();
}

Clase abstracta

Una clase abstracta es una clase parcialmente implementada. Es decir, puede definir funciones con cuerpo y sin él, que tendrán que completar las clases hijas. No se puede construir directamente.

public class Duplicador extends Multiplicador {
    public double multiplicar(double numero) {
        return base * altura;
    }

    public double factor() {
        return 2.0;
    }
}
public abstract class Figura2D
    implements Figura {
    public int nCaras() { return 1; }
}

@acmupm

Igualdad entre instancias

Coche c1 = new Coche("1234BCD", "rojo");
Coche c2 = c1;

c1 == c2; //true

Coche c3 = new Coche("1234BCD", "rojo");

c1 == c3; //false

Identidad vs. Estado

La identidad es algo propio y único de cada instancia. Dos instancias que se encuentran en la misma región de memoria son, a todos los efectos iguales y se dicen que tienen la misma identidad. La identidad compara con el operador ==

@acmupm

Igualdad entre instancias

Coche c1 = new Coche("1234BCD", "rojo");
Coche c2 = new Coche("1234BCD", "rojo");

c1.equals(c2); // false

Identidad vs. Estado

Llamamos estado al conjunto de todos los valores de los atributos de una instancia en un momento determinado. Podemos comparar dos instancias a través de su estado pero solo si antes hemos sobreescrito el método equals() de Object para ello.

Tal como está ahora mismo esto es equivalente al ==

Coche c1 = new Coche("1234BCD", "rojo");
Coche c2 = new Coche("1234BCD", "rojo");

c1.equals(c2); // true
public class Coche {
    private String matricula;
    private String color;
    //[...]

    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(this instanceof Coche)) return false;
        Coche cother = (Coche) o;
        
        return matricula.equals(cother.matricula) &&
               color.equals(cother.color);
    }
}

@acmupm

ESTO ES TODO

@acmupm

intr_prog_acm-2

By devcexx

Made with Slides.com

intr_prog_acm-2

  • 565

More from devcexx