From 2c865821b7383b6668270be717dc7add425f3e02 Mon Sep 17 00:00:00 2001 From: Tunahan Erturk <89503561+tunisch@users.noreply.github.com> Date: Thu, 9 Oct 2025 13:31:45 +0300 Subject: [PATCH 1/7] Create operatorler.md --- operatorler.md | 145 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 145 insertions(+) create mode 100644 operatorler.md diff --git a/operatorler.md b/operatorler.md new file mode 100644 index 0000000..1b659f5 --- /dev/null +++ b/operatorler.md @@ -0,0 +1,145 @@ +# 1. Temel Operatörler + +Java dilinde operatörler birçok işlemi yapabilmenize olanak tanır. Örneğin: matematiksel operatörlerle birlikte aritmetik işlemler yapabilmenizi, ilişkisel operatörlerle verileri kıyaslayabilmeyi, atama operatörleri ile değişkenlerin değerlerini değiştirmeye fırsat verir. + +Java'da operatörler aşağıdaki gibi listelenebilir: + +- Atama Operatörleri +- Aritmetiksel Operatörler +- İlişkisel ve Eşitlik Operatörler +- Koşul Operatörler +- Mantıksal Operatörler + +## Atama Operatörü +image + +## Aritmetik Operatörler +Java'da Aritmetik Operatörler adından da anlaşılacağı üzere matematiksel işlemleri programlama dilinde uygulamamızı sağlarlar. + +- Toplama : a + b +- Çıkarma : a – b +- Çarpma : a * b +- Bölme : a / b +- Mod alma : a % b +- 1 arttırma : a++ +- 1 eksiltme : b-- + +## Karşılaştırma Operatörleri +Java'da Karşılaştırma Operatörleri iki nesnenin birbirleriyle olan durumlarını belirler. + +- Eşitlik : a == b +- Eşit Değil : a != b +- Büyüktür : a > b +- Küçüktür : a < b +- Büyük Eşittir : a >= b +- Küçük Eşittir : a <= b +## Mantıksal Operatörler +Java'da Mantıksal Operatörler , nesnelerin veya ifadelerin mantıksal değerlerini yansıtır. + +- Ve : a && b +- Veya : a || b +- Değil : !(a&&b) +## Koşul Operatörü +Java'da Koşul Operatörleri ifadelerin sonucunda oluşacak olayları belirler. + +- a = 5 ; +- b = (a == 1) ? 1 : 0 +- Çıktısı : 0 + +## Ternary Operator +Ternary Operator (üçlü operatör), Java’da if-else yapısının kısa hali olarak kullanılan bir operatördür. +Kısaca, bir koşulu (condition) test eder ve bu koşulun true veya false olmasına göre iki farklı değer döndürür. + +### 🧠 Genel Sözdizimi (Syntax) +``` +variable = (condition) ? value_if_true : value_if_false; +``` +- condition → test etmek istediğin ifade (örneğin: a > b) +- value_if_true → koşul doğruysa dönecek değer +- value_if_false → koşul yanlışsa dönecek değer + +### 🔍 Basit Bir Örnek +``` +int a = 10; +int b = 20; + +int max = (a > b) ? a : b; +System.out.println("En büyük sayı: " + max); +``` +#### 🧩 Açıklama: +- (a > b) koşulu false, çünkü 10 > 20 değil. +- Bu yüzden b seçilir → max = 20. +##### ✅ Çıktı: +``` +En büyük sayı: 20 +``` +### 💡 if-else ile aynı örnek +Yukarıdaki örneği normal if-else ile yazarsak: +``` +int max; +if (a > b) { + max = a; +} else { + max = b; +} +``` +Ternary operatörü bunu tek satıra indirir. +Yani kodun okunabilirliğini artırır, ama karmaşık koşullarda dikkatli kullanılmalıdır. +#### ⚙️ Başka bir örnek (String ile) +``` +int yas = 18; +String sonuc = (yas >= 18) ? "Reşit" : "Reşit değil"; +System.out.println(sonuc); +``` + +##### ✅ Çıktı: +``` +Reşit +``` +#### 🔁 İç içe (nested) ternary örneği +``` +int sayi = 0; +String sonuc = (sayi > 0) ? "Pozitif" : (sayi < 0) ? "Negatif" : "Sıfır"; +System.out.println(sonuc); +``` + +##### ✅ Çıktı: +``` +Sıfır +``` +Ancak iç içe ternary ifadeleri okunması zorlaşabilir, bu yüzden sadece basit durumlarda tercih edilir. + +### 🔒 Özet +| Özellik | Açıklama | +| -------------- | ------------------------------------------- | +| Operatör | `?:` | +| Kullanım Amacı | Kısa if-else yapısı | +| Avantajı | Kodun sade ve kısa olması | +| Dezavantajı | Karmaşık koşullarda okunabilirliğin düşmesi | + +# 🧮 2. İleri Seviye Operatörler (Advanced Operators) +## 🧱 Bit Düzeyinde Operatörler (Bitwise) +| Operatör | Anlamı | Örnek | Açıklama | | | +| -------- | ---------------------- | ---------- | ------------------------------------ | -- | ------------------------- | +| `&` | Bitwise AND | `a & b` | Bit düzeyinde VE işlemi | | | +| ` | ` | Bitwise OR | `a | b` | Bit düzeyinde VEYA işlemi | +| `^` | XOR | `a ^ b` | Farklı bitlerde 1 üretir | | | +| `~` | NOT | `~a` | Bitleri ters çevirir | | | +| `<<` | Sol kaydırma | `a << 2` | Bitleri sola kaydırır | | | +| `>>` | Sağ kaydırma | `a >> 2` | Bitleri sağa kaydırır | | | +| `>>>` | İşaretsiz sağ kaydırma | `a >>> 2` | Negatif sayılarda işaretsiz kaydırma | | | + + +## 🧱 instanceof Operatörü +Bir nesnenin (object) belirli bir sınıftan (class) olup olmadığını kontrol eder. +``` +String ad = "Tunahan"; +boolean kontrol = ad instanceof String; // true +``` + +# 📚 Referanslar + +1. [Oracle Docs - Conditional Operator (?:)](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html) +2. [GeeksforGeeks - Ternary Operator in Java](https://www.geeksforgeeks.org/ternary-operator-in-java/) +3. [W3Schools - Java Ternary Operator](https://www.w3schools.com/java/java_ternary.asp) +4. [Programiz - Java Ternary Operator](https://www.programiz.com/java-programming/ternary-operator) From e45edbe918932bac4b78a3d4716731ecd4eee580 Mon Sep 17 00:00:00 2001 From: Tunahan Erturk <89503561+tunisch@users.noreply.github.com> Date: Thu, 9 Oct 2025 13:40:21 +0300 Subject: [PATCH 2/7] Update operatorler.md --- operatorler.md | 122 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 121 insertions(+), 1 deletion(-) diff --git a/operatorler.md b/operatorler.md index 1b659f5..ab0b092 100644 --- a/operatorler.md +++ b/operatorler.md @@ -46,7 +46,7 @@ Java'da Koşul Operatörleri ifadelerin sonucunda oluşacak olayları belirler. - b = (a == 1) ? 1 : 0 - Çıktısı : 0 -## Ternary Operator +## Conditional (Ternary) Operator Ternary Operator (üçlü operatör), Java’da if-else yapısının kısa hali olarak kullanılan bir operatördür. Kısaca, bir koşulu (condition) test eder ve bu koşulun true veya false olmasına göre iki farklı değer döndürür. @@ -136,6 +136,126 @@ Bir nesnenin (object) belirli bir sınıftan (class) olup olmadığını kontrol String ad = "Tunahan"; boolean kontrol = ad instanceof String; // true ``` +## Type Casting (Tür Dönüştürme Operatörü) + +Amaç: +Bir veri tipini başka bir veri tipine dönüştürmek için kullanılır. +Java’da primitive türlerde ( ) parantez kullanılır. +Objelerde ise upcasting / downcasting şeklinde yapılır. + +### Sözdizimi: +``` +(targetType) value; +``` +#### Örnek: +``` +int num = 10; +double converted = (double) num; // int → double + +System.out.println(converted); // 10.0 +``` +### Object Casting (Downcasting): +``` +Animal a = new Dog(); // upcasting +Dog d = (Dog) a; // downcasting +d.bark(); +``` +## Object / Member Access Operator (.) +Amaç: +Bir sınıfın (class) özelliklerine (fields) veya metotlarına (methods) erişmek için kullanılır. + +### Sözdizimi: +``` +objectName.memberName +``` +#### Örnek: +``` +public class Person { + String name = "Ahmet"; + void greet() { + System.out.println("Merhaba " + name); + } +} + +public class Main { + public static void main(String[] args) { + Person p = new Person(); + System.out.println(p.name); // field erişimi + p.greet(); // metot çağrısı + } +} +``` +## Lambda Expression Operator (->) + +Amaç: +Java 8 ile gelen functional programming yapısını destekler. +Lambda ifadesi, anonim (ismi olmayan) fonksiyonlar tanımlamak için kullanılır. +-> operatörü, parametreleri ve fonksiyon gövdesini birbirinden ayırır. + +### Sözdizimi: +``` +(parameters) -> expression +(parameters) -> { statements } +``` + +#### Örnek: +``` +// Tek satırlık lambda +Runnable r = () -> System.out.println("Çalıştı!"); +r.run(); + +// Parametreli lambda +Function kareAl = x -> x * x; +System.out.println(kareAl.apply(5)); // 25 +``` +## Method Reference Operator (::) + +Amaç: +Lambda ifadelerinin kısa yazımıdır. +Var olan bir metodu referans olarak aktarır. + +### Sözdizimi: +``` +ClassName::methodName +``` + +#### Örnek: +``` +List isimler = Arrays.asList("Ali", "Veli", "Ayşe"); + +// Lambda ile +isimler.forEach(isim -> System.out.println(isim)); + +// Method reference ile +isimler.forEach(System.out::println); +``` +## Annotation Operator (@) + +Amaç: +Kod hakkında ek bilgi (metadata) sağlar. +Derleyiciye veya çalışma zamanına özel bilgi verir. +Örnekler: @Override, @Deprecated, @SuppressWarnings + +### Sözdizimi: +``` +@AnnotationName +``` + +#### Örnek: +``` +class Parent { + void speak() { + System.out.println("Parent konuşuyor"); + } +} + +class Child extends Parent { + @Override + void speak() { + System.out.println("Child konuşuyor"); + } +} +``` # 📚 Referanslar From 535b2892659b893723ec599050f7f1281874b336 Mon Sep 17 00:00:00 2001 From: Tunahan Erturk <89503561+tunisch@users.noreply.github.com> Date: Sat, 11 Oct 2025 18:38:08 +0300 Subject: [PATCH 3/7] Update operatorler.md --- operatorler.md | 139 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 138 insertions(+), 1 deletion(-) diff --git a/operatorler.md b/operatorler.md index ab0b092..ccd283c 100644 --- a/operatorler.md +++ b/operatorler.md @@ -9,10 +9,19 @@ Java'da operatörler aşağıdaki gibi listelenebilir: - İlişkisel ve Eşitlik Operatörler - Koşul Operatörler - Mantıksal Operatörler - +🧮 Java Operatörlerinin Sözdizimleri (Formülleri) ## Atama Operatörü image +| Operatör | Sözdizimi (Formül) | Açıklama | +| -------- | -------------------- | ------------------------------ | +| `=` | `değişken = değer;` | Sağdaki değeri sola atar | +| `+=` | `değişken += değer;` | `değişken = değişken + değer;` | +| `-=` | `değişken -= değer;` | `değişken = değişken - değer;` | +| `*=` | `değişken *= değer;` | `değişken = değişken * değer;` | +| `/=` | `değişken /= değer;` | `değişken = değişken / değer;` | +| `%=` | `değişken %= değer;` | `değişken = değişken % değer;` | + ## Aritmetik Operatörler Java'da Aritmetik Operatörler adından da anlaşılacağı üzere matematiksel işlemleri programlama dilinde uygulamamızı sağlarlar. @@ -23,6 +32,114 @@ Java'da Aritmetik Operatörler adından da anlaşılacağı üzere matematiksel - Mod alma : a % b - 1 arttırma : a++ - 1 eksiltme : b-- +### 🔢 İleri Düzey Aritmetik Operatör Örnekleri (Java) +#### 1️⃣ Modül ve Birleşik İşlem Örneği +``` +public class AdvancedMath1 { + public static void main(String[] args) { + int x = 17; + int y = 5; + int result = (x % y) + (x / y) * 2; // 2 + 6 = 8 + System.out.println("Sonuç: " + result); + } +} +``` +### 2️⃣ Üs Alma (Math.pow) ve Karekök Hesabı +``` +public class AdvancedMath2 { + public static void main(String[] args) { + double a = 4; + double b = 3; + double result = Math.pow(a, b) + Math.sqrt(a * b); + System.out.println("Sonuç: " + result); + } +} +``` +Açıklama: +- Math.pow(4, 3) = 4³ = 64 +- Math.sqrt(4*3) = √12 ≈ 3.464 + ➡️ Sonuç: 67.464 +### 3️⃣ Artırma ve Azaltma Operatörlerinin Etkileşimi +``` +public class AdvancedMath3 { + public static void main(String[] args) { + int a = 5; + int b = ++a * 2 + a--; // (6*2)+6 = 18 + System.out.println("a: " + a + ", b: " + b); + } +} +``` +#### Açıklama: + +- ++a → önce artır, sonra kullan → a = 6 +- a-- → önce kullan, sonra azalt +- Hesap sırası: (6 * 2) + 6 = 18 +- Son durumda a = 5, b = 18 +### 4️⃣ Karışık Parantezli İşlem Örneği +``` +public class AdvancedMath4 { + public static void main(String[] args) { + int x = 10; + int y = 4; + int z = 2; + int result = (x + y) * z % (y + z) - x / z; + System.out.println("Sonuç: " + result); + } +} +``` +#### Açıklama: +- (x + y) * z → (10 + 4) * 2 = 28 +- (y + z) → 6 +- 28 % 6 → 4 +- x / z → 10 / 2 = 5 +- 4 - 5 = -1 + ➡️ Sonuç: -1 +### 5️⃣ Kombine Atama Operatörleri (+=, -=, *=, /=, %=) +``` +public class AdvancedMath5 { + public static void main(String[] args) { + int num = 10; + num += 5; // 15 + num *= 2; // 30 + num %= 7; // 2 (30 mod 7) + System.out.println("Sonuç: " + num); + } +} +``` +Açıklama: +Sırasıyla işlemler uygulanır: + +num += 5 → 15 + +num *= 2 → 30 + +num %= 7 → 2 +➡️ Sonuç: 2 +### 6️⃣ Negatif ve Pozitif Operatörlerin Karışımı +``` +public class AdvancedMath6 { + public static void main(String[] args) { + int a = -5; + int b = 3; + int result = -a + ++b * (-a % b); + System.out.println("Sonuç: " + result); + } +} +``` +Açıklama: + +-a → 5 + +++b → 4 + +(-a % b) → 5 % 4 = 1 + +5 + 4 * 1 = 9 +➡️ Sonuç: 9 + + + + ## Karşılaştırma Operatörleri Java'da Karşılaştırma Operatörleri iki nesnenin birbirleriyle olan durumlarını belirler. @@ -35,6 +152,12 @@ Java'da Karşılaştırma Operatörleri iki nesnenin birbirleriyle olan durumlar - Küçük Eşittir : a <= b ## Mantıksal Operatörler Java'da Mantıksal Operatörler , nesnelerin veya ifadelerin mantıksal değerlerini yansıtır. +| Operatör | Sözdizimi (Formül) | Açıklama | | | | | +| -------- | -------------------- | ------------------------------ | -------- | - | -------- | -------------------- | +| `&&` | `(kosul1 && kosul2)` | VE (her iki koşul da true ise) | | | | | +| ` | | ` | `(kosul1 | | kosul2)` | VEYA (biri true ise) | +| `!` | `!(kosul)` | DEĞİL (sonucu tersine çevirir) | | | | | + - Ve : a && b - Veya : a || b @@ -163,6 +286,10 @@ d.bark(); ## Object / Member Access Operator (.) Amaç: Bir sınıfın (class) özelliklerine (fields) veya metotlarına (methods) erişmek için kullanılır. +| Operatör | Sözdizimi (Formül) | Açıklama | +| -------- | ------------------ | ----------------------- | +| `.` | `nesne.üyeAdi` | Alan veya metot erişimi | + ### Sözdizimi: ``` @@ -192,6 +319,12 @@ Java 8 ile gelen functional programming yapısını destekler. Lambda ifadesi, anonim (ismi olmayan) fonksiyonlar tanımlamak için kullanılır. -> operatörü, parametreleri ve fonksiyon gövdesini birbirinden ayırır. +| Operatör | Sözdizimi (Formül) | Açıklama | +| -------- | -------------------------------- | ------------------- | +| `->` | `(parametreler) -> ifade` | Tek satırlık lambda | +| `->` | `(parametreler) -> { kodBloğu }` | Çok satırlı lambda | + + ### Sözdizimi: ``` (parameters) -> expression @@ -214,6 +347,10 @@ Amaç: Lambda ifadelerinin kısa yazımıdır. Var olan bir metodu referans olarak aktarır. +| Operatör | Sözdizimi (Formül) | Açıklama | +| -------- | -------------------- | --------------- | +| `::` | `SınıfAdi::metotAdi` | Lambda kısayolu | + ### Sözdizimi: ``` ClassName::methodName From 8b486b71be2124d349764e34326e54e02a79a7da Mon Sep 17 00:00:00 2001 From: Tunahan Erturk <89503561+tunisch@users.noreply.github.com> Date: Sat, 11 Oct 2025 18:40:04 +0300 Subject: [PATCH 4/7] Update operatorler.md --- operatorler.md | 31 ++++++++++++------------------- 1 file changed, 12 insertions(+), 19 deletions(-) diff --git a/operatorler.md b/operatorler.md index ccd283c..4e89c5f 100644 --- a/operatorler.md +++ b/operatorler.md @@ -55,7 +55,7 @@ public class AdvancedMath2 { } } ``` -Açıklama: +#### Açıklama: - Math.pow(4, 3) = 4³ = 64 - Math.sqrt(4*3) = √12 ≈ 3.464 ➡️ Sonuç: 67.464 @@ -106,15 +106,12 @@ public class AdvancedMath5 { } } ``` -Açıklama: +#### Açıklama: Sırasıyla işlemler uygulanır: - -num += 5 → 15 - -num *= 2 → 30 - -num %= 7 → 2 -➡️ Sonuç: 2 +- num += 5 → 15 +- num *= 2 → 30 +- num %= 7 → 2 + ➡️ Sonuç: 2 ### 6️⃣ Negatif ve Pozitif Operatörlerin Karışımı ``` public class AdvancedMath6 { @@ -126,16 +123,12 @@ public class AdvancedMath6 { } } ``` -Açıklama: - --a → 5 - -++b → 4 - -(-a % b) → 5 % 4 = 1 - -5 + 4 * 1 = 9 -➡️ Sonuç: 9 +#### Açıklama: +- -a → 5 +- ++b → 4 +- (-a % b) → 5 % 4 = 1 +- 5 + 4 * 1 = 9 + ➡️ Sonuç: 9 From 53bbb0cf8fc21c111ec5c2c7d46dbd14a77edc44 Mon Sep 17 00:00:00 2001 From: Tunahan Erturk <89503561+tunisch@users.noreply.github.com> Date: Wed, 15 Oct 2025 18:11:23 +0300 Subject: [PATCH 5/7] Update operatorler.md --- operatorler.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/operatorler.md b/operatorler.md index 4e89c5f..8cb10c3 100644 --- a/operatorler.md +++ b/operatorler.md @@ -143,6 +143,7 @@ Java'da Karşılaştırma Operatörleri iki nesnenin birbirleriyle olan durumlar - Küçüktür : a < b - Büyük Eşittir : a >= b - Küçük Eşittir : a <= b + ## Mantıksal Operatörler Java'da Mantıksal Operatörler , nesnelerin veya ifadelerin mantıksal değerlerini yansıtır. | Operatör | Sözdizimi (Formül) | Açıklama | | | | | @@ -167,7 +168,7 @@ Ternary Operator (üçlü operatör), Java’da if-else yapısının kısa hali Kısaca, bir koşulu (condition) test eder ve bu koşulun true veya false olmasına göre iki farklı değer döndürür. ### 🧠 Genel Sözdizimi (Syntax) -``` +```java variable = (condition) ? value_if_true : value_if_false; ``` - condition → test etmek istediğin ifade (örneğin: a > b) @@ -191,7 +192,7 @@ En büyük sayı: 20 ``` ### 💡 if-else ile aynı örnek Yukarıdaki örneği normal if-else ile yazarsak: -``` +```java int max; if (a > b) { max = a; From ee12a53f56d3ec1f8c4794a181b1d21dc88c382c Mon Sep 17 00:00:00 2001 From: Tunahan Erturk <89503561+tunisch@users.noreply.github.com> Date: Thu, 16 Oct 2025 16:49:20 +0300 Subject: [PATCH 6/7] Expand logical operators section in operatorler.md Added explanations and examples for logical operators in Java, including AND, OR, NOT, and the ternary operator. --- operatorler.md | 66 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/operatorler.md b/operatorler.md index 8cb10c3..a4110d0 100644 --- a/operatorler.md +++ b/operatorler.md @@ -163,6 +163,72 @@ Java'da Koşul Operatörleri ifadelerin sonucunda oluşacak olayları belirler. - b = (a == 1) ? 1 : 0 - Çıktısı : 0 +## Mantıksal Operatörler + +Java'da Mantıksal Operatörler, değişkenler veya değerler arasındaki mantığı belirlemek için kullanılır. Türkçe'de ki bağlaç ekleri gibi düşünebilirsiniz. + +Bir kontrol işlemi sonucunda geriye true yada false değeri döndüren operatörlerdir. True / False döndüren ifadeler veya boolean tipinde değerler tutan değişkenler üzerinde kullanılabilirler. Konuyu anlayabilmek için ilk önce mantıksal operatörlerin neler olduğu öğrenilmelidir. + +## Java'da Mantıksal Operatörler +### && VE (AND) + +Her iki ifade de doğruysa True döndürür. +``` +Örnek +x'i 5 olarak ele alırsak; +x<10 && x<25 +``` +Burada sonuç True olacaktır. + +### || Veya (OR) + +İfadelerden biri doğruysa True döndürür. +``` +Örnek +x'i 5 olarak ele alırsak; +x<10 || x<3 +``` +Burada sonuç True olacaktır. + +### ! Ters İşlem + +Sonucu tersine çevirir. +``` +Örnek +x'i 5 olarak ele alalım. +x<10 ifadesi True dönecektir. Ancak !(x<5) olarak yazarsak sonuç False olacaktır. + +### Soru İşareti Operatörü +? işareti operatörü ile Java'da mantıksal kıyaslama yapılabilir. ? ifadesi Java'daki "if-else" yapısı yerine kullanılabilir. Tek satırda bunu yapabilmemizi sağlar. Kullanımı ise if'in içerisinde yer alacak ifadeyi soru işaretinden önce yazılır, ifadenin doğru olması durumunda yapılacak işlemler soru işareti ile iki nokta arasına yazılır. İfadenin yanlış olması durumunda yapılacaklar ise iki noktadan sonra yazılır. +Kullanımı : +``` +( kontrol edilecek ifade ) ? doğru olması durumunda yapılacaklar : yanlış olması durumunda yapılacaklar +``` +#### Örnek : +```java +public class Test { + + public static void main(String args[]) { + int a, b; + a = 10; + b = (a == 1) ? 20: 30; + System.out.println( "Value of b is : " + b ); + + b = (a == 10) ? 20: 30; + System.out.println( "Value of b is : " + b ); + } +} +``` + +#### Sonuç : + +- Value of b is : 30 +- Value of b is : 20 +#### Açıklama : + +- b = (a == 1) ? 20: 30; => ifadesini incelenirse, (a == 1) ? 20: 30 ifadesinden başlamak daha doğru olacaktır. a'nın 1 olması durumunda 20 değeri, a'nın 1'den farklı olması durumunda 30 değeri dönecektir. b'nin değeri buradan dönen değere göre belirlenecektir. Kodda a değeri 10 olarak verildiği için b'nin değeri 30 olarak atanmaktadır. +- b = (a == 10) ? 20: 30; => ifadesi incelenirse, yine yukarıdaki açıklamaya benzer olarak a değerinin 10 olması durumunda 20, a değeri 10'dan farklı olması durumunda ise 30 değeri geriye dönecektir. Bu durumda a değeri kodda 10 olduğu için b değeri de 20 olarak atanacaktır. + ## Conditional (Ternary) Operator Ternary Operator (üçlü operatör), Java’da if-else yapısının kısa hali olarak kullanılan bir operatördür. Kısaca, bir koşulu (condition) test eder ve bu koşulun true veya false olmasına göre iki farklı değer döndürür. From 4be1467947fe252e1ae26b283d77633b18c81019 Mon Sep 17 00:00:00 2001 From: Tunahan Erturk <89503561+tunisch@users.noreply.github.com> Date: Thu, 16 Oct 2025 16:57:26 +0300 Subject: [PATCH 7/7] Fix formatting and improve code examples in operatorler.md Correct formatting issues and ensure consistent code examples. --- operatorler.md | 55 +++++++++++++++++++++++++------------------------- 1 file changed, 27 insertions(+), 28 deletions(-) diff --git a/operatorler.md b/operatorler.md index a4110d0..09d0d37 100644 --- a/operatorler.md +++ b/operatorler.md @@ -34,7 +34,7 @@ Java'da Aritmetik Operatörler adından da anlaşılacağı üzere matematiksel - 1 eksiltme : b-- ### 🔢 İleri Düzey Aritmetik Operatör Örnekleri (Java) #### 1️⃣ Modül ve Birleşik İşlem Örneği -``` +```java public class AdvancedMath1 { public static void main(String[] args) { int x = 17; @@ -45,7 +45,7 @@ public class AdvancedMath1 { } ``` ### 2️⃣ Üs Alma (Math.pow) ve Karekök Hesabı -``` +```java public class AdvancedMath2 { public static void main(String[] args) { double a = 4; @@ -60,7 +60,7 @@ public class AdvancedMath2 { - Math.sqrt(4*3) = √12 ≈ 3.464 ➡️ Sonuç: 67.464 ### 3️⃣ Artırma ve Azaltma Operatörlerinin Etkileşimi -``` +```java public class AdvancedMath3 { public static void main(String[] args) { int a = 5; @@ -76,7 +76,7 @@ public class AdvancedMath3 { - Hesap sırası: (6 * 2) + 6 = 18 - Son durumda a = 5, b = 18 ### 4️⃣ Karışık Parantezli İşlem Örneği -``` +```java public class AdvancedMath4 { public static void main(String[] args) { int x = 10; @@ -95,7 +95,7 @@ public class AdvancedMath4 { - 4 - 5 = -1 ➡️ Sonuç: -1 ### 5️⃣ Kombine Atama Operatörleri (+=, -=, *=, /=, %=) -``` +```java public class AdvancedMath5 { public static void main(String[] args) { int num = 10; @@ -113,7 +113,7 @@ Sırasıyla işlemler uygulanır: - num %= 7 → 2 ➡️ Sonuç: 2 ### 6️⃣ Negatif ve Pozitif Operatörlerin Karışımı -``` +```java public class AdvancedMath6 { public static void main(String[] args) { int a = -5; @@ -130,10 +130,6 @@ public class AdvancedMath6 { - 5 + 4 * 1 = 9 ➡️ Sonuç: 9 - - - - ## Karşılaştırma Operatörleri Java'da Karşılaştırma Operatörleri iki nesnenin birbirleriyle olan durumlarını belirler. @@ -197,14 +193,17 @@ Sonucu tersine çevirir. Örnek x'i 5 olarak ele alalım. x<10 ifadesi True dönecektir. Ancak !(x<5) olarak yazarsak sonuç False olacaktır. - +``` ### Soru İşareti Operatörü ? işareti operatörü ile Java'da mantıksal kıyaslama yapılabilir. ? ifadesi Java'daki "if-else" yapısı yerine kullanılabilir. Tek satırda bunu yapabilmemizi sağlar. Kullanımı ise if'in içerisinde yer alacak ifadeyi soru işaretinden önce yazılır, ifadenin doğru olması durumunda yapılacak işlemler soru işareti ile iki nokta arasına yazılır. İfadenin yanlış olması durumunda yapılacaklar ise iki noktadan sonra yazılır. -Kullanımı : + ``` +Kullanımı : ( kontrol edilecek ifade ) ? doğru olması durumunda yapılacaklar : yanlış olması durumunda yapılacaklar ``` -#### Örnek : + +Örnek : + ```java public class Test { @@ -242,7 +241,7 @@ variable = (condition) ? value_if_true : value_if_false; - value_if_false → koşul yanlışsa dönecek değer ### 🔍 Basit Bir Örnek -``` +```java int a = 10; int b = 20; @@ -269,7 +268,7 @@ if (a > b) { Ternary operatörü bunu tek satıra indirir. Yani kodun okunabilirliğini artırır, ama karmaşık koşullarda dikkatli kullanılmalıdır. #### ⚙️ Başka bir örnek (String ile) -``` +```java int yas = 18; String sonuc = (yas >= 18) ? "Reşit" : "Reşit değil"; System.out.println(sonuc); @@ -280,7 +279,7 @@ System.out.println(sonuc); Reşit ``` #### 🔁 İç içe (nested) ternary örneği -``` +```java int sayi = 0; String sonuc = (sayi > 0) ? "Pozitif" : (sayi < 0) ? "Negatif" : "Sıfır"; System.out.println(sonuc); @@ -315,7 +314,7 @@ Ancak iç içe ternary ifadeleri okunması zorlaşabilir, bu yüzden sadece basi ## 🧱 instanceof Operatörü Bir nesnenin (object) belirli bir sınıftan (class) olup olmadığını kontrol eder. -``` +```java String ad = "Tunahan"; boolean kontrol = ad instanceof String; // true ``` @@ -327,18 +326,18 @@ Java’da primitive türlerde ( ) parantez kullanılır. Objelerde ise upcasting / downcasting şeklinde yapılır. ### Sözdizimi: -``` +```java (targetType) value; ``` #### Örnek: -``` +```java int num = 10; double converted = (double) num; // int → double System.out.println(converted); // 10.0 ``` ### Object Casting (Downcasting): -``` +```java Animal a = new Dog(); // upcasting Dog d = (Dog) a; // downcasting d.bark(); @@ -352,11 +351,11 @@ Bir sınıfın (class) özelliklerine (fields) veya metotlarına (methods) eriş ### Sözdizimi: -``` +```java objectName.memberName ``` #### Örnek: -``` +```java public class Person { String name = "Ahmet"; void greet() { @@ -386,13 +385,13 @@ Lambda ifadesi, anonim (ismi olmayan) fonksiyonlar tanımlamak için kullanılı ### Sözdizimi: -``` +```java (parameters) -> expression (parameters) -> { statements } ``` #### Örnek: -``` +```java // Tek satırlık lambda Runnable r = () -> System.out.println("Çalıştı!"); r.run(); @@ -412,12 +411,12 @@ Var olan bir metodu referans olarak aktarır. | `::` | `SınıfAdi::metotAdi` | Lambda kısayolu | ### Sözdizimi: -``` +```java ClassName::methodName ``` #### Örnek: -``` +```java List isimler = Arrays.asList("Ali", "Veli", "Ayşe"); // Lambda ile @@ -434,12 +433,12 @@ Derleyiciye veya çalışma zamanına özel bilgi verir. Örnekler: @Override, @Deprecated, @SuppressWarnings ### Sözdizimi: -``` +```java @AnnotationName ``` #### Örnek: -``` +```java class Parent { void speak() { System.out.println("Parent konuşuyor");