/*******************************************************
 * Ohjelmoinnin jatkokurssi, syksy 2009, Harjoitus 2
 * Malliratkaisuja
 ******************************************************/


/*******************************************************
*Tehtävä 1&2
*******************************************************/

public class Opiskelija {

  private String etunimi;
  private String sukunimi;
  private int koepisteet;       // saa olla vain 0-50
  private int harjoituspisteet; // saa olla vain 0-10

  public Opiskelija(String etunimi, String sukunimi) {
    this.etunimi = etunimi;
    this.sukunimi = sukunimi;
    this.koepisteet = 0;
    this.harjoituspisteet = 0;
  }
  //---------------------------
  public String getEtunimi() {
    return this.etunimi;
  }
  public String getSukunimi() {
    return this.sukunimi;
  }
  public int getPistesaalis() {
    return this.koepisteet + this.harjoituspisteet;
  }
  //---------------------------

/*******************************************************
!!!Tehtävä alkaa!!!
*******************************************************/
	/*
	* Metodi palauttaa false, jos annettu parametri ei ole 
	* kelvollinen. Tällöin koepisteiden arvoa ei muuteta (olisiko 
	* joku muu tapa parempi?).
	* Jos parametri on kelvollinen, muutetaan koepisteiden arvoa ja 
	* palautetaan true
	*/
	public boolean setKoepisteet(int pisteet){
		//palautetaan false, jos parametri ei kelpaa
		if(pisteet < 0 || pisteet >50 )
			return false;
		//kelvolliset pisteet 
		this.koepisteet = pisteet;
		return true;
	}
	
	/*
	* Metodi palauttaa false, jos annettu parametri ei ole 	
	* kelvollinen. Tällöin harjoituspisteiden arvoa ei muuteta 
	* (olisiko joku muu tapa parempi?).
	* Jos parametri on kelvollinen, muutetaan harjoituspisteiden 
	* arvoa ja palautetaan true.
	*/
	public boolean setHarjoituspisteet(int pisteet){
		//palautetaan false, jos parametri ei kelpaa
		if(pisteet < 0 || pisteet > 10)
			return false;
		
		this.harjoituspisteet = pisteet;
		return true;
	}

	/*
	* Metodi käy if-lauseet läpi (ensimmäiseen toteen asti) joka 
	* kerta, kun sitä kutsutaan. Jos metodia käytetään usein, voisi 	
	* olla järkevämpää luoda erillinen private int arvosana -	
	* muuttuja, johon arvosana laskettaisiin aina, kun pisteitä 	
	* muutetaan.
	*/ 
	public int arvosana(){
		int pisteet = this.harjoituspisteet + this.koepisteet;

		if(pisteet < 30)
			return 0;
		if(pisteet < 35)
			return 1;
		if(pisteet < 40)
			return 2;
		if(pisteet < 45)
			return 3;
		if(pisteet < 50)
			return 4;
		return 5;
	}
	
	/*
	* Vertaillaan Opiskelijoita. Järjestysperusteena on 	
	* ensisijaisesti Opiskelijan pistesaalis, sitten sukunimi ja 	
	* etunimi. Mikäli kaikki täsmäävät, palauttaa metodi 0.
	*/
	public int compareTo(Opiskelija verrattava){
		//verrataan pisteitä
		if(this.getPistesaalis() > verrattava.getPistesaalis())
			return -1;
		if(this.getPistesaalis() < verrattava.getPistesaalis())
			return 1;
		//yhtäsuuret pistesaaliit, verrataan sukunimeä	
		if(this.sukunimi.compareTo(verrattava.getSukunimi()) < 0)
			return -1;
		if(this.sukunimi.compareTo(verrattava.getSukunimi()) > 0)
			return 1;
		//sama sukunimi, verrataan etunimiä
		if(this.etunimi.compareTo(verrattava.getEtunimi()) < 0)
			return -1;
		if(this.etunimi.compareTo(verrattava.getEtunimi()) > 0)
			return 1;	
		return 0;
	}

}


Tässä myös vaihtoehtoinen toteutustapa compareTo –metodille. Samat ehdoton
esitetty huomattavasti tiiviimmin. Tämä versio on kuitenkin ehkä hieman 
vaikealukuisempi.

public int compareTo(Opiskelija verrattava){
	if(this.getPistesaalis() > verrattava.getPistesaalis())
		return -1;
	if(this.getPistesaalis() < verrattava.getPistesaalis())
		return 1;
	if(this.sukunimi.compareTo(verrattava.getSukunimi())!=0)
		return this.sukunimi.compareTo(verrattava.getSukunimi());
	return this.etunimi.compareTo(verrattava.getEtunimi());
}





/*******************************************************
*Tehtävä 3&4
********************************************************

import java.util.Scanner;

public class OpiskelijaTietokanta {
	
	private static Scanner lukija = new Scanner(System.in);
	
	/*
	 * Apuohjelma, jonka avulla voi syöttää tiedot "tietokantaan"
	 */
	private static void pyydaTiedot(Opiskelija[] taulu){
		String etunimi, sukunimi;
		
		for(int i=0; i < taulu.length; i++){
			System.out.println("Anna etunimi ");
			etunimi = lukija.next();
			System.out.println("Anna sukunimi ");
			sukunimi = lukija.next();
			taulu[i] = new Opiskelija(etunimi, sukunimi);
			System.out.println("Anna koepisteet");
			int koepisteet = lukija.nextInt();
			while(!taulu[i].setKoepisteet(koepisteet)){
				System.out.println("Virheelliset koepisteet. Anna koepisteet uudelleen (0-50):");
				koepisteet = lukija.nextInt();
			}
			System.out.println("Anna harjoituspisteet");
			int harjoituspisteet = lukija.nextInt();
			
			while(!taulu[i].setHarjoituspisteet(harjoituspisteet)){
				System.out.println("Virheelliset harjoituspisteet. Anna harjoituspisteet uudelleen (0-10):");
				harjoituspisteet = lukija.nextInt();
			}
		}
	}

	/*
	 * Järjestetään taulukko.
	 */
	private static void jarjestaTaulu(Opiskelija[] taulu){
		Opiskelija apu;
		
		for(int i=0; i<taulu.length-1; i++){
			for(int j=i+1; j<taulu.length; j++){
				if(taulu[i].compareTo(taulu[j]) > 0){
					apu = taulu[i];
					taulu[i] = taulu[j];
					taulu[j] = apu;
				}
			}
		}
	}
	
	/*
	 * Tulostetaan taulukko.
	 */
	private static void tulostaTaulu(Opiskelija[] taulu){
		
		System.out.println("Tulos \t\tNimi");
		for(int i=0; i<taulu.length; i++){
			System.out.println("" + taulu[i].arvosana()+ "\t"+
					taulu[i].getPistesaalis()+ "\t"+
					taulu[i].getSukunimi()+ ", "+
					taulu[i].getEtunimi());
		}
	}
	
	public static void main(String[] args) {
		int lkm;
		Opiskelija[] taulu;
		
		System.out.println("Anna opiskelijoiden lukumäärä.");
		lkm = lukija.nextInt();
		taulu = new Opiskelija[lkm];
		
		pyydaTiedot(taulu);
		jarjestaTaulu(taulu);
		tulostaTaulu(taulu);
	}

}



/*******************************************************
*Tehtävä 5
********************************************************

Vastaukset:

a)	a = ++i;
	a: -3	i:-3
b)	a = i++;
	a: -4	i:-3
c)	a = --i;
	a: -5	i:-5
d)	a = i--;
	a: -4	i:-5
e)	a += i++;
	a: -1	i:-3
f)	a *= ++i + i++;
	a: -18 i:-2
g)	a -= i++ - --i;
	a: 3	i:-4
h)	a -= (i++ - --a) + (++a + i--);
	a: 9	i:-4
i)	a += (i += ++a) - (a -= i--);
	a: -1	i:-1
j)	a += (a += a--) + (a = i = a++);
	a: 15	i:6

Hieman selityksiä:

a) ja b)
Kohdassa a) muuttujaa i kasvatetaan ennen sijoitusta lauseeseen,
b):ssä vasta sijoituksen jälkeen.

eli 
a = 	++i;
	1-4		//kasvatetaan i:n arvoa
	-3		//uusi i:n arvo
-3			//ja sijoitetaan i:n arvo a:lle

ja 
a = 	i++;
3	-4		
-4	-4+1		//sijoitetaan i:n arvo, ja sen jälkeen kasvatetaan
	-3		//uusi i:n arvo

c) ja d)
Sama kuin edellä, mutta tällä kertaa vähennetään

eli 
a = 	--i;		
3	-1-4		//vähennetään i:n arvoa
	-5		//uusi i:n arvo
-5			//sijoitetaan i:n arvo a:lle

ja 
a = 	i--;		
3	-4		//alkuarvot
-4			//sijoitetaan i:n arvo a:lle
	-4-1		//vähennetään i:n arvoa
	-5		//uusi i:n arvo

e)
a 	+=	i++;
3	3+	-4		//lasketaan lausekkeen arvo (i:n 						
				//alkuperäisellä arvolla
-1		-4+1		//sijoitetaan lausekkeen arvo a:lle ja
				//lasketaan i:n uusi arvo
		-3		//i:n uusi arvo

f)
a 	*= 	++i 	+ 	i++;
3	3*	[1-4 	+	-3]	//lasketaan lausekkeen arvo,
 					//jälkimmäisen i:n arvo on jo kasvanut
 					//edellisessä kohdassa (++i)
					//huom! kertolasku kohdistuu molempiin
 					//lausekkeen tekijöihin (selvennetty
 					//sulkeilla)
				-3+1	//huom! i:n arvoa kasvatetaan heti, kun
 					//se on sijoitettu lausekkeeseen
	3*-6			-2	//lasketaan lausekkeen arvo
	-18				//lausekkeen uusi arvo
-18					//sijoitetaan lausekkeen arvo a:lle

g)

a 	-= 	i++ 	- 	--i;
3	3-	-4			//sijoitetaan i:n arvo
		-4+1			//heti sijoituksen jälkeen i:n arvoa
 					//kasvatetaan yhdellä (mutta ei vaikuta
					//itse lausekkeeseen jo sijoitettuun
 					//i:n arvoon, seuraavan i:n arvoon
 					//kylläkin
				-1-3	//vähennetään i:n arvoa yhdellä (huom!
					//i:n arvo ehti jo muuttua)

3	3-	-4	-	-4	//lasketaan lausekkeen arvo
	3-	-4	+	4	//minukset muuttuvat plussaksi
	3-	0
	3				
3					//sijoitetaan lausekkeen arvo a:lle

a: 3	i:-4


h)
Ensin sijoitetaan a, sitten lasketaan ensimmäiset sulut ja sijoitetaan ne lauseeseen 
ja lopulta lasketaan toiset sulut ja tehdään sijoitus.

Ensimmäisten sulkujen laskeminen 
vaikuttaa muuttujien arvoihin, mikä pitää huomioida laskettaessa toisten sulkujen sisältöä.

a 	-= 	(i++ 	- 	--a) 	+ 	(++a 	+ 	i--);
3 -= (ekat sulut) + (tokat sulut)

//jaetaan tämä osiin, lasketaan esimmäisten sulkeiden arvo
(i++	-	--a)
-4	-	-1+3		//vähennetään a:n arvoa
-6				//lasketaan lausekkeen arvo
					
//Tämän jälkeen kasvatetaan i:n arvoa
i++
-4+1 = -3			//i:n uusi arvo

//i:n ja a:n muuttuneet arvot
a	i
2	-3

//ja lasketaan toiset sulut, huom! i:n ja a:n arvot ovat muuttuneet
(++a 	+	i--)
1+2	+	-3		//kasvatetaan a:n arvoa
0				//lasketaan lausekkeen arvo

//tämän jälkeen vähennetään i:n arvoa yhdellä
i--
-3-1 
-4				//i:n uusi arvo

//lasketaan alkuperäisen lausekkeen arvo
a 	-= 	(i++ - --a) + (++a + i--);
3	3-	(-6)		+	0		//lasketaan lausekkeen arvo
	9
9							//sijoitetaan lausekkeen 							
							//arvo a:lle

//i:n arvo on edellä laskettu -4

	
i)
a += (i += ++a) - (a -= i--);
a =a+(i += ++a) - (a -= i--);
a = 3 + ((ekat sulut) - (tokat sulut))

//jaetaan tämä osiin, lasketaan esimmäisten sulkeiden arvo
(i	+=		++a)
-4	-4	+	1+3		//kasvatetaan a:n arvoa
-4	-4	+	4		//lasketaan lausekkeen arvo
	0				//lausekkeen uusi arvo
0					//sijoitetaan lausekkeen uusi arvo 						
					//i:lle

//i:n ja a:n muuttuneet arvot ensimmäisten sulkeiden jälkeen
a=4, i=0

//lasketaan toisten sulkeiden arvo, huom! lasketaan päivitetyillä //arvoilla
(a 	-= 		i--)
4	4	-	0		//lasketaan lausekkeen arvo
4	4		0-1		//ja vähennetään i:n arvoa yhdellä,
 			-1		//huom! tämä ei vaikuta lausekkeen 						
					//arvoon
4					//ja sijoitetaan lausekkeen arvo a:lle

//päivitetyt muuttujien arvot
a=4, i=-1

//lopuksi lasketaan koko lausekkeen arvo
a =	a	+(ekat sulut) 	- (tokat sulut);
3	3	+	0		-	4	//lasketaan lausekkeen arvo
	-1
-1							//ja sijoitetaan lausekkeen 							
							//arvo a:lle

//lopulliset muuttujien arvot
a=-1, i= -1
		
j)
Juoni on sama kuin edellä, eli ensin sijoitetaan vasemmaisin a, sitten sulut. Ekat sulut
lasketaan ennen toisia sulkuja, eli ekojen sulkujen laskennassa tapahtuvat muutokset 
muuttujien arvoissa vaikuttavat toisten sulkujen laskentaan.

a += (a += a--) + (a = i = a++);
a = a+ (a += a--) + (a = i = a++);
a = 3 + (ekat sulut) + (tokat sulut);


//jaetaan tämä osiin, lasketaan ensimmäisten sulkeiden arvo
(a 	+= 		a--)
3	3+		3		//lasketaan lausekkeen arvo
	6		
6					//sijoitetaan arvo a:lle
			6-1		//ja vähennetään a:ta yhdellä,
			5		//huom! tämä ei vaikuta seuraavien sulkeiden  					
					//arvoon, koska toisten sulkujen laskenta tehdään ennen
					//tätä vähennystä

//päivitetyt arvot:
i:n arvo ei muuttunut eli i=-4, a:n arvo on 5

//lasketaan toiset sulut, huom! laskenta tehdään päivitetyllä a:n 
//arvolla (ennen vähennystä)
(a 	= 	i 	= 	a++);
6				6	
		6			//sijoitetaan a:n arvo i:lle
					//ja edelleen a:lle
6
				6+1	//lopuksi kasvatetaan a:n arvoa yhdellä
				7	
 					

//päivitetyt arvot:
a=7, i=6

//ja lasketaan koko lauseke
a = 3 + (ekat sulut) 	+ (tokat sulut);
a = 3 +	5		+	7		//lasketaan lausekkeen arvo
	15
15						//ja sijoitetaan a:lle


//lopulliset arvot
a=15,i=6



Tämän tehtävän kaltainen ohjelmointityyli ei ole mielestäni kovinkaan mielekästä.
Tämän tehtävän ratkaisu tuotti myös tuhottomasti päänvaivaa (ainakin minulle)
eli toivottavasti voimme lopettaa tämän tehtävän sanoilla:

”Tästä tehtävästä opimme sen, ettei tällä tavalla todellakaan saa koodata!”
********************************************************/