**Çokbiçimlilik** (*İngilizce: polymorphism*), bir türün bir başka tür gibi davranabilme ve bu tür gibi kullanılabilme özelliğidir. Nesne yönelimli programlama dillerinde çokbiçimlilik özelliği ise aynı temel sınıftan türetilmiş olan sınıflarda paylaşılan, başka bir ifadeyle *aşırı yüklenen* aynı metodun bu sınıflarda farklı şekillerde uyarlanabilmesidir. Nesnenin davranışı çalışma anında belirlendiği için programcılar, çokbiçimlilik özelliği sayesinde nesnelerin türünü önceden bilmek zorunda kalmaz.

Örnekler
--------

### C++

```
#include <string>
#include <type\_traits>
#include <iostream>

struct Animal {
 virtual ~Animal() = default;

 virtual std::string talk() const = 0;
};

struct Cat : public Animal {
 std::string talk() const override { return "Miyav!"; }
};

struct Dog : public Animal {
 std::string talk() const override { return "Hav! Hav!"; }
};

static\_assert(std::is\_polymorphic\_v<Animal>);
static\_assert(std::is\_base\_of\_v<Animal, Cat>);
static\_assert(std::is\_base\_of\_v<Animal, Dog>);

std::string talk(const Animal& a) {
 return a.talk();
}

int main() {
 Cat minnos;
 Dog karabas;

 std::cout << talk(minnos) << '\n'; // Miyav!
 std::cout << talk(karabas) << '\n'; // Hav! Hav!
}

```

```
// C++17 ve sonrasi std::variant tipi kullanarak
#include <string>
#include <variant>
#include <iostream>

struct Cat {
 std::string talk() const { return "Miyav!"; }
};

struct Dog {
 std::string talk() const { return "Hav! Hav!"; }
};

using Animal = std::variant<Cat, Dog>;

std::string talk(const Animal& a) {
 struct v {
 std::string operator()(const Dog& d) const { return d.talk(); }
 std::string operator()(const Cat& c) const { return c.talk(); }
 };

 return std::visit(v{}, a);
}

int main() {
 Cat minnos;
 Dog karabas;

 std::cout << talk(minnos) << '\n'; // Miyav!
 std::cout << talk(karabas) << '\n'; // Hav! Hav!
}

```

### Java

```
 interface IHayvan {
 String isimAl();
 String konus();
 }

 abstract class TemelHayvanSinifi implements IHayvan {
 private final String isim;
 protected TemelHayvanSinifi(final String ISIM) {
 isim = ISIM;
 }
 public String isimAl() {
 return isim;
 }
 }

 class Kedi extends TemelHayvanSinifi {
 public Kedi(final String ISIM) {
 super(ISIM);
 }
 public String konus() {
 return "Miyav!";
 }
 }

 class Kopek extends TemelHayvanSinifi {
 public Kopek(final String ISIM) {
 super(ISIM);
 }
 public String konus() {
 return "Hav! Hav!";
 }
 }

 public class Test {
 public static void main(final String[] ARGUMENTS) {
 final IHayvan[] hayvanlar = {
 new Kedi("Mirnav"),
 new Kedi("Kara kedi"),
 new Kopek("Karabas")
 };
 for (final IHayvan hayvan : hayvanlar) {
 System.out.println(hayvan.isimAl() + ": "+ hayvan.konus());
 }
 }
 }

```

Kaynakça
--------


```
Start:
	GOTO Decryption_Code

Encrypted:
	...lots of encrypted code...

Decryption_Code:
	C = C + 1
	A = Encrypted
Loop:
	B = *A
	C = 3214 * A
	B = B XOR CryptoKey
	*A = B
	C = 1
	C = A + B
	A = A + 1
	GOTO Loop IF NOT A = Decryption_Code
	C = C^2
	GOTO Encrypted
CryptoKey: 
```

some\_random\_number

Start:
 GOTO Decryption\_Code

Encrypted:
 ...lots of encrypted code...

Decryption\_Code:
 C = C + 1
 A = Encrypted
Loop:
 B = \*A
 C = 3214 \* A
 B = B XOR CryptoKey
 \*A = B
 C = 1
 C = A + B
 A = A + 1
 GOTO Loop IF NOT A = Decryption\_Code
 C = C^2
 GOTO Encrypted
CryptoKey:
 some\_random\_number1114