Objektdesorientert javaprogrammering

Dersom du føler deg som en nybegynner i programmering så kan kanskje dette notatet være med på å demystifisere javaprogrammering noe. For deg som har erfaring med objektorientert programmering, kan det også være lurt å lese igjennom for å se det hele fra en litt annen vinkel. Hvis du synes det dukker opp mange nye ting underveis er det et tegn på at du skal ta et skritt tilbake fra objektorientert programmering. Slik kan du ta flere skritt fram igjen, når det grunnleggende er forstått.

Hva er et godt javaprogram?

Java uten objektorientering

public class MinKlasse {
    static int demoDummy = 14;

    /** returnerer i fakultet for 0 <= i <= 12 .*/
    public static int fakultet(int i)
    {
        if( i > 1 ) 
            return i * fakultet( i - 1 );
        else        
            return 1;
    }

    public static void main(String[] args)
    {
        System.out.println("6 fakultet: " + fakultet(6) );
    }
}

• En variabel skal deklareres static med mindre den skal være unik for hver instans av klassen.
• En metode skal være static med mindre den skal operere på medlemsvariable.

//Bra
int i = MinKlasse.fakultet(6);

//Dårlig design av MinKlasse
MinKlasse m = new MinKlasse(6);
int i = m.fakultet();

//Dårlig design av MinKlasse
MinKlasse m = new MinKlasse();
int i = m.fakultet(6);

Programflyt

public class Program {
    public static char f( char c ){
       System.out.print( c++ );
       return c--;
    }

    public static void main(String[] args)
    {
       if( f('j') == 'k' || f('f') == 'f'){
          System.out.println( f('d') );
       }
    }
}

Programflyten styres i tillegg til metodekall av kontrollstrukturer; if else, for, while, switch og av nøkkelord for å gjøre hopp; return, break, continue. Alt dette regnes som kjent stoff og dersom du skulle være i tvil om noe av dette finner du svaret i javaboka di. Programflyten ved metodekall regnes også som kjent stoff, men for sikkerhets skyld repeterer vi hvordan det fungerer.

Dersom vi kaller en metode fra en gitt kontekst (blokk), må denne metoden returnere før det neste metodekallet gjøres fra den samme konteksten. For å kunne kalle en metode må alle inputparametre (og en eventuell instans å kalle metoden på) være kjent. Det vil si at at disse må evalueres før selve metodekallet gjøres. Rekkefølgen er definert slik at det eventuelle objektet som har metoden evalueres før parameterne til metoden. I eksempelet under evalueres først metoden a() deretter b() og til slutt c(), fordi c blir kalt på objektet returnert fra a() og skal ha b()'s returverdi som parameter.

a().c( b() );

int i = (i = 3) + i; // i = 3 + 3;

minus( i = 5, i); // minus( 5, 5);

boolean T = true, F = false;
if( F || F || F || T || F || F || T || F || T );
if( T && T && T && F && T && F && F && T && F );

Presedens

Presedensregler er det som bestemmer i hvilken rekkefølge operatorer i uttrykk skal evalueres. Disse reglene sørger for at betydningen av uttrykk er entydig definert - selv uten parenteser. Parenteser er likevel klargjørende og kan brukes selv om språket ikke krever det. De operatorene som binder operandene tettest til seg har høyest presedens. Fra matematikken vet vi for eksempel at multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon og at parenteser brukes til å overstyre disse reglene. Under følger presedensreglene for operatorer i java.

Bruk tabellen over til å forstå hva som skjer i dette utrykket:

i+=i+++i;

Presedensregler kommer ikke i konflikt med regelen om at uttrykk skal evalueres fra venstre mot høyre. I uttrykket under evalueres a først, så b og deretter multipliseres disse. Tilsvarende skjer med c og d før hele utrykket adderes. Begrepet evaluere gir større mening dersom vi ser på a, b, c og d som mindre delutrykk, for eksempel metodekall. Operandene evalueres altså fra venstre mot høyre, mens operatorene følger presedensreglene.

a * b + c * d

Parameteroverføring ved metodekall

public class Program {
    public static void modifiser( int i )
    {
        i++;
    }

    public static void main(String[] args)
    {
        int i = 42;
        modifiser( i );          //ingen effekt.
        System.out.println( i ); //print 42
    }
}

public class Program {
    public static void modifiser( int[] array )
    {
        array[0]++;
    }

    public static void main(String[] args)
    {
        int array[] = [ 42 ];
        modifiser( array );
        System.out.println( array[0] ); //print 43
    }
}

Java med litt objektorientering

class Person {
    Person mor;
    Person far;
    String navn;
}

  Person jeg   = new Person();
  jeg.navn     = "h4X0r";
  jeg.mor      = new Person();
  jeg.mor.navn = "Kari";
  jeg.far      = new Person();
  jeg.far.navn = "Per";

    public static void traverser( Person p )
    {
        System.out.println( p.navn );
            if( p.mor != null ) traverser( p.mor );
            if( p.far != null ) traverser( p.far );
    }

class Person {
    String navn;
    Person mor;
    Person far;
}


public class Program {

    public static void traverser( Person p )
    {
        System.out.println( p.navn );
        if( p.mor != null ) 
            traverser( p.mor );
        if( p.far != null ) 
           traverser( p.far );    
    }

    public static void main(String[] args)
    {
        Person jeg   = new Person();
        jeg.navn     = "h4X0r";
        jeg.mor      = new Person();
        jeg.mor.navn = "Kari";
        jeg.far      = new Person();
        jeg.far.navn = "Per";
        traverser( jeg );
    }
}

class Person {
    private String navn;
    private Person mor;
    private Person far;

    /*konstruktør*/
    public Person(String navn)
    { 
        this.navn = navn;
    }

    public void settMor( Person mor )
    { 
        this.mor = mor; 
    }

    public void settFar( Person far ){
        this.far = far; 
    }
 
    public void traverser()
    {
       System.out.println( this.navn );
       if( this.mor != null ) 
           this.mor.traverser();
       if( this.far != null ) 
           this.far.traverser();    
    }
}


public class Program {
    public static void main(String[] args)
    {
        Person jeg   = new Person( "h4X0r" );
        jeg.settMor(   new Person( "Kari"  ) );
        jeg.settFar(   new Person( "Per"   ) );
        jeg.traverser();
    }
}

Objektorientert programmering

Hvordan skrive god kode

• Keep it simple. Ikke gjør ting vanskeligere enn det er. Spør deg selv hele tiden om dette kan gjøres enklere?
• En metode/funksjon skal utføre én oppgave, og utføre den oppgaven best mulig.
• Programkode skal være lettlest. Sørg alltid for at koden gjenspeiler det du prøver å gjøre.
• Gi beskrivende variabel- og metodenavn. Bruk korte navn som 'i' eller tilsvarende på lokale variabler for å telle igjennom løkker.
• Indenter riktig. Dersom du ikke har noen formening om hva riktig indentering er, bruk en teksteditor som gjør det for deg.
• Bruk mellomrom og linjeskift der det er naturlig for å øke lesbarheten.
• Vær konsekvent ved bruk av indentering, mellomrom og linjeskift.
• Ikke skriv for lange metoder. 20 linjer er max. Blir den lengre blir den vanskelig å forstå og du må tenke over hvilken del av metoden som skulle vært utskilt og skrive om metoden.
• Ikke skriv for lange linjer. 80 tegn er max. Dette gjør koden lettere å lese og du kan kan lese den i et terminalvindu eller skrive den ut uten at linjer blir brutt opp.
• Ikke bruk for mange nøstede nivåer. 5 nivåer er max - mer gjør koden uleselig.
• Indenteringen bør være minst fire tegn, men du kan godt bruke 8 ettersom du uansett aldri har behov for mer enn 5 nivåer.
• Alle inputparametre og returverdi hos en metode skal beskrives over metoden.
• Metoder skal ha et minimalt sett med inputparametre. Ikke send parametre som lett kan beregnes av de andre parameterne (for eksempel en tabell og tabellens lengde).
• Kommentarer inne i metoder skal være overflødige. Dersom du trenger kommentarer inne i koden er det et tegn på at den er lite lesbar og du bør skrive den om.
• Ikke gjør optimaliseringer på bit/instruksjonsnivå på bekostning av lesbar kode.

• En loop som skal gå igjennom alle elementer i en tabell (int array[]) kan skrives på mange måter. Den beste måten er den som er mest lesbar, dvs. den enkleste. Uansett bør array.length brukes som maksimumsgrense. Dette gjør det lett for leseren å se at hele tabellen blir gått igjennom og det motvirker feil når array har en annen størrelse enn du opprinnelig forutså.

  for( int i = 0; i < array.length; i++) {
      // behandle array[i]
      ...
      ...
  }
  

• Boolske uttrykk skal være så enkle som mulig.

      int a, b;
      if( ! ( a < b ) )             -->  if( a >= b )
      
      boolean a, b;
      if( (a && !b) || (!a && b) )  -->  if( a != b )
  

• Bruk den uttrykkskraften språket tilbyr, men ikke mer enn at det blir lesbart. Fakultetfunksjonen kan omskrives til en linje ved hjelp av spørsmålstegn-kolon-konstruksjonen:

  public static int fakultet( int i )
  {
      return  i > 1  ? i * fakultet( i - 1 ) : 1;
  }
  

• De logiske &&- og ||-operatorene kan være med å styre programflyten. Hvis vi har uttrykket (a && b) vil ikke b bli evaluert dersom a evaluerer til false. Dette kan forenkle enkelte kodebiter. F.eks:

  if( str != null )
      if( str.length() > i )
          if( str.charAt( i ) == '\n' ){
  

  Kan også skrives slik:

  if( (str != null) && (str.length() > i) && (str.charAt(i) == '\n') ){
  

Kilder:

• B.W. Kernighan, R. Pike (1999). The Practice of Programming,
• J. Gosling, B. Joy, G. Steele (1996). Java Language Specification
• Linus Torvalds, Linux Kernel Coding Style.