Kihagyás

JavaScript OOP (Objektumorientált Programozás)

Objektumok létrehozása

Az objektumorientált programozás alapja az objektumok használata, amelyek tulajdonságokkal és metódusokkal (függvényekkel) rendelkeznek.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
// Egyszerű objektum létrehozása
const person = {
  name: "John",
  age: 30,
  greet: function() {
    console.log("Hello, my name is " + this.name);
  }
};

person.greet(); // Hello, my name is John

Osztályok (Classes)

Az osztályok az OOP alapvető részei, és segítségükkel objektumokat hozhatunk létre, amelyek közös struktúrát használnak.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Animal {
  constructor(name, sound) {
    this.name = name;
    this.sound = sound;
  }

  makeSound() {
    console.log(`${this.name} says ${this.sound}`);
  }
}

// Példa egy Animal objektum létrehozására
const dog = new Animal("Dog", "Woof");
dog.makeSound(); // Dog says Woof

Öröklődés (Inheritance)

Az öröklődéssel az osztályok tulajdonságokat és metódusokat örökölhetnek más osztályoktól.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Dog extends Animal {
  constructor(name, breed) {
    super(name, "Woof");
    this.breed = breed;
  }

  showBreed() {
    console.log(`This dog is a ${this.breed}`);
  }
}

const myDog = new Dog("Buddy", "Golden Retriever");
myDog.makeSound(); // Buddy says Woof
myDog.showBreed(); // This dog is a Golden Retriever

Encapsulation (Inkább Zártság)

Az encapsulation arra utal, hogy az adatok védettek és csak meghatározott metódusokkal érhetők el. Ezt privát mezők segítségével érhetjük el.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
class BankAccount {
  #balance = 0; // Privát mező

  deposit(amount) {
    this.#balance += amount;
  }

  getBalance() {
    return this.#balance;
  }
}

const account = new BankAccount();
account.deposit(100);
console.log(account.getBalance()); // 100
console.log(account.#balance); // Hibát dob

Polimorfizmus (Polymorphism)

A polimorfizmus lehetővé teszi, hogy azonos metódusokat különböző módon valósítsunk meg az örökölt osztályokban.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class Bird extends Animal {
  constructor(name) {
    super(name, "Tweet");
  }

  makeSound() {
    console.log(`${this.name} is chirping!`);
  }
}

const bird = new Bird("Sparrow");
bird.makeSound(); // Sparrow is chirping!

Statikus metódusok és tulajdonságok

A statikus metódusok és tulajdonságok osztályszintűek, és nem az objektumokhoz kötődnek.

1
2
3
4
5
6
7
class MathUtils {
  static add(a, b) {
    return a + b;
  }
}

console.log(MathUtils.add(5, 10)); // 15

Összegzés

  • Objektumok: Egyedi adatok és függvények összegyűjtése.
  • Osztályok: Objektumok sablonjai.
  • Öröklődés: Egy osztály örökölhet egy másiktól.
  • Encapsulation: Az adatok védelme privát mezők segítségével.
  • Polimorfizmus: Azonos metódus különböző implementációi különböző osztályokban.
  • Statikus metódusok: Osztályszintű függvények.