# TypeScript-luokkien määritteleminen ja käyttö

TypeScript-luokat tarjoavat selkeän ja jäsennellyn tavan järjestää data ja käyttäytyminen **objektissa**. Tämä helpottaa entiteettien ja käsitteiden mallintamista koodissasi.

## Mitä ovat TypeScript-luokat?

Luokat ovat keskeinen käsite TypeScript-kielessä, joka on JavaScript-pohjainen ohjelmointikieli. Luokat edustavat **jäsenneltyä menetelmää objektien määrittelemiseksi** ja olio-ohjelmoinnin (OOP) soveltamiseksi. TypeScript-luokat ovat kuin suunnitelmia objektien luomiseksi, jotka kokoavat loogisesti toisiinsa liittyviä tietoja ja menetelmiä.

[TypeScript](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/mikae-on-typescript/) sisältää kaikki JavaScriptin toiminnot ja lisäksi **staattisen tyypityksen**. Tämän ansiosta voit määrittää [TypeScript-funktioiden](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/typescript-functions/), muuttujien ja luokkien tietotyypit, jolloin voit havaita kompiloinnin aikaiset virheet. Tyyppiturvallisuuden lisäksi TypeScript-luokat tukevat myös perintää ja abstraktiota, mikä helpottaa monimutkaisten sovellusten kehittämistä.

TypeScript-luokkien avulla voit luoda selkeän **luokkahierarkian, jossa luokat** perivät ominaisuuksia ja metodeja. Tämä edistää koodin uudelleenkäyttöä ja jäsentelyä. Luokkien konstruktorit mahdollistavat instanssien alustamisen ja varmistavat yhdenmukaisen objektien luomisen.

## Mikä on TypeScript-luokkien syntaksi?

TypeScript-luokkien merkintätapa on samanlainen kuin **ECMAScript 6:ssa (ES6)** ja se on JavaScript-luokkasyntaxin laajennettu versio. TypeScript-luokka voi sisältää erilaisia elementtejä, joilla määritellään objektien rakenne ja käyttäytyminen. Tärkeimmät komponentit ovat:

- **Ominaisuudet**
- **Rakentajat**
- **Menetelmät**

### Ominaisuudet

Ominaisuudet määrittävät **objektin tilan**. Ne tallentavat data-arvoja ja niihin voidaan liittää datatyyppejä, jotta niillä on vain kelvollisia arvoja.

```typescript
class ClassName {
    propertyName: propertyType;
}
```

- **ClassName**: luokan nimi
- **propertyName**: määriteltävän ominaisuuden nimi
- **propertyType**: ominaisuuden tietotyyppi

Tässä on konkreettinen esimerkki:

```typescript
class Person {
    name: string;
}
```

Ensin määritellään `Person` -luokka, jolla on tyypin `string` ominaisuus `name`. Tämä tarkoittaa, että `Person` -luokan instansseilla on `name` -ominaisuus, joka tallentaa **merkkijonoja**.

### Rakentaja

TypeScriptin konstruktori on erityinen menetelmä, jota kutsutaan, kun luokan instanssi (objekti) luodaan. Sitä tarvitaan **objektin ominaisuuksien alustamiseen**. Konstruktori määrittelee olennaisesti instanssin alkutilan. Konstruktorissa voi määrittää parametreja, joilla välitetään arvoja TypeScript-luokkien instansointia varten.

TypeScript-kielessä konstruktorin perusrakente on seuraava:

```typescript
class ClassName {
    constructor(parameter1: Type1, parameter2: Type2, ...) {
    }
}
```

- **konstruktori**: jokaisella luokalla voi olla yksi konstruktori. Jos konstruktoria ei ole määritelty, luodaan oletusarvoisesti tyhjä konstruktori.
- **parametri: Tyyppi**: parametrit ovat valinnaisia, riippuen luokasta ja sen vaatimuksista. Parametrit tulisi merkitä niiden tietotyypeillä.

Esimerkki konstruktorista:

```typescript
class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}
```

Yllä olevassa esimerkissä luokalla `Person` on konstruktori, joka hyväksyy kaksi parametria `firstName` ja `lastName`. Kun **luodaan** tämän luokan **instanssi**, nämä parametrit välitetään, ja konstruktori alustaa instanssin `firstName` ja `lastName` ominaisuudet vastaavilla arvoilla. `this` viittaa luokan nykyiseen instanssiin, jossa koodi suoritetaan.

### Menetelmät

TypeScriptissä metodit ovat funktioita, jotka voidaan määritellä luokissa ja soveltaa niiden instansseihin. Metodoiden avulla voit suorittaa **tiettyjä toimintoja tai operaatioita** luokan kontekstissa.

```typescript
class ClassName {
    // ...
    methodName(parameter1: Type1, parameter2: Type2, ...): ReturnType {
    }
    // ...
}
```

- **methodName**: menetelmän nimi
- **parameter: Tyyppi**: menetelmän hyväksymät valinnaiset parametrit
- **ReturnType**: tämä on tietotyyppi, joka määrittää menetelmän palauttaman arvon. Jos menetelmä ei palauta mitään, voit määrittää arvon `void`.

Voit käyttää luokkainstanssin ominaisuutta tai kutsua sen menetelmää pisteoperaattorilla `.`, jota seuraa menetelmän nimi ja tarvittavat argumentit, jos menetelmä odottaa parametreja.

```typescript
class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    getFullName(): string {
        return this.firstName + " " + this.lastName;
    }
}
const person = new Person("John", "Doe");
const fullName = person.getFullName();
```

Menetelmää `getFullName` käytetään luomaan ja palauttamaan henkilön koko nimi. Se käyttää luokassa määriteltyjen ja konstruktorissa alustettujen ominaisuuksien `firstName` ja `lastName` arvoja. Objekti `person` luodaan avainsanalla `new`, jota seuraa luokan nimi ja vastaavat parametrit. Menetelmä **yhdistää kaksi merkkijonoa**, kun se kutsutaan, ja palauttaa koko nimen merkkijonona. Objektin `person` tulos on siis ”John Doe”.

## TypeScript-luokan esimerkkejä

TypeScript-luokissa on erilaisia mekanismeja **objektien rakenteen ja käyttäytymisen** järjestämiseen ja hallintaan. Alla esittelemme joitakin TypeScript-luokkien käytön käsitteitä.

### Pääsy

TypeScript tarjoaa kolme pääsyn muokkaajaa: `public`, `private` ja `protected`, joilla hallitaan pääsyä luokkien sisäisiin ja ulkoisiin ominaisuuksiin ja menetelmiin.

- **public (vakio)**: `public` varustetut ominaisuudet ja menetelmät voidaan kutsua mistä tahansa, sekä luokan sisä- että ulkopuolelta.
- **yksityinen**: `private` viittaa ominaisuuksiin ja menetelmiin, joita voidaan kutsua vain luokan sisällä. Ne eivät ole käytettävissä ulkoisissa koodiosissa.
- **suojattu**: `protected` lla merkityt ominaisuudet ja menetelmät voidaan kutsua luokasta itsestään ja johdetuista luokista (perintö), mutta ei ulkoisesta koodista.

```typescript
class Person {
    private socialSecurityNumber: string;
    constructor(ssn: string) {
        this.socialSecurityNumber = ssn;
    }
    greet() {
        console.log("Hello, I am a person with SSN: " + this.socialSecurityNumber);
    }
}
const person = new Person("123-45-6789");
person.greet();
```

Tässä esimerkissä `socialSecurityNumber` on yksityinen ominaisuus, johon pääsee käsiksi vain `Person` sisällä. Voit kuitenkin kutsua `greet` luokan ulkopuolelta.

### Perintö

Perintö on objektisuuntautuneen ohjelmoinnin (OOP) peruskonsepti, jota käytetään TypeScriptissä ja monissa muissa internet-ohjelmointikielissä. Sen avulla voidaan luoda uusi luokka olemassa olevan **perusluokan tai superluokan** pohjalta. Johdettu luokka (alaluokka) perii perusluokan ominaisuudet ja menetelmät ja voi laajentaa tai mukauttaa niitä.

```typescript
class Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    makeSound() {
        console.log("Some generic sound");
    }
}
class Dog extends Animal {
    makeSound() {
        console.log(this.name + " barks");
    }
}
const myDog = new Dog("Buddy");
myDog.makeSound();
```

Avainsanan `extends` avulla alaluokka `Dog` perii ominaisuudet ja menetelmät yläluokasta `Animal`. Luokka `Dog` ohittaa menetelmän `makeSound` lisätäkseen tietyn käyttäytymisen ja perii samalla ominaisuuden `name` luokasta `Animal`.

### Vain luku

Voit käyttää `readonly` määrittelemään TypeScript-luokkien tai -objektien ominaisuudet **vain luku -ominaisuuksiksi**. Tämä tarkoittaa, että kun vain luku -ominaisuus on alustettu, sen arvoa ei voi enää muuttaa.

```typescript
class Circle {
    readonly pi: number = 3.14159;
    radius: number;
    constructor(radius: number) {
        this.radius = radius;
    }
    getArea() {
        return this.pi    *this.radius*    this.radius;
    }
}
const myCircle = new Circle(5);
console.log(myCircle.getArea()); // Output: ≈ 78,54
```

`pi` on esimerkissämme vain luku -tyyppinen ja se alustetaan konstruktorissa. Alustuksen jälkeen `pi` ei voi enää muuttaa. Jos yrität muuttaa `pi` arvoa alustuksen jälkeen, TypeScript tuottaa kompilaatiovirheen.


This is a markdown version of: [https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/typescript-luokat/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/typescript-luokat/) for AI/LLM consumption.