8. előadás (e-Kozsik 1.)

Array list

ArrayList<String> names = new ArrayList<>();
names.add("Tim");
names.add("Jerry");

Paraméterezett típus

ArrayList<Time> times; // Time a paraméter típus, ArrayList a paraméterezett típus

Kb. így van definiálva:

package java.util;
public class ArrayList<T> {
    public ArrayList(){ ... }
    public T get( int index ){ ... }
    public void set( int index, T item ){ ... }
    public void add( T item ){ ... }
    public T remove( int index ){ ... }
    ...
}

Használata:

ArrayList<String> names = new ArrayList<String>();
ArrayList<String> namez = new ArrayList<>();

Metódus is lehet generikus:

import java.util.*;
class Main {
    // Definiál egy típus paramétert, amit utána paraméterként és változó típusként használ
    public static <T> void reverse( T[] array ){
        int lo = 0, hi = array.length-1;
        while( lo < hi ){
            T tmp = array[hi];
            array[hi] = array[lo];
            array[lo] = tmp;
            ++lo; --hi;
        }
    }
    public static void main( String[] args ){
        reverse(args);
        System.out.println( Arrays.toString(args) );
    }
}

Javában osztályok és metódusok is lehetnek generikusak.
Ez polimorf, mert több típusra is működik.
Típus paraméter lehet: referenciatípus
A generic-ek egy "bosszantó" tulajdonsága: nem működnek primitív típusokra
Tehát, primitív típus nem lehet típusparaméter:

    ArrayList<int> ints = new ArrayList<>(); // Nem helyes kód

Helyette referenciatípus

ArrayList<Integer> ints = new ArrayList<>();
ints.add(Integer.valueOf(7));
ints.add(10); // auto-BOXing

int ten = ints.get(1); // auto-unboxing
int ten_ = ints.get(1).intValue();

Ésszel haszáljuk!

Halmaz:

HashSet<String> colors = new HashSet<>();
colors.add("red"); colors.add("white"); colors.add("red");
colors.size(); // 2

Leképezés:

HashMap<String, String> colors = new HashSet<>();
colors.add("red", "piros"); colors.add("white", "fehés");
colors.get("red"); // "piros"

Öröklődés (inheritance)

class A extends B {}

A gyermekosztálya (child class) a B szülőosztálynak (parent class)

Egy típust egy másik típusból származtatunk
- Újrafelhasználás
Örökli a metódusait és adattagjait
Tranzitivitás: leszármazott osztály – ősosztály
- alosztály: subclass, derived class
- bázisosztály: super class, base class
Nem lehet körkörös

public class Time {
    private int hour, minute; // initialized to 00:00
    public int getHour(){ ... }
    public int getMinute(){ ... }
    public void setHour( int hour ){ ... }
    public void setMinute( int minute ){ ... }
    public void aMinutePassed(){ ... }
}

Az ExactTime kibővíti a Time-ot.

public class ExactTime extends Time {
    private int second; // initialized to 00
    public int getSecond(){ ... }
    public void setSecond( int second ){ ... }
    public boolean earlierThan( ExactTime that ){ ... }
}

Implicit szülőosztály

java.lang.Object az MINDEN osztály szülőosztálya!

public class Time extends java.lang.Object

package java.lang;
public class Object {
    public Object(){ ... }
    public String toString(){ ... }
    public int hashCode(){ ... } // Hasító kód
    public boolean equals( Object that ){ ... }
...
}

A konstruktorok függetlenek az öröklődéstől

public class ExactTime extends Time {
    private int second;
    public ExactTime( int hour, int minute, int second ){
        super(hour,minute); // meghívandó a szülő konstruktora
        if( second < 0 || second > 59 )
            throw new IllegalArgumentException();
        this.second = second;
    }
}

A gyermekosztályba is kell konstruktort írni. Ha nem írjuk ki, akkor implicit lehívja a szülő konstruktort.

Tehát:

class A {}

Az valójában:

class A extends java.lang.Object {
    A(){
        super();
    }
}

Egy érdekes hiba

class Base {
    Base( int n ){}
}
class Sub extends Base {}

Jelentése:

class Base extends Object {
    Base( int n ){
        super();
    }
}
class Sub extends Base {
    Sub(){ super(); }
}

Felüldefiniálás

Újradefiniálás, redefinition, overriding

Eredetileg:

package java.lang;
public class Object {
    ...
    public String toString(){ ... } // java.lang.Object@4f324b5c
}

Ez felülírható:

public class Time {
    ...
    public String toString(){
        return hour + ":" + minute; // 8:5
    }
}