# Kuidas määratleda ja kasutada TypeScripti klasse

TypeScripti klassid pakuvad selget ja struktureeritud viisi andmete ja käitumise organiseerimiseks **objektis**. See lihtsustab teie koodis entiteetide ja kontseptsioonide modelleerimist.

## Mis on TypeScripti klassid?

Klassid on JavaScriptil põhineva programmeerimiskeele TypeScripti võtmekontseptsioon. Klassid esindavad **struktureeritud meetodit objektide defineerimiseks** ja objektorienteeritud programmeerimise (OOP) rakendamiseks. TypeScripti klassid on nagu objektide loomise joonised, mis koondavad loogiliselt seotud andmeid ja meetodeid.

[TypeScript](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/mis-on-typescript/) sisaldab kõiki JavaScripti funktsioone ja lisaks ka **staatilist tüüpimist**. See võimaldab määrata [TypeScripti funktsioonide](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/typescripti-funktsioonid/), muutujate ja klasside andmetüübid, et saaksite tuvastada kompileerimise ajal tekkivaid vigu. Lisaks tüübikindlusele toetavad TypeScripti klassid ka selliseid kontseptsioone nagu pärimine ja abstraktsioon, mis hõlbustavad keerukate rakenduste arendamist.

TypeScripti klassidega saate luua selge **klasside hierarhia**, mis pärivad omadusi ja meetodeid. See soodustab koodi taaskasutamist ja struktureerimist. Klasside konstruktorid võimaldavad instantside algseadistamist ja tagavad objekti loomise järjepidevuse.

## Mis on TypeScripti klasside süntaks?

TypeScripti klasside märkimine on sarnane **ECMAScript 6 (ES6)** märkimisega ja on JavaScripti klassisüntaksi laiendatud versioon. TypeScripti klass võib sisaldada erinevaid elemente, mis määravad objektide struktuuri ja käitumise. Peamised komponendid on:

- **Omadused**
- **Konstruktorid**
- **Meetodid**

### Omadused

Omadused määravad **objekti seisundi**. Need salvestavad andmeväärtusi ja neile võib lisada andmetüübid, et neil oleksid ainult kehtivad väärtused.

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

- **ClassName**: klassi nimi
- **propertyName**: määratletava omaduse nimi
- **propertyType**: omaduse andmetüüp

Siin on konkreetne näide:

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

Esiteks määratletakse klass `Person` omadusega `name` tüübist `string`. See tähendab, et klassi `Person` instantsidel on omadus `name`, mis salvestab **stringe**.

### Ehitusettevõtja

TypeScripti konstruktor on spetsiaalne meetod, mida kutsutakse välja klassi instantsi (objekti) loomisel. Seda on vaja **objekti omaduste algseadistamiseks**. Konstruktor määrab sisuliselt instantsi algseisundi. Konstruktoris saab määrata parameetrid, et edastada väärtusi TypeScripti klasside instantside loomisel.

TypeScripti konstruktori põhiline süntaks on:

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

- **konstruktor**: igal klassil võib olla üks konstruktor. Kui konstruktorit ei ole määratletud, luuakse vaikimisi tühi konstruktor.
- **parameeter: Tüüp**: parameetrid on valikulised, sõltuvalt klassist ja selle nõuetest. Parameetrid tuleks märgistada nende andmetüüpidega.

Konstruktori näide:

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

Eespool toodud näites on klassil `Person` konstruktor, mis võtab vastu kaks parameetrit `firstName` ja `lastName`. Selle klassi **instantsi loomisel** edastatakse need parameetrid ja konstruktor algseadistab instantsi omadused `firstName` ja `lastName` vastavate väärtustega. `this` viitab klassi praegusele instantsile, milles kood täidetakse.

### Meetodid

TypeScriptis on meetodid funktsioonid, mida saab klassides defineerida ja nende instantsidele rakendada. Meetodid võimaldavad teha **teatud toiminguid või operatsioone** klassi kontekstis.

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

- **methodName**: meetodi nimi
- **parameter: tüüp**: meetodi poolt aktsepteeritavad valikulised parameetrid
- **ReturnType**: see on andmetüüp, mis määrab meetodi poolt tagastatava väärtuse. Kui meetod ei tagasta midagi, võite määrata `void`.

Omaduse juurde pääsemiseks või klassi instantsi meetodi kutsumiseks kasuta punktioperaatorit `.`, millele järgneb meetodi nimi ja vajalikud argumendid, kui meetod eeldab parameetreid.

```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();
```

Meetodit `getFullName` kasutatakse isiku täisnime loomiseks ja tagastamiseks. See pääseb ligi klassis määratletud ja konstruktoris initsialiseeritud omaduste `firstName` ja `lastName` väärtustele. Objekt `person` luuakse märksõnaga `new`, millele järgneb klassi nimi ja vastavad parameetrid. Meetod **ühendab kaks stringi**, kui see kutsutakse, ja tagastab täisnime stringina. Objekti `person` väljund on seega „John Doe”.

## TypeScripti klasside näited

TypeScripti klassidel on mitmesugused mehhanismid **objektide struktuuri ja käitumise** organiseerimiseks ja kontrollimiseks. Allpool tutvustame mõningaid TypeScripti klasside kasutamise põhimõtteid.

### Juurdepääs

TypeScript pakub kolme juurdepääsu modifikaatorit: `public`, `private` ja `protected`, et kontrollida juurdepääsu klassi sisemistele ja välistele omadustele ja meetoditele.

- **avalik (standard)**: `public` märgitud omadused ja meetodid on kutsutavad kõikjal, nii klassi sees kui ka väljaspool seda.
- **privaatne**: `private` viitab omadustele ja meetoditele, mida saab kutsuda ainult klassi sees. Need on välistele koodiosadele kättesaamatud.
- **kaitstud**: `protected` märgitud omadusi ja meetodeid saab kutsuda klassi enda ja tuletatud klasside (pärimisel) poolt, kuid mitte välise koodi poolt.

```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();
```

Selles näites on `socialSecurityNumber` privaatne omadus, millele on juurdepääs ainult klassis `Person`. Siiski on võimalik kutsuda meetodit `greet` väljaspool klassi.

### Pärandus

Pärimine on objektorienteeritud programmeerimise (OOP) põhikontseptsioon, mida kasutatakse TypeScriptis ja paljudes teistes internetiprogrammeerimiskeeltes. See võimaldab luua uue klassi olemasoleva **baasklassi või superklassi** alusel. Tuletatud klass (alamklass) pärandab baasklassi omadused ja meetodid ning võib neid laiendada või kohandada.

```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();
```

Sõna `extends` abil pärandab alamklass `Dog` vanemklassi `Animal` omadused ja meetodid. Klass `Dog` asendab meetodi `makeSound`, et lisada konkreetne käitumine, pärandades samal ajal omaduse `name` klassist `Animal`.

### Ainult lugemiseks

Võite kasutada `readonly`, et deklareerida TypeScripti klasside või objektide omadused ainult **lugemiseks**. See tähendab, et kui ainult lugemiseks mõeldud omadus on algselt määratud, ei saa selle väärtust enam muuta.

```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
```

Meie näites on omadus `pi` ainult lugemiseks ja see algatatakse konstruktoris. Pärast algatamist ei saa `pi` enam muuta. Kui proovite pärast algatamist muuta väärtust `pi`, tekitab TypeScript kompileerimisvea.


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/typescripti-klassid/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/typescripti-klassid/) for AI/LLM consumption.