Tässä oppaassa käsitellään C++ kieltä ja sen olio-ominaisuuksia. Oppaan lähtökohtana, on että lukija on ohjelmoinut C-kielellä.

Aiheeseen liittyviä video-oppaita löytyy sivulta https://www.youtube.com/playlist?list=PLWl0bS7jZq9_6i4B1l4Im6sx9DKwUo7OU

Oppaaseen liittyvien esimerkkien lähdekoodit löytyy sivulta https://github.com/orgs/olio-kurssi/repositories.

Olio-ohjelmoinnin tärkeimmät käsitteet ovat luokka ja olio. Voisit ajatella, että luokka on ohjelmoijan tekemä uusi muuttujatyyppi ja olio muuttuja, jonka tyyppinä on tuo luokka. Voit siis verrata sitä tilanteeseen, jossa määrittelet muuttujan lauseella int age;. Samalla tavalla määrittelet olion lauseella Student myObject;. Sinun on kuitenkin itse luotava tuo luokka nimeltään Student.

Milloin on tarpeen luoda luokka ja olio?
Esimerkiksi teet sovelluksen, jossa käsittelet opiskelijoiden tietoja. Jokaiselle opiskelijalle määritellään nimi, syntymävuosi, osoite, sähköpostiosoite ja puhelinnumero. Yhdelle opiskelijalle sinun on luotava 5 muuttujaa. Jos käsittelet 10 opiskelijan tietoja, sinun on luotava 50 muuttujaa.

Edellistä parempi ratkaisu on luoda tietue, jossa määritellään nuo 5 muuttujaa. Ja sitten luot 10 muuttujaa, joiden tyyppinä on tuo tietue.

Miksi luoda luokka, jos tietuekin toimii?
Luokan sisään voit sijoittaa myös metodeja eli funktioita. Niiden avulla voit esimerkiksi antaa edellä mainutuille 5:lle muuttujalle arvoja hallitummin. Ja voit luoda metodeja jotka tulostavat noiden muuttujien arvoja haluamallasi tavalla.

Kun tehdään graafisia sovelluksia tarvitaan paljon buttoneita, tekstikenttiä, labeleita, alasvetovalikoita jne. Yleensä käytetään jotain valmiita kirjastoja tai frameworkkejä. Niissä on valmiiksi tehtynä esimerkiksi Button luokka, jolla on ominaisuuksia: buttonissa oleva teksti, klikkauksen aiheuttama tapahtuma, buttonin väri, reunojen tyyli jne. Aina kun laitamme omaan sovellukseemme buttonin, luomme Button luokan olion.

Mikä on Qt?
Qt on framework jolla voidaan luoda graafisia sovelluksia. Qt sisältää joukon valmiiksi tehtyjä luokkia, joita voimme hyödyntää. Kun asennat Qt:n voit asentaa myös Qt Creatorin. Qt Creator on graafinen sovellus, jolla voidaan luoda Qt-sovelluksia ja myös C- ja C++-sovelluksia.

Aluksi on syytä tutustua kuinka C++ kielessä tulostetaan konsolin ruudulle ja kuinka sieltä luetaan käyttäjän antamaa dataa. Voit toki käyttää C-kielestä tuttuja funktioita printf ja scanf, mutta niiden sijaan käytetään yleensä olioita: cout ja cin. Molemmat ovat iostream luokan olioita, joten niitä käyttäessäsi sinun tulee lisätä kooditiedostoon alkuun rivi

#include <iostream>

C++ kielessä voidaan käyttää merkkijonoille muuttujatyyppiä string, jota C-kielessä ei ole. C-kielessähän merkkijonoille käytettiin char -taulukkoja. Tuo string, samoin kuin cout ja cin on määritetty nimiavaruudessa eli namespace:ssa nimeltään std.

Voisit tehdä lyhyen ohjelman koodilla

#include <iostream>

int main()
{
    std::string name;
    std::cout<<"Kerro nimesi"<<std::endl;
    std::cin>>name;
    std::cout<<"Terve "<<name<<std::endl;
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    string name;
    cout<<"Kerro nimesi"<<endl;
    cin>>name;
    cout<<"Terve "<<name<<endl;
    return 0;
}

Olio-ohjelmoinnin kaksi keskeistä termiä ovat luokka ja olio. Olio-ohjelmoinnissa tieto ja sitä käsittelevä toiminnallisuus kootaan luokkarakenteeksi. Luokista luodaan olioita.

Olio-ohjelmointia tukevia kieliä ovat mm. C++, C#, Java ja Visual Basic. C++ poikkeaa muista edellä mainituista siten, että C++ sovelluksia ajetaan suoraan käyttöjärjestelmän päällä. Muilla edellä mainituilla kielillä tehdyt sovellukset ajetaan virtuaalikoneessa. Edellä mainitun eron vuoksi C++ sovellukset vaativat vähemmän resursseja koneelta ja toimivat näin nopeammin, varsinkin heikkotehoisissa koneissa. Haittapuolena on, että C++ sovelluksen ohjelmoiminen on työläämpää. C++ ohjelmoijan tulee itse huolehtia esimerkiksi muistin varaamisesta ja vapauttamisesta, kun muissa em. kielissä virtuaalikone huolehtii siitä. Alla olevassa kuvassa kuvataan C++ - ja Java-sovelluksen toimintaa.

Opiskeltuasi c-kieltä tietue lienee sinulle tuttu käsite. Myös C++ ohjelmassa voit luoda tietueita esimerkiksi seuraavasti:

typedef struct Person_struct{
    int age;
    string name;
}
person;

person pe;

pe.age=23;
pe.name="Teppo Testi";

Luokka voisi olla samanlainen, mutta usein se sisältää myös metodeja, joiden avulla noita muuttujia käsitellään. Voidaan luoda Person luokka seuraavasti:

class Person{
    private:
        int age;
        string name;
    public:
        int getAge() const {
            return age;
        }
        void setAge(int value){
            age=value;
        }
        string getName() const {
            return name;
        }
        void setName(string value){
            name=value;
        }
};

Luokan sisältämiä muuttujia nimitetään jäsenmuuttujiksi ja luokan sisältämiä funktioita (jotka käsittelevät em. muuttujia) nimitetään jäsenfunktioiksi eli metodeiksi.

Oheisen esimerkin sovellus, löytyy sivulta https://github.com/olio-kurssi/esim1

#ifndef PERSON_H
#define PERSON_H

#include <iostream>

using namespace std;

class Person
{
public:
    Person();
    int getAge() const;
    void setAge(int newAge);

    string getFname() const;
    void setFname(const string &newFname);

private:
    int age;
    string fname;
};

#endif // PERSON_H

#include "person.h"

Person::Person()
{

}

int Person::getAge() const
{
    return age;
}

void Person::setAge(int newAge)
{
    age = newAge;
}

string Person::getFname() const
{
    return fname;
}

void Person::setFname(const string &newFname)
{
    fname = newFname;
}

class MyClass {
    int age;
public:
    void setValue(int age) {
        this->age = age;  // Erotellaan jäsenmuuttuja ja parametri
    }
};

Person objectPerson1;

//luo osoitin, jonka tyyppinä Person    
Person *objectPerson2;
//varaa osoittimelle muistia new operaattorilla
*objectPerson2 = new Person;

Person *objectPerson2 = new Person;

objectPerson1.setAge(23);

objectPerson2->setAge(23);

delete objectPerson2;
objectPerson2 = nullptr;

#include <memory>
unique_ptr<Person> objectPerson = make_unique<Person>();

#include <iostream>
#include <memory>

using namespace std;
class TestClass{
public:
    TestClass(string value){
        fname=value;
        cout<<"TestClass olio luotiin"<<endl;
    }
    ~TestClass(){
        cout<<"TestClass olio tuhottiin"<<endl;
    }
    string getName(){
        return fname;
    }
private:
    string fname;
};


void functionFirst();
void functionSecond(shared_ptr<TestClass> ptr);


int main()
{
    functionFirst();
}

void functionFirst(){
    shared_ptr<TestClass> ptr1=make_shared<TestClass>("Teppo");
    cout<<"Funktiossa1 nimi = "<< ptr1->getName()<<endl;;
    functionSecond(ptr1);
}
void functionSecond(shared_ptr<TestClass> ptr2){
    cout<<"Funktiossa2 nimi = "<< ptr2->getName()<<endl;
}

TestClass olio luotiin 
Funktiossa1 nimi = Teppo 
Funktiossa2 nimi = Teppo 
TestClass olio tuhottiin 

Edellä, jo kerrottiin, että luokan muodostin on metodi, jolla on sama nimi kuin itse luokalla. Muodostinta kutsutaan aina kun luokasta luodaan olio. Sillä ei ole koskaan paluuarvoa, eikä paluuarvoksi kirjoiteta edes sanaa void.

Voit lisätä muodostimelle parametrin tai useita parametrejä. Jos edellä muokattaisiin luokan muodostin h tiedostossa muotoon

Person(int value);

Person::Person(int value)
{
    age=value;
}

Person objectPerson(46);

Person *objectPerson=new Person(46);

Person *objectPerson=new Person;

Person();
Person(int value);

Luokan tuhoaja on myös saman niminen kuin luokka, mutta sen edessä on merkki ~ eli seuraava olisi h-tiedostossa

~Person();

Person::~Person()
{
    cout<<"Person luokan tuhoajaa kutsuttiin\n";
}

Person *objectPerson=new Person;
delete objectPerson;
objectPerson=nullptr;

Sinun ei ole pakko luoda luokalle tuhoajaa, koska kääntäjä luo automaattisesti "näkymättömän tuhoajan". Ohjelmoijan kannattaa luoda tuhoaja vain, jos haluaa lisätä siihen jotain koodia.

Oheiseen esimerkkiin liittyvä sovellus, löytyy sivulta https://github.com/olio-kurssi/esim2

C++ mahdollistaa funktioiden ylikuormittamisen (function overloading) eli sen, että saman nimisiä funktioita on useita, mutta niillä on erilaiset parametrit. Myös palautusarvot voivat olla erilaisia, mutta pelkät erilaiset paluuarvot eivät mahdollista ylikuormitusta, jos parametrit ovat samat. Kääntäjä valitsee funktion kutsussa annettujen argumenttien avulla sopivan funktion.

Esimerkki ylikuormittamisesta

void calcSum(int a, int b){
    int sum=a+b;
    cout<<"Kokonaislukujen summa = "<<sum<<endl;
}
void calcSum(double a, double b){
    double sum=a+b;
    cout<<"Desimaalilukujen summa = "<<sum<<endl;
}

Periytyminen eli inheritance tarkoittaa, että jokin luokka voi periä toisen luokan. Ajatellaan esimerkiksi että rakentaisimme sovellusta, jolla käsitellään jonkin oppilaitoksen dataa. Todetaan, että oppilaitoksessa on opiskelijoita ja opettajia. Molemmilla on monia samalaisia ominaisuuksia, kuten esimerkiksi nimi ja syntymävuosi. Lisäksi opiskelijoilla on ryhmätunnus ja opettajilla on osasto.

Nyt voidaan tehdä niin, että

1. luodaan kantaluokka Person, johon laitetaan kaikille yhteiset ominaisuudet
2. luodaan luokka Student, joka perii luokan Person ja luokalla on lisäominaisuus groupName
3. luodaan luokka Teacher, joka perii luokan Person ja luokalla on lisäominaisuus department

Perityminen merkitään Student-luokalle näin:

class Student : public Person

Oheiseen esimerkkiin liittyvä sovellus, löytyy sivulta https://github.com/olio-kurssi/esim3. Sovelluksen luokkakaavio näyttää seuraavalta:

Periytymisen yhteydessä on syytä tutustua termiin protected, kun luokka perii toisen luokan se pääsee käsiksi ominaisuuksiin, jotka ovat tyypiltään public tai protected. Seuraavassa taulukossa kuvataan kuinka private, public ja protected rajaavat oikeuksia.

Edellä kuvattiin luokan jäsenten suojauksia. Periytymiselle voidaan myös määrittää suojaus seuraavilla vaihtoehdoilla

• class Student : public Person
  jolloin perivällä luokalla on pääsy perittävän public- ja protected-jäseniin
• class Student : protected Person
  jolloin perittävän luokan public-jäsenistä tulee perivän luokan protected-jäseniä
• class Student : private Person
  jolloin perittävän luokan public- ja protected-jäsenistä tulee perivän luokan private-jäseniä

Voit lukea lisätietoa periytymisestä sivulta https://www.tutorialspoint.com/cplusplus/cpp_inheritance.htm

Mikäli peritävässä luokassa on muodostin, joka ottaa parametreja, voidaan perivän luokan konstruktorissa kutsua tuota muodostinta.

Esimerkiksi, jos Person luokassa on seuraava muodostin

Person::Person (string na){
    name=na;
}

Student::Student(string gr, string na ) : Person(na){
    groupName=gr;
} 

Jos edellä Person luokalla on oletusmuodostin ja public tyyppinen metodi setName(), voitaisiin Student-luokan muodostin kirjoittaa muotoon:

Student::Student(string gr, string na ) {
    groupName=gr;
    this->setName(na);
} 

Ylikirjoittaminen (overriding) C++-ohjelmoinnissa tarkoittaa, että aliluokka määrittelee uudelleen kantaluokassa perityn virtuaalisen funktion. Kun ylikirjoitettu funktio kutsutaan aliluokan instanssin kautta, suoritetaan aliluokan versio kyseisestä funktiosta. Tämä mahdollistaa polymorfismin, jossa aliluokka voi muokata kantaluokan toiminnallisuutta omien tarpeidensa mukaisesti.

Ylikirjoittaminen edellyttää, että sekä kantaluokan että aliluokan funktiot ovat määritelty samalla nimellä, paluuarvolla ja parametreilla, ja kantaluokan funktion on oltava virtual-avainsanalla merkitty. Aliluokan funktio voidaan myös merkitä override-avainsanalla selkeyden vuoksi.

Seuraavassa esimerkissä lisäsin Person luokkaan metodin sayStatus ja ylikirjoitin sen Students ja Teacher luokissa.

Alla rivit h-tiedostoista

person.h
virtual void sayStatus();

student.h 
virtual void sayStatus() override; 

teacher.h 
virtual void sayStatus() override; 

void Person::sayStatus()
{
    cout<<"Person\n ";
}
void Student::sayStatus()
{
    cout<<"Opiskelija: ";
}
void Teacher::sayStatus()
{
    cout<<"Opettaja: ";
}

Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim4

Luokkien välillä voi olla seuraavanlaisia suhteita

• Kompositio: Tarkoittaa sitä, että luokan sisällä on jäsenenä toisen luokan olio. Kompositiossa luokka koostuu yhdestä tai useammasta toisesta oliosta, mikä ilmentää "on osa" -suhdetta. Tämä on yleinen tapa luoda monimutkaisia olioita yhdistämällä yksinkertaisempia komponentteja. Esimerkiksi, "Talo" koostuu "Huoneista", ja jos talo tuhoutuu, myös sen huoneet tuhoutuvat.
• Assosiaatio: Tämä viittaa kahden tai useamman luokan väliseen suhteeseen, jossa toinen luokka käyttää toisen luokan jäseniä. Se ei osoita omistussuhdetta eikä määrittele elinkaarisuhdetta, vaan yksinkertaisesti ilmaisee, että luokat ovat jollain tavalla yhteydessä toisiinsa. Esimerkiksi luokka "Auto" ja luokka "Moottori" voivat olla assosioituneita, koska auto käyttää moottoria.
• Aggregaatio: Tässä suhteessa yksi luokka "omistaa" toisen luokan ilmentymän. Se on looginen suhde, jossa yksi objekti koostuu toisista objekteista, mutta niillä voi olla oma elinkaari. Esimerkiksi, "Auto" voi sisältää "Moottorin", mutta moottori voi olla olemassa ilman autoakin.

Kompositio eli vahva kooste tarkoittaa tilannetta, jossa koosteluokka sisältää toisen luokan olion/olioita. Esimerkissä 6 on luokka Classroom, joka sisältää kaksi Student-luokan oliota ja yhden Teacher-luokan olion seuraavasti:

class Student {

}
class Teacher {

}
Class Classroom{
private:
    unique_ptr<Student> objStudent1;
    unique_ptr<Student> objStudent2;
    unique_ptr<Teacher> objTeacher;
}

Sovelluksen luokkadiagrammi pelkistettynä näyttää tältä

Classroom on siis koosteluokka. Tässä esimerkissä Student- ja Teacher-luokan oliot luodaan smart pointtereiden avulla, mutta ne voitaisiin luoda myös "normi" pointtereilla tai pinomuistiin.

Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim6

Assosiaatiossa koostavan luokan konstruktorille tai jollekin metodille annetaan parametrina toisen luokan olio esimerkiksi näin:

    Engine objectEngine;
    Car objectCar(objectEngine);

Aggregaatiossa koostavan luokan konstruktorille tai jollekin metodille annetaan parametrina olion osoite esimerkiksi näin:

    Engine objectEngine;
    Car objectCar(&objectEngine);

// Luodaan osoite shared_ptr:llä
shared_ptr<Address> objA1 = make_shared<Address>("Yliopistokatu 10", "Oulu");

// Luodaan henkilöitä, jotka käyttävät samaa osoitetta
Person objPerson1("Teppo Joki", objA1);
Person objPerson2("Aino Joki", objA1);

Person::Person(string n, shared_ptr<Address> a){
    this->name=n;
    this->objAddres=a;
}

Esimerkki löytyy sivulta https://github.com/olio-kurssi/aggregation

Kooste ja perintä ovat molemmat oliosuuntautuneita ohjelmistomalleja. Kooste tarkoittaa has a-tyyppistä suhdetta ja perintä is a-tyyppistä suhdetta. Tämän sivun esimerkeistä voidaan sanoa, että

• "Student is a Person", joten käytetään perintää
• "Classroom has a Student", joten käytetään koostetta

C++-vektori on osa C++ Standard Libraryä ja se on dynaaminen taulukko, joka voi mukautua erilaisiin datamäärien muutoksiin. Se tarjoaa samankaltaisia ominaisuuksia kuin perinteinen taulukko, kuten nopea elementteihin pääsy, mutta toisin kuin perinteiset taulukot, vektorin koko voi muuttua joustavasti.

Jos sovelluksessa tarvitaan monta oliota samasta luokasta, voidaan niistä luoda lista vektorin avulla. Seuraavassa esimerkissä luodaan oliolista, joka sisältää Student-luokan oliota. Listan käytöstä erillisten olioiden sijaan on etuna se, että listaa voidaan käydä läpi toistorakenteella.

#include "student.h"

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    vector<Student> studentList;

    //luodaan Student-luokan oloita
    Student objectStudent0("Teppo Testi",1999,"TVT23SPL");
    Student objectStudent1("Liisa Joki",1998,"TVT23SPL");
    Student objectStudent2("Aino Virta",1997,"TVT23SPO");
    Student objectStudent3("Matti Virtanen",2001,"TVT23SPO");
    Student objectStudent4("Mikko Vilkas",2001,"TVT23SPL");

    //lisätään luodut oliot listaan
    studentList.push_back(objectStudent0);
    studentList.push_back(objectStudent1);
    studentList.push_back(objectStudent2);
    studentList.push_back(objectStudent3);
    studentList.push_back(objectStudent4);

    for(int x=0; x<=4; x++){
        studentList[x].printStudentData();
    }
    return 0;
}

Esimerkissä 7 on käytetty smart_pointteria ja sen main.cpp on seuraava

#include "student.h"

#include <iostream>
#include <vector>
#include <memory>

using namespace std;

int main()
{
    unique_ptr<vector<Student>> studentList = make_unique<vector<Student>>();

    Student objectStudent0("Teppo Testi",1999,"TVT23SPL");
    Student objectStudent1("Liisa Joki",1998,"TVT23SPL");
    Student objectStudent2("Aino Virta",1997,"TVT23SPO");
    Student objectStudent3("Matti Virtanen",2001,"TVT23SPO");
    Student objectStudent4("Mikko Vilkas",2001,"TVT23SPL");

    studentList->push_back(objectStudent0);
    studentList->push_back(objectStudent1);
    studentList->push_back(objectStudent2);
    studentList->push_back(objectStudent3);
    studentList->push_back(objectStudent4);

    // Hae opiskelijalista studentList-osoittimesta
    vector<Student>& students = *studentList;

    for(int x=0; x<=4; x++){
        // Käytä opiskelijalistan elementtiä `x` ja kutsu printStudentData() -funktiota
        students[x].printStudentData();
    }

    return 0;
}

Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim7

Abstrakti luokka, tarkoittaa luokkaa, josta ei voi luoda oliota, mutta luokkaa voidaan käyttää kantaluokkana muille luokille. Edellisessä esimerkissä voisimme tehdä Person luokasta abstraktin.

Edellisessä esimerkissä voit luoda Person luokasta olion. Luokka saadaan abstraktiksi, jos siihen lisätään yksi pure virtual method. Muutetaan Person luokassa sayStatus() metodin määrittely muotoon

virtual void sayStatus()=0;

Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim5

Virtuaalifunktioita sisältävän luokan tuhoajan pitää myös olla virtuaalinen.

Olio-ohjelmoinnissa käsite interface tarkoittaa luokkaa, josta ei tehdä olioita. Siinä määritellään metodeja, muttei niiden toteutuksia. Siis määritetään metodien paluuarvojen tyypit ja parametrien tyypit. Kun jokin luokka perii tuon interface luokan on perivän luokan toteutettava interface luokan metodit, muuten seuraa virheilmoitus.

Javassa ja C#:ssa interface luokka toteutetaan lisäämällä sana interface luokan määrityksen eteen. C++:ssa ei tällaista sanaa ole vaan interface luokka voidaan toteuttaa tekemällä metodeista puhtaita virtuaalimetodeja. Interface luokan nimi alkaa usein kirjaimella I.

Tein esimerkin, jossa on interface luokka nimeltään IPerson ja Student ja Teacher perivät sen, sekä luokan Person. Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim8

Staattinen luokka tarkoittaa luokkaa, jonka metodeita voidaan kutsua luomatta oliota kyseisestä luokasta. C++ kielessä ei voida luoda varsinaista staattista luokkaa, mutta toiminnallisesti käsitettä vastaa luokka, jonka kaikki metodit ovat staattisia.

Esimerkiksi C#:ssa on luokka Math, josta löytyy esimerkiksi funktio sqrt. Ei ole järkevää, että voidaksesi käyttää tuon luokan metodeja sinun tulisi luoda luokasta olio. Voit laskea esimerkiksi luvun 4 neliöjuuren koodilla Math.Sqrt(4).

Tein esimerkin, jossa on luokka nimeltään MyStaticClass ja siellä määritettynä metodi doubleMe. Luokan h-tiedostossa metodi on määritetty näin:

static double doubleMe(double);

double MyStaticClass::doubleMe(double value)
{
    return 2*value;
}

myResult=MyStaticClass::doubleMe(myValue);

Voit kuitenkin luoda olioita luokasta MyStaticClass. Jos haluat estää olioiden luomisen, voit muokata luokan oletusmuodostimen h-tiedosssa seuraavaan muotoon:

MyStaticClass()=delete;

Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim9

UML eli Unified Modeling Language on standardoitu tapa kuvata ohjelmisto- ja järjestelmäsuunnittelua visuaalisesti. Se tarjoaa erilaisia kaavioita ja työkaluja ohjelmistojen rakenteen, toiminnallisuuden ja käyttötapauksien mallintamiseen. UML auttaa suunnittelijoita kommunikoimaan, ymmärtämään ja dokumentoimaan ohjelmistojen arkkitehtuuria ja toiminnallisuutta.

Luokkakaavio on UML-standardin mukainen mallinnustyyppi, joka kuvaa järjestelmän staattisen rakenteen luokkien ja niiden välisten suhteiden avulla.

Luokka piirretään suorakaiteena, joka on jaettu kolmeen osaan; luokan nimi, luokan tiedot (jäsenmuuttujat) ja luokan toiminnallisuus (jäsenfunktiot).

Diagrammeissa käytetyt suojaustasoa kuvaavat symbolit ovat:

• - : private
• + : public
• # : protected

Esimerkiksi jäsenmuuttuja osiossa voisi olla rivi:
-age:int
joka tarkoittaa, että luokka sisältää int tyyppisen muuttujan nimeltään age, jonka suojaustaso on private

Ja jäsenfunktio osiossa voisi olla rivi:
+getInfo(int):float
joka tarkoittaa, että public metodi getInfo ottaa vastaan argumenttina int tyyppisen arvon ja palauttaa float tyyppisen arvon

Kontruktoria ei välttämättä merkitä diagrammiin.

Oppaaseen liittyvien esimerkkien lähdekoodit löytyy sivulta https://github.com/orgs/olio-kurssi/repositories.

repository	aihe
esim0	Tietue
esim1	Luokka ja olio (pino ja keko)
esim2	Muodostin ja tuhoaja
esim3	Periytyminen
esim4	Virtuaalimetodi
esim5	Abstraktiluokka
esim6	Koostaminen
esim7	Oliotaulukko
esim8	Interface luokka
esim9	Staattinen luokka
unit_test	Yksikkötestaus