interfész
absztrakt osztály
osztály



abstract class X
{
    int x;
    int f()
    {
        ...
    }

    double d();
}

// absztrakt osztály nem példányosítható
// különben:
X x = new X();
x.d();      // ???????

// ilyet viszont lehet:
class Y extends X
{
    double d()
    {
        ...
    }
}

X x = new Y();
x.d();      // ennek már van értelme


interface Színes
{
    enum Szín { KÉK, ZÖLD };
    public Szín színe();
}

class Alakzat implements Színes
{
    Szín szín;

    Alakzat(Szín sz)
    {
        szín = sz;
    }

    public Szín színe()
    {
        return szín;
    }
}


---------------------------------------

class Színes
{
    enum Szín { KÉK, ZÖLD };
    Szín színe()
}

class Alakzat extends Színes
{
    Szín szín;

    Alakzat(Szín sz)
    {
        szín = sz;
    }

    Szín színe()
    {
        return szín;
    }
}



List lista = new ArrayList();
List lista2 = new LinkedList();


interface List2 extends List, IFaceX, IFaceY
{
    ...
}



        A
    B       C
        D

// nem Java
class D extends B, C    { }
class B extends A       { int f() { ... }   }
class C extends A       { int f() { ... }   }
class A                 { int f() { ... }   }

// Java
interface D extends B, C    { }
interface B extends A       { int f();   }
interface C extends A       { int f();   }
interface A                 { int f();   }
interface F                 { int f();   }

class E implements D, B, C, A
{
    int f()
    {
        ...
    }
}

class G extends E implements F
{
}



---------------------------------------------------

class A
{
    B f(Alk c) { ... }
    int f(int i) { ... }
}

class B2 extends B
class Alkalmazott extends Ember

class A2 extends A
{
    // ilyet nem lehet
    B f(Ember c) { ... }
}





List list = new LinkedList();
list.add(new Integer(3));
list.add(new X());

List<Integer> list = new LinkedList<Integer>();
list.add(new Integer(3));
// ezt nem lehet:
list.add(new X());






String s = "abc";
String s2 = "abc";

// nem jó
if (s == s2) { ... }

int i = 1;
int j = 1;

// jó
if (i == j) { ... }


Integer i = 1;
Integer j = 1;

// nem jó
if (i == j) { ... }