Mój projekt pierwszy z baaardzo obszernym komentarzem.

Krótka instrukcja użycia:

Wymagania co do projektu są tu:
http://www.users.pjwstk.edu.pl/~mtrzaska/Files/MAS/MAS-informacje-stacjonarne.pdf

Jak zrobić 'ekstensje’ (są w projekcie, ale tu macie opis o co chodzi):

http://www.mtrzaska.com/plik/mas/mas-wyklad-nr-04

Projekt składa się z 4 plików:

Main.java

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;
import java.util.Random;


public class Main
{
	public static void main(String[] arg) throws Exception
	{
		// jesli wczesniej cos zapisalem [odpalam program po raz kolejny] to wczytaj to co bylo
		// DEMONSTRACJA DZIALANIA 'TRWALYCH EKSTENSJI' (trwale czyli nie znikaja po zamnieciu programu)
		if(new File("mojeTajneDane").isFile())
		{
			try
			{
				// plik jest w 'workspace'
				FileInputStream fileIn = new FileInputStream("mojeTajneDane");
				ObjectInputStream inStream = new ObjectInputStream(fileIn);
				// odczytuje wszystko z dysku do pliku 'mojeTajneDane' jedna linijka
				// 'magia javy' zrobi reszte
				ObjectPlus.odczytajEkstensje(inStream);
				inStream.close();
				fileIn.close();
			}
			catch(IOException i)
			{
				i.printStackTrace();
				return;
			}
			catch(ClassNotFoundException c)
			{
				System.out.println("Klasa nie znaleziona.");
				c.printStackTrace();
				return;
			}
		}
		
		
		
		// utworz nowego Grzegorza o wzroscie miedzy 165, a 195
		Random rand = new Random();
		Student studencik = new Student("Grzegorz" + rand.nextInt(100), 165 + (rand.nextInt(31)));
		// na date urodzenia ustawiamy czas jaki jest 'teraz'
		studencik.ustawDateUrodzenia(new Date());
		// wywoluje przeciazana metode z parametrem 'int'
		studencik.dodajOcene(2 + rand.nextInt(4));
		// wywoluje przeciazana metode z parametrem 'Double'
		studencik.dodajOcene(new Double(2 + ((double)rand.nextInt(7) / 2)));
		// pokaz wszystkich Grzegorzy jacy istnieja
		ObjectPlus.pokazEkstensje(Student.class);
		
		
		
		// przed zamknieciem programu zapisz wszystkie ekstensje do pliku
		// DEMONSTRACJA DZIALANIA 'TRWALYCH EKSTENSJI' (trwale czyli nie znikaja po zamnieciu programu)
		try
		{
			// plik jest w 'workspace'
			FileOutputStream fileOut = new FileOutputStream("mojeTajneDane");
			ObjectOutputStream outStream = new ObjectOutputStream(fileOut);
			// zapisuje wszystko na dysk do pliku 'mojeTajneDane' jedna linijka
			// 'magia javy' zrobi reszte
			ObjectPlus.zapiszEkstensje(outStream);
			outStream.close();
			fileOut.close();
		}
		catch(IOException i)
		{
			i.printStackTrace();
		}
		
	}
}

Osoba.java

import java.util.Date;


public abstract class Osoba extends ObjectPlus
{
	/*
	wymagane do serializacji, w przyszlosci jak cos zmienisz w tej klasie [dodasz/usuniesz atrybut]
	to zmienisz ta liczbe na inna, dzieki temu mechanizm 'serialize' nie pozwoli zaladowac 
	pliku z dysku z starymi danymi do programu ktory uzywa innej klasy
	(przeciez moze byc zupelnie inna klasa o nazwie Student i dane takie jak 'oceny' moga w niej
	nie wystepowac)
	 */
	private static final long serialVersionUID = 1L;
	/* PRZYPOMNIENIE: Co to jest 'protected'?
	 * To takie cos jak 'private' tylko, ze zmienna jest widziana w klasach 'dziedziczacych' (rozszerzajacych).
	 * Dzieki temu bedzie mozna wyswietlac np. 'imie' w studencie ktory dziedziczy po osobie.
	 */
	
	// atrybut prosty, wymagany, pojedynczy, obiektu
	protected String imie;
	/*
	 * WYMAGANY:
	 * zawsze kiedy go ustawiamy to sprawdzamy czy ktos nam nie przekazal 'null'
	 */
	
	// atrybut prosty, opcjonalny, pojedynczy, obiektu
	protected String nazwisko;
	/*
	 * OPCJONALNY:
	 * zawsze kiedy go wyswietlany to sprawdzany cyz ktos nam nie przekazal 'null'
	 * jesli 'null' to trzeba wyswietlic o tym informacje lub inaczej to 'obsluzyc',
	 * bo proba wyswietlenie 'null' skonczy sie bledem programu
	 */
	
	// atrybut zlozony, opcjonalny, pojedynczy, obiektu
	protected Date dataUrodzenia;
	/*
	 * ZLOZONY:
	 * to taki ktory zawiera w sobie wiecej niz jedna informacje
	 * ogolnie chodzi o odniesienie sie do innego obiektu (oprocz 'String')
	 * 
	 */
	// atrybut prosty, wymagany, pojedynczy, obiektu
	protected int wzrost = 0;
	/*
	 * jest tu tylko po to, zeby wyliczac srednia (i miec cos 'pochodnego')
	 */
	
	// atrybut prosty, pojedynczy, wyliczalny (pochodny), klasowy
	private static double sredniWzrost = 0;
	/*
	 * KLASOWY:
	 * dotyczy klasy, czyli wszystkich 'Osob', a nie jednej konkretnej
	 * technicznie: zmienna typu static
	 * 
	 * POCHODNY:
	 * mozna go wyliczyc, w tym wypadku wystarczylo by pobrac wszystkie Osoby z 'ekstensji' ObjectPlus
	 * pobrac ich wzrost i wyliczyc srednia, ale prosciej to po prostu pamietac
	 * i liczyc tylko raz przy dodawaniu osoby
	 */
	// atrybut prosty, pojedynczy, klasowy - potrzebny do liczenia sredniej
	private static int iloscOsob = 0;
	
	// konstruktor nie jest 'pusty', bo imieOsoby jest 'wymagane', wiec musi byc w kazdym konstruktorze
	Osoba(String imieOsoby, int wzrostOsoby)
	{
		/*
		 * BARDZO WAZNE: kazdy konstruktor klasy dziedziczacej po klasie ObjectPlus musi wywolywac 'super()'
		 * Co to jest 'super()'?
		 * Jest to cos co odpali konstruktor w klasie 'wyzej' / 'u rodzica' czyli w ObjectPlus.
		 * A co to robi?
		 * To zapewnia, ze kazdy utworzony obiekt jest na liscie 'ekstensji' w ObjectPlus.
		 * Konstruktor w ObjectPlus zajmuje sie dodawaniem/tworzeniem list ekstensji.
		 */
		super();

		
		
		// tutaj dbamy, aby wymagany atrybut byl ustawiony, a nie wskazywal na 'null'
		if(imieOsoby == null)
		{
			throw new NullPointerException("Osoba musi miec imie");
		}
		this.imie = imieOsoby;
		
		// 'int' nie moze byc 'nullem', wiec tego nie sprawdzamy
		// ale wymagamy podania tego w konstruktorze, wiec kazda osoba bedzie miala wpisany wzrost
		this.wzrost = wzrostOsoby;
		
		
		
		// to nam sie przyda do liczenia sredniej
		iloscOsob++;
		// a tu troche Drabikologi i mamy srednia
		sredniWzrost += (this.wzrost - sredniWzrost) / iloscOsob;
	}

	/*
	 * PRZESLANIANIE METOD:
	 * w nadklasie Osoba metoda ta zwraca tylko imie,
	 * a w Student imie z dodanym na poczatku tekstem 'Student'
	 * jaki tego sens? trudno mi wymyslic jakas sensowna przeslaniana funkcje
	 * 
	 * technicznie: w klasie dziedziczacej jest metoda o takiej samej nazwie, takich samych argumentach,
	 * ale zwraca cos innego
	 */
	public String getImie()
	{
		return this.imie;
	}
	
	/*
	 * METODA KLASOWA:
	 * metoda operujaca na zmiennych klasowych, a nie obiekcie
	 * technicznie: typu static
	 */
	public static double getSredniWzrost()
	{
		return sredniWzrost;
	}

	/*
	 * demonstracja roznicy w poslugiwaniu sie atrybutami 'wymaganymi' i 'opcjonalnymi'
	 */
	public void ustawImie(String imie)
	{
		if(imie == null) // uwaga wymagany!
		{
			throw new NullPointerException("Osoba musi miec imie");
		}
		this.imie = imie;
	}
	
	public void ustawNazwisko(String nazwisko)
	{
		this.nazwisko = nazwisko;
	}
	
	public void ustawDateUrodzenia(Date dataUrodzenia)
	{
		this.dataUrodzenia = dataUrodzenia;
	}
	
	public String toString()
	{
		String ret = new String();
		ret += "Imie: " + getImie();
		ret += "\nNazwisko: ";
		if(nazwisko != null) // uwaga opcjonalny!
			ret += nazwisko;
		else
			ret += "bez nazwiska";

		ret += "\nWzrost: " + wzrost;

		ret += "\nData urodzenia: ";
		if(dataUrodzenia != null) // uwaga opcjonalny!
			ret += dataUrodzenia;
		else
			ret += "nie znana";
		return ret;
	}
}

Student.java

import java.util.Vector;


public class Student extends Osoba
{
	/*
	wymagane do serializacji, w przyszlosci jak cos zmienisz w tej klasie [dodasz/usuniesz atrybut]
	to zmienisz ta liczbe na inna, dzieki temu mechanizm 'serialize' nie pozwoli zaladowac 
	pliku z dysku z starymi danymi do programu ktory uzywa innej klasy
	(przeciez moze byc zupelnie inna klasa o nazwie Student i dane takie jak 'oceny' moga w niej
	nie wystepowac)
	 */
	private static final long serialVersionUID = 1L;
	
	// atrybut prosty, powtarzalny, obiektu
	private Vector<Double> oceny = new Vector<Double>();
	/*
	 * POWTARZALNY:
	 * obiekt zawiera 0 lub wiecej takich 'elementow'
	 * technicznie: lista/tablica
	 */
	
	Student(String imieOsoby, int wzrostOsoby)
	{
		/*
		 * 'super', bo dziedziczy po klasie ktora dziedziczy po ObjectPlus
		 * z parametrem 'imieOsoby' i 'wzrostOsoby', bo takie atrybuty sa wymagana w Osoba
		 */
		super(imieOsoby, wzrostOsoby);
	}
	
	/*
	 * PRZESLANIANIE METOD:
	 * w nadklasie Osoba metoda ta zwraca tylko imie,
	 * a w Student imie z dodanym na poczatku tekstem 'Student'
	 * jaki tego sens? trudno mi wymyslic jakas sensowna przeslaniana funkcje
	 * 
	 * technicznie: w klasie dziedziczacej jest metoda o takiej samej nazwie, takich samych argumentach,
	 * ale zwraca cos innego
	 */
	public String getImie()
	{
		return "Student " + this.imie;
	}
	
	/*
	 * PRZECIAZANIE METOD:
	 * metody maja taka sama nazwe, ale przyjmuja rozne parametry
	 * w tym przypadku jedna 'Double', a druga 'int'
	 */
	public void dodajOcene(Double ocena) throws Exception
	{
		if(ocena == null || ocena < 2 || ocena > 5)
		{
			throw new Exception("Ocena musi byc pomiedzy 2, a 5");
		}
		oceny.add(ocena);
	}
	public void dodajOcene(int ocena) throws Exception
	{
		if(ocena < 2 || ocena > 5)
		{
			throw new Exception("Ocena musi byc pomiedzy 2, a 5");
		}
		oceny.add(new Double(ocena));
	}
	
	public String toString()
	{
		// na poczatek opisu studenta wklejamy opis z Osoby (imie, nazwisko..) wywolujac metode z klasy 
		// z ktorej dziedziczymy, robimy to uzywajac 'super'
		String ret = super.toString();
		ret += "\nOceny: ";
		if(oceny.size() > 0)
		{
			for(Double ocena : oceny)
			{
				ret += ocena + ",";
			}
		}
		else
		{
			ret += "brak ocen";
		}
		return ret;
	}
}

ObjectPlus.java

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Hashtable;
import java.util.Vector;

/* 
 * To jest klasa z wykladu nr 4 z drobnymi zmianami, zeby eclipse nie wywalal 'ostrzezen'
 * --------------------
 * klasa zrobina przez wykladowce!, wiec raczej nie powinien sie czepiac
 * ale trzeba rozumiec KAZDY szczegol jej dzialania!
 * */
public class ObjectPlus implements Serializable
{
	/*
	wymagane do serializacji, w przyszlosci jak cos zmienisz w tej klasie [dodasz/usuniesz atrybut]
	to zmienisz ta liczbe na inna, dzieki temu mechanizm 'serialize' nie pozwoli zaladowac 
	pliku z dysku z starymi danymi do programu ktory uzywa innej klasy
	(przeciez moze byc zupelnie inna klasa o nazwie Student i dane takie jak 'oceny' moga w niej
	nie wystepowac)
	 */
	private static final long serialVersionUID = 1L;
	/*
	(w tym tlumaczeniu bede uzywal slowa 'tablica' zamiast 'lista', roznica? lista [z ktorej korzystamy pod nazwa Hashtable!]
	sama 'rosnie' jak do niej dodajemy obiekty, a tablice maja staly rozmiar np. 'new Integer[5]' - 5 elementow)
	
	Tlumaczenie typow:
	1. Class<? extends ObjectPlus> - obiekt typu Class pobrany z obiektu ktory rozszerza ObjectPlus, czyli np. Osoba lub Student,
	String czy Integer nie rozszerzaja ObjectPlus, wiec nie zostana zaakceptowane
	2. Vector<ObjectPlus> - lista/kontener obiektow typu ObjectPlus, do takiej listy mozna wsadzic dowolny obiekt
	ktory rozszerza ta klase, czyli np. Student czy Osoba
	
	Opis:
	To jest 'tablica tablic', a dokladniej tablica ktora jako klucz nie ma liczby, a.. KLASE (Class)!
	Class to o dziwo w Javie klasa ktora przechowuje informacje o klasie, mozna pobrac obiekt typu Class z kazdego obiektu
	w Javie uzywajac:
	Class klasaObiektu = mojObiekt.getClass();
	No wiec mamy juz tablice ktora uzywa jako klucza Class, a jakie dane przechowuje? Przechowuje Vector<ObjectPlus>,
	czyli tablice obiektow typu ObjectPlus:
	1. Osoba rozszerza ObjectPlus [extends], wiec tez moga ja wrzucic do tej tablicy
	2. Student rozszerza Osoba ktora rozszerza ObjectPlus, wiec tez moge ja tam wrzucic
	
	A po co mi wogole tablica tablic zamiast zwyklej tablicy?
	Bo ObjectPlus w projekcie docelowym moze byc rozszerzany przez wiele obiektow roznych
	klas jak np. 'Wplata', 'Ocena', 'Przedmiot' itd., a nie chce mi sie pisac nowego ObjectPlus dla kazdej z nich
	Nie chce tez przechowywac wszystkich obiektow w jednej tablicy [typu Object, wtedy moge tam wrzucic wszystko],
	bo wtedy 'pobranie wszystkich 'Student' wymagalo by przegladania wszystkich elementow tablicy i
	sprawdzania ktorzy to Studenci.
	 */
	private static Hashtable<Class<? extends ObjectPlus>, Vector<ObjectPlus>> ekstensje = new Hashtable<Class<? extends ObjectPlus>, Vector<ObjectPlus>>();

	/**
	 * Konstruktor.
	 */
	public ObjectPlus()
	{
		Vector<ObjectPlus> ekstensja = null;
		Class<? extends ObjectPlus> klasa = this.getClass();

		if(ekstensje.containsKey(klasa))
		{
			// Ekstensja tej klasy istnieje w kolekcji ekstensji
			// jest juz jakis np. Student, wiec jest i lista studentow, nie chce tworzyc nowej listy,
			// tylko dodac nowego studenta do listy juz istniejacej
			ekstensja = ekstensje.get(klasa);
		}
		else
		{
			// Ekstensji tej klasy jeszcze nie ma -> dodaj ją
			// to wystepuje kiedy pierwszy raz dodajemy obiekt danego typu (np. Student) do ekstensji
			ekstensja = new Vector<ObjectPlus>();
			ekstensje.put(klasa, ekstensja);
		}
		// a tu wreszcie dodaje studenta do listy nowej LUB istniejacej
		ekstensja.add(this);
	}
	
	/**
	 * Zapisuje wszystkie ekstensje do podanego strumienia (wersja z serializacja).
	 * Metoda klasowa.
	 * @throws IOException 
	 */
	public static void zapiszEkstensje(ObjectOutputStream stream) throws IOException
	{
		/*
		'magia javy' zamienia obiekt (Hashmape) zawierajacy inne obiekty w tekst,
		wiec jak zawiera liste Studentow to Ci studenci maja np. atrybut 'Date dataUrodzenia' i to tez sie zapisze
		(Date jest 'serializable' jak wiekszosc klas uzywanych na codzien w javie)
		(wszystkie obiekty jakie zawiera ekstensja musza rozszerzac interfejs 'Serializable')
		java znajdzie wszystkie powiazane obiekty z tymi obiektami ktore mamy w hashmap 'ekstensje' i 
		wszystkie powiazane z ich powiazaniami itd. i wszystko zapisze jako tekst!
		a potem jeszcze moze z tego tekstu odtworzyc ten obiekt [i obiekty powiazane], magia!
		
		UWAGA: to zapisze tylko zmienne 'obiektu', zmienne 'klasowe' (te z 'static') nie zostana zapisane i
		to jeden z problemow z takim prostym zapisem, ale mozna samemu dopisac zapis 'static'
		na szczescie to nie jest wymagane w MP_1, a jedynie w projekcie semestralnym
		*/
		stream.writeObject(ekstensje);
	}

	/**
	 * Odczytuje wszystkie ekstensje z podanego strumienia (wersja z serializacja).
	 * Metoda klasowa.
	 * @throws IOException 
	 * @throws ClassNotFoundException 
	 */
	@SuppressWarnings("unchecked")
	public static void odczytajEkstensje(ObjectInputStream stream) throws IOException, ClassNotFoundException
	{
		/*
		tutaj 'magia javy' odtwarza dane zapisane jako tekst do pliku (zapisane w funkcji wyzej)
		 */
		ekstensje = (Hashtable<Class<? extends ObjectPlus>, Vector<ObjectPlus>>) stream.readObject();
	}	
	
	/**
	 * Wyswietla ekstensje.
	 * Metoda klasowa.
	 * @throws Exception 
	 */
	public static void pokazEkstensje(Class<? extends ObjectPlus> klasa) throws Exception
	{
		/*
		wystarczy gdzies w programie wywolac ta funkcje tak:
		ObjectPlus.pokazEkstensje(Student.class);
		aby wyswietlic wszystkie obiekty typu 'Student' istniejace w programie
		 */
		Vector<ObjectPlus> ekstensja = null;
		
		if(ekstensje.containsKey(klasa))
		{
			// Ekstensja tej klasy istnieje w kolekcji ekstensji
			ekstensja = ekstensje.get(klasa);
		}
		else
		{
			throw new Exception("Unknown class " + klasa);
		}
		
		System.out.println("Ekstensja klasy: " + klasa.getSimpleName());

		for(Object obiekt : ekstensja)
		{
			System.out.println(obiekt + "\n");
		}
	}
	
}

Mam nadzieję, że będziecie przestrzegać instrukcji.

Wszystko w .zip:

MAS_MP1_Jerzego