Java Syntax en conventies

In dit artikel gaan we in vogelvlucht over de verschillende Java syntax en leren we over naamgeving conventies. Zonder daadwerkelijk ervaring met code zijn dit lastige onderwerpen om te bevatten maar toch is het belangrijk om het hier even kort over te hebben zodat ik in het vervolg niet bij iedere nieuwe keywoord uitleg hoef te geven.

Java classes & objects

Java is Object Oriented Programming (OOP), dit houd in dat we programma’s schrijven door verschillende objecten met elkaar te laten communiceren. Hieronder behandelen we de basis termen hoe we objecten maken en opbouwen

• Class – Je hebt in het vorige artikel al een class gemaakt. Een class functioneerd als een sjabloon voor het maken van een object. Hierin beschrijf je hoe het object zich moet gedragen.
• Object – Objecten hebben een staat zodra deze worden gemaakt. En deze staat kan je gedurende het programma aanpassen.
• Variable – Variables houden waarden vast en bepalen zo de staat van het object. Het object van een auto heeft bijvoorbeeld een variable die aangeeft hoe snel de auto rijd.
• Method – Met behulp van methods kan je het gedrag van een object bepalen. Bij dezelfde auto kan een method beschrijven wat er gebeurt als het gaspedaal word ingedrukt. Bijvoorbeeld de variable snelheid vergroten.

Dit is wellicht lastig te begrijpen als je net begin, hieronder een stukje code dat de hele simpele auto van hierboven beschrijft.

Weet je nog hoe je een class bestand maakt? Dit doe je altijd in de map src. Druk rechtermuisknop op de src map en kies new -> Java Class.

public class Auto {

    // Hieronder de varable snelheid
    private int snelheid = 0;

    // Hieronder de method gaspedaal
    public void gaspedaalIndrukken(){
        snelheid = 10;
    }
}

Dit is een class en dit “sjabloon” gebruik je om auto objecten van te maken in het programma. Deze auto’s hebben ieder hun eigen unieke variable snelheid. De method gaspedaalIndrukken beschrijft wat er gebeurt met de status van de auto als de method word aangesproken. In dit geval vergroten we de variable snelheid.

standaard Naamgeving conventies

In praktisch alle programmeer talen is er een standaard voor hoe we bepaalde syntax schrijven. Door deze conventies toe te passen kunnen we syntax sneller herkennen en code beter lezen. Het is dus belangrijk dat je deze naamgeving conventies direct aanleert. In java gebruik je vooral PascalCase waar alle eerste letters van een woord een hoofdletter is en camelCase waar de eerste letter van het eerste woord geen hoofdletter is. Probeer oog te krijgen voor de verschillende conventies die er vaak gebruikt worden en pas deze ook toe. Hieronder de conventies van de syntax die we hierboven geleerd hebben.

• Class namen zijn PascalCase en beginnen dus altijd met een hoofdletter. De bestandsnaam moet altijd precies hetzelfde zijn als de class naam. Bijvoorbeeld MijnJavaClass.java met als class naam MijnJavaClass.
• Methods en variables schrijf je normaal gesproken camelCase en beginnen dus met een kleine letter zoals gaspedaalIndrukken(). Er zijn diverse uitzonderingen op deze regel, maar daar kom ik later op terug.

Java modifiers

In de code hierboven zien we private en public toegevoegd aan de variable en method. Dit zijn zogeheten access modifiers en bepalen of we toegang hebben to deze variables of methods van buitenaf. Er zijn 4 soorten access modifiers.

• public – Altijd toegang.
• private – Geen toegang.

De volgende twee zijn voorlopig niet belangrijk maar voor de volledigheid benoem ik deze toch.

• protected – Toegang als het object een “child” is van het object met de protected modifier.
• default – Toegang als het object die dit gebruikt zich in dezelfde package bevindt. Een package is een soort folder/map. Als je structuur wilt aanbrengen in de src folder maak je geen nieuwe mappen aan in java maar packages.

Dan zijn er nog enkele andere modifiers. Ook deze zijn voorlopig niet belangrijk.

• final – variables met final ervoor kunnen na het aanmaken van een object niet meer veranderd worden.
• abstract – hiermee kunnen we abstracte classes en methods maken die nog geen code en “implementatie” hebben. Abstractie is een heel belangrijk concept in OOP maar voor nu nog te lastig om uit te leggen.
• strictfp – Deze was ik eigenlijk alweer vergeten en gebruik het eigenlijk nooit. Een floating point nummer is een nummer met x aantal decimalen echter is dit na 6 plaatsen achter de komma niet meer nauwkeurig. Normaal gesproken worden floating point nummers per platform en zelfs hardware waar java op draait verschillend berekend en dit heeft als bijkomend effect dat je programma dan anders zou kunnen gaan functioneren. strictfp zorgd ervoor dat het nummer per platform gelijk is.

Java variables

Hier hebben we het al kort over gehad maar er bestaan nog een aantal andere soorten variables.

• Instance variables – Deze hebben we boven gebruikt en behoren toe aan het object. Ieder object dat we maken van de class heeft zijn eigen unieke locale variables hierdoor kan bijvoorbeeld ieder auto object zijn eigen snelheid hebben.
• Class variables – Deze behoren toe aan de class, het sjabloon dus. Je krijg ook geen toegang tot deze variable via het object maar moet de class naam typen en het van daaruit aanspreken. Class variables noemen we ook wel static variables omdat we dit keywoord moeten gebruiken. De naamgeving conventie start met een hoofdletter bijvoorbeeld public static String AutoMerk = "Audi" zou een goede static variable zijn voor een Audi fabriek. Als we hier een private access modifier gebruiken hebben we alleen toegand vanuit dezelfde class tot deze variable.
• Local variables – dit zijn variables die we nodig hebben binnen de methods of blokken code binnen deze methods. Ze worden niet onthouden en representeren dus geen staat van het object in questie.

Java Enums

Een Enum staat voor enumaration, of opsomming, en stelt ons in staat een variable te beperken tot een aantal specifieke waarden. Door het gerbuik van emumerations kunnen we onze code beter leesbaar en voorspelbaarder maken. Als er bijvoorbeeld ergens een bepaalde waarde van een variable verwacht dan is het gebruik van een Enum gewenst. Hieronder nemen we het auto type als enum omdat er maar een x aantal typen zijn.

public class Auto {
    public enum Type {
        Sedan,
        Hatchbag,
        Station,
        Cabrio,
        Coupe
    }
    private Type type = Type.Station;

    // Hieronder de varable snelheid
    private int snelheid = 0;

    // Hieronder de method gaspedaal
    public void gaspedaalIndrukken(){
        snelheid = 10;
    }
}

Nadat we de enum hebben gemaakt maken we hier een variable voor om de waarde in te houden. Zoals je ziet verkrijgen we de type auto uit de enum Type als een soort static variable. Static variables worden vaak ook gebruikt voor soortgelijke doeleinden maar een enum zorgd er specifiek voor dat de waarde alleen een van de ingevoerde waarden binnen de enum kan zijn.

Java Arrays

Arrays kunnen meerdere waarden vasthouden van hetzelfde type. Een array heeft altijd een vaste lengte en bij het maken van een array moet deze waarde ook opgegeven worden. Als de lengte op voorhand niet te bepalen is zijn er andere data typen om een reeks variables in op te slaan. Later meer over deze collectie en arrays.

Java opmerkingen

Opmerkingen oftwel comments zijn essentieel voor het schrijven van nette code die makkelijk terug leest. De volgende code demonstreerd een aantal comments.

public class MijnJavaClass {

    // Dit is een commend op een enkele lijn.

    /*  Dit is een voorbeeld
        van comment op
        meerdere lijnen
    */

    /** Deze comment word getoont in de tekst als de onderstaande variable word aangesproken in de IDE **/
    public int test;

    /**
     * Deze comment word getoont in de tekst als onderstaande method word aangesproken in de IDE
     */
    public void testMethod(){
    }
}

De onderste twee comments geven je de mogelijkheid om je code te documenteren. Als je nu vanuit een heel ander deel in je programma dit object gebruikt dan krijg je deze code te zien zodat je exact weet wat het doet mits je dit natuurlijk op deze manier hebt gedocumenteerd. Net als de duizenden java objecten die je gaat gebruiken voor jou programma’s en zeer zeker ook in code bibliotheken van anderen zal je zien dat de meeste classes en methods op deze manier gedocumenteerd zijn. In IntelliJ IDEA ga je met de cursor op een method of class staan en druk je CTRL + Q.

In het volgende deel gaan we wat dieper in op OOP princiepen en nemen we inheritence, interfaces en abstractie onder de loop.