☕ Java Senior

Developer

Kapsamlı Çalışma Rehberi

Design Patterns · Concurrency · Spring Framework · JVM Internals · Generics ·

Reflection · HQL

Yazılım Mühendisleri İçin — Derinlemesine & Nedenleriyle

İÇİNDEKİLER

1 Design Patterns
Creational, Structural, Behavioral

2 Java Concurrency & Threads

Thread safety, Locks, Executor framework
3 Spring Framework
IoC, DI, Annotations, AOP

4 JVM Internals & Garbage Collection

Memory model, GC algorithms, TLAB

5 Java Generics
Type parameters, Wildcards, Bounds

6 Java Reflection
Runtime introspection, Method invocation

7 Hibernate & HQL

ORM, Entity mapping, Query language

8 Cryptography in Java
AES, RSA, DSA — ne zaman ne kullanılır

9 Spring Boot Microservices

Load balancing, Gateway, Service discovery
 1 · Design Patterns
Design Pattern'ler, yazılım tasarımında tekrarlayan problemlere yönelik kanıtlanmış çözüm
şablonlarıdır. GoF (Gang of Four) kitabında 23 temel pattern üç kategoride toplanmıştır:
Creational, Structural, Behavioral.

1.1 Singleton Pattern — "Tek Nesne"

Problem: Bir sınıftan uygulama genelinde yalnızca tek bir instance olmasını garantilemek.
Örneğin: veritabanı bağlantısı, configuration manager, logger.

Zorunlu 3 kural:

• private static instance alanı — dışarıdan doğrudan erişim engellenir

• private constructor — new ile dışarıdan nesne oluşturmak engellenir
• public static getInstance() — tek kontrollü giriş noktası

// Thread-safe Singleton (Lazy Initialization)

public class Singleton {
private static volatile Singleton instance; // volatile: visibility garantisi
private Singleton() {} // private constructor

public static synchronized Singleton getInstance() {

if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

// En iyi alternatif: Enum Singleton (thread-safe, serileştirme güvenli)

public enum DatabaseConnection {
INSTANCE;
public void connect() { /* ... */ }
}

⚠ synchronized olmadan: iki thread aynı anda null kontrolü yapabilir ve iki farklı nesne oluşturur →
Singleton bozulur.
✓ Enum Singleton en güvenli yöntemdir. Reflection saldırısına ve serileştirmeye karşı korumalıdır.

1.2 Builder Pattern — "Adım Adım İnşa"

Problem: Çok sayıda parametreli nesneler oluştururken constructor hell'den kaçınmak.
Parametre sırasını karıştırmak imkânsız hale gelir.
public class HttpRequest {
private final String url;
private final String method;
private final int timeout;
private final Map<String, String> headers;

private HttpRequest(Builder builder) { // private constructor

[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
}

public static class Builder {

private String url;
private String method = "GET"; // default value
private int timeout = 30;
private Map<String, String> headers = new HashMap<>();

public Builder url(String url) { [Link] = url; return this; }

public Builder method(String method) { [Link] = method; return this; }
public Builder timeout(int t) { [Link] = t; return this; }
public Builder header(String k, String v){ [Link](k,v); return this; }
public HttpRequest build() { return new HttpRequest(this); }
}
}

// Kullanım — fluent API

HttpRequest req = new [Link]()
.url("[Link]
.method("POST")
.timeout(60)
.header("Authorization", "Bearer token")
.build();

1.3 Factory Method Pattern — "Nesne Üretimi Soyutlama"

Problem: Hangi sınıfın instantiate edileceğini çağıran koddan gizlemek. Open/Closed prensibini
sağlar — yeni tipler eklerken mevcut kod değişmez.
public interface Animal {
void speak();
}
public class Dog implements Animal { public void speak() { [Link]("Woof"); } }
public class Cat implements Animal { public void speak() { [Link]("Meow"); } }

// Factory
public class AnimalFactory {
public static Animal create(String type) {
return switch ([Link]()) {
case "dog" -> new Dog();
case "cat" -> new Cat();
default -> throw new IllegalArgumentException("Unknown: " + type);
};
}
}
// Kullanım
Animal a = [Link]("dog");
[Link](); // Woof

1.4 Observer Pattern — "Olay Yayıncısı"

Problem: Bir nesnedeki değişikliği birden fazla bağımlı nesneye bildirmek. Event-driven
mimarilerin temelini oluşturur (Spring Events, GUI toolkit'ler, Reactive streams).

public interface Observer {

void update(String event, Object data);
}

public class EventBus {

private final Map<String, List<Observer>> listeners = new HashMap<>();

public void subscribe(String event, Observer observer) {

[Link](event, k -> new ArrayList<>()).add(observer);
}

public void publish(String event, Object data) {

[Link](event, [Link]())
.forEach(obs -> [Link](event, data));
}
}
 2 · Java Concurrency & Threads
Java'nın multithreading modeli JVM üzerine kuruludur. Her thread, OS-level bir thread'e map edilir.
Java Memory Model (JMM) hangi koşulda bir thread'in başka thread'in yazdıklarını göreceğini
tanımlar.

2.1 Thread Safety Problemleri

Race Condition: İki thread aynı kaynağa eş zamanlı erişirken verinin tutarsız kalması.

// UNSAFE: counter++ atomik değildir!

// JVM bunu 3 adıma böler: READ → MODIFY → WRITE
public class Counter {
private int count = 0;
public void increment() { count++; } // thread-safe DEĞİL
}

// SAFE: AtomicInteger
public class SafeCounter {
private final AtomicInteger count = new AtomicInteger(0);
public void increment() { [Link](); } // CAS (Compare-And-Swap)
}

2.2 synchronized ve Locks

Thread-
Yöntem Kapsam Ne zaman kullan
Safe

synchronized(this) Instance ✓ Basit senaryolar

synchronized(lock) Özel nesne ✓ Daha ince kontrol

synchronized method Tüm metod ✓ Tüm metod kritik

ReentrantLock Manuel ✓ tryLock, timeout, fairness

ReadWriteLock Okuma/Yazma ✓ Okuma yoğun

StampedLock Optimistik ✓ Java 8+, yüksek perf

// ReentrantLock — en güvenli explicit lock kullanımı
public class DatabaseWriter {
private final ReentrantLock lock = new ReentrantLock();

public void writeToDatabase(String data) {

[Link](); // Kilidi al — başka thread buraya giremez
try {
// Kritik bölge: sadece 1 thread aynı anda çalışır
performWrite(data);
} finally {
[Link](); // MUTLAKA finally'de — exception olsa bile serbest bırak
}
}

// tryLock: kilidi alamazsa beklemek yerine false döner

public boolean tryWrite(String data) {
if ([Link]()) {
try {
performWrite(data);
return true;
} finally {
[Link]();
}
}
return false; // Kilit başka thread'deydi, yazma atlandı
}
}

⚠ [Link]() çağrısını finally bloğuna koymak zorunludur. Aksi hâlde exception sonrası deadlock
oluşur.

2.3 Executor Framework & ScheduledThreadPoolExecutor

Thread'leri doğrudan oluşturmak (new Thread()) production kodunda anti-pattern'dir. Executor
Framework thread havuzu yönetimini soyutlar.

Factory Metod Tür Ne zaman

[Link](n) Sabit havuz CPU-bound görevler

[Link]() Esnek havuz I/O-bound, kısa görevler

[Link]() Tek thread Sıralı işlem garantisi

[Link](n) Zamanlanmış Periyodik/gecikmeli görevler

// scheduleAtFixedRate vs scheduleWithFixedDelay — FARK ÖNEMLİ
ScheduledExecutorService executor = [Link](3);

// scheduleAtFixedRate: görev her 100s'de BİR BAŞLAR (period sabit)

// Görev 120s sürerse: 0s → 120s → 200s → 300s (çakışma yaşanabilir)
[Link](
new EmailTask(), // Runnable
30, // initialDelay: ilk çalışmadan önceki bekleme
100, // period: iki başlangıç arasındaki süre
[Link]
);

// scheduleWithFixedDelay: bir görev BİTTİKTEN SONRA delay kadar bekler

// Görev 120s sürerse: 0s → 120s → (120+100=)220s → ...
[Link](
new EmailTask(),
30, // initialDelay
100, // delay: bitiş ile sonraki başlangıç arası
[Link]
);

// Executor'ı kapatmak
[Link](); // Kuyruktaki görevleri bitir, yeni kabul etme
[Link](); // Hemen durdur (interrupt gönder)

✓ İş yükü sorusu: "30 sn sonra başla, her 100 sn tekrar et" → scheduleAtFixedRate. "Görev bittikten 100
sn sonra tekrar et" → scheduleWithFixedDelay.

2.4 volatile ve Java Memory Model

// volatile: değişkenin her zaman main memory'den okunup yazılmasını garantiler

// Visibility problem'ini çözer ama atomikliği SAĞLAMAZ
public class Flag {
private volatile boolean running = true;

public void stop() {

running = false; // Tüm thread'ler bu değişikliği görür
}

public void run() {

while (running) { // volatile olmasa thread kendi cache'ini okur
doWork();
}
}
}

2.5 TLAB — Thread Local Allocation Buffers

JVM'in eden space'i thread'ler arasında paylaşımlıdır. Her nesne oluşturmada global lock almak
performansı ciddi şekilde düşürür. TLAB, her thread'e eden space'in küçük bir bölümünü ayırır;
thread bu alanda lock almadan nesne oluşturur.

Durum Açıklama

TLAB dolmadan Thread kendi TLAB'ından lock'suz allocate eder (çok hızlı)
TLAB dolunca Yeni TLAB talep eder → minor GC tetiklenebilir

Büyük nesneler Doğrudan old gen'e (TLAB bypass) ya da humongous region'a

 3 · Spring Framework
Spring'in çekirdeği IoC (Inversion of Control) ve DI (Dependency Injection)'dır. Nesneler
kendi bağımlılıklarını oluşturmaz; Spring Container oluşturup enjekte eder. Bu yaklaşım loose
coupling, testability ve configurability sağlar.

3.1 Dependency Injection Türleri

Tür Annotation Avantaj / Dezavantaj

Constructor Injection @Autowired (opsiyonel)Best practice. final alan destekler, immutable, test edilebilir

Setter Injection @Autowired Opsiyonel bağımlılıklar için uygun

Field Injection @Autowired Kısa ama test edilemez, final desteklemez — KAÇIN

@Service
public class UserService {
// Constructor injection — EN İYİ PRATIK
private final String hostUrl; // final: immutability
private final UserRepository repo;

// @Value: [Link]'ten değer enjekte et

// @Autowired: Spring bean'ini enjekte et
public UserService(@Value("${[Link]}") String hostUrl,
@Autowired UserRepository repo) {
[Link] = hostUrl;
[Link] = repo;
}
}

// [Link]
// [Link]=[Link]

// [Link] alternatifi
// api:
// url: [Link]

⚠ @Value ile String enjeksiyonunda @Autowired gereksizdir — @Value yeterlidir. Setter injection ile
final alan kullanılamaz.

3.2 Spring Bean Scopes

Scope Tanım Kullanım

singleton (default) ApplicationContext'te tek instance

Stateless servisler

prototype Her istekte yeni instance Stateful nesneler

request HTTP request başına Web uygulamaları

session HTTP session başına Kullanıcı oturumu

application ServletContext başına Uygulama geneli

3.3 Temel Spring Annotation'ları

// Stereotype annotations — Spring'e bean olduğunu söyler

@Component // Genel amaçlı bean
@Service // İş mantığı katmanı (semantik fark yok, okunabilirlik için)
@Repository // Veri erişim katmanı + exception translation
@Controller // MVC web katmanı
@RestController // @Controller + @ResponseBody

// Configuration
@Configuration // Java-based bean tanımı
@Bean // @Configuration içinde metod — return değeri bean olur
@ComponentScan("[Link]") // Belirtilen paketi tara

// Injection & Properties

@Autowired // Bağımlılık enjeksiyonu
@Value("${[Link]}") // Property enjeksiyonu
@Qualifier("beanName") // Aynı tipte birden fazla bean varsa hangisi?

// Lifecycle
@PostConstruct // Bean oluşturulup inject edildikten sonra çalışır
@PreDestroy // Context kapanmadan önce çalışır
 4 · JVM Internals & Garbage Collection

4.1 JVM Memory Yapısı

GC'ye tabi
Alan İçerik
mi?

Heap – Young Gen (Eden + S0/S1) Yeni nesneler Evet – Minor GC

Heap – Old Gen (Tenured) Uzun ömürlü nesneler Evet – Major GC

Metaspace (Java 8+) Class metadata Evet (varsayılan limitsiz)

Stack Her thread'in call stack'i, local değişkenler

Hayır

Program Counter Çalıştırılan bytecode adresi Hayır

Native Method Stack JNI metod çağrıları Hayır

4.2 GC Algoritmaları

Stop-the-Wo
Collector Kullanım Durumu
rld

Serial GC Evet – uzun Küçük uygulamalar, tek çekirdek

Parallel GC (default <Java9)

Evet – paralel Throughput odaklı batch işlemler

CMS (deprecated) Kısmen Düşük latency (eski uygulamalar)

G1 GC (default Java9+)Kısmen Büyük heap, dengeli throughput/latency

ZGC (Java 15+) Çok kısa (<1ms) Ultra-low latency, büyük heap

Shenandoah Çok kısa OpenJDK, concurrent compaction

4.3 Stop-the-World ve TLAB

Stop-the-World (STW): GC çalışırken tüm uygulama thread'leri durdurulur. Bu latency spike'lara
neden olur. TLAB (Thread Local Allocation Buffer), her thread'e eden space'in küçük bir bölümünü
özel olarak tahsis ederek global lock ihtiyacını ortadan kaldırır ve minor GC sıklığını azaltır.
✓ Kısa ömürlü çok sayıda nesne oluşturan multithreaded uygulamalarda TLAB boyutunu artırmak
(-XX:TLABSize) GC baskısını azaltır.
 5 · Java Generics
Generics, compile-time type safety sağlar. Runtime'da type erasure ile silinir — JVM bytecode
seviyesinde generics yoktur, Object'e dönüştürülür.

5.1 Type Parameter Kuralları

Notasyon Anlamı

<T> Herhangi bir tip (convention: T=Type, E=Element, K=Key, V=Value)

<T extends Number> T, Number'dan türemiş olmak zorunda (upper bound)

<T super Integer> T, Integer'in üst sınıfı olmak zorunda (lower bound)

<?> Wildcard: bilinmeyen tip (read-only)

<? extends Number> Bounded wildcard: Number alt sınıfları (producer)

<? super Integer> Bounded wildcard: Integer üst sınıfları (consumer)

// Generic class örneği — Pair<T, S>

public class Pair<T, S> {
private T first;
private S second;

public Pair(T first, S second) {

[Link] = first;
[Link] = second;
}
public T getFirst() { return first; }
public S getSecond() { return second; }
}

// Numerik toplama için bound gerekli

// T ve S'nin Number olduğunu garantilemeden .doubleValue() çağrılamaz
public static <T extends Number, S extends Number>
double sum(Pair<T, S> pair) {
return [Link]().doubleValue() + [Link]().doubleValue();
}

// Kullanım
Pair<Integer, Double> p = new Pair<>(5, 3.14);
double result = sum(p); // 8.14

5.2 PECS Prensibi

PECS: Producer Extends, Consumer Super. Bir collection'dan okuyacaksanız (producer)
extends, yazacaksanız (consumer) super kullanın.
// Extends: listeden okuma (Number ve alt sınıflar)
public double sumList(List<? extends Number> list) {
return [Link]().mapToDouble(Number::doubleValue).sum();
}

// Super: listeye yazma (Integer ve üstleri)

public void addIntegers(List<? super Integer> list) {
[Link](1);
[Link](2);
}
 6 · Java Reflection
Reflection, runtime'da sınıf yapısını (field, method, constructor, annotation) incelemeye ve
manipüle etmeye olanak tanır. Spring, Hibernate gibi framework'lerin temeli Reflection'dır.

6.1 getMethod vs getDeclaredMethod

setAccessible gerekli
Metod Kapsam
mi?

getMethod("name") Sadece public metodlar (miras dahil)

Genellikle hayır

getDeclaredMethod("name")
Tüm erişim seviyeleri (bu sınıf) private için evet

getMethods() Tüm public metodlar (dizi) Hayır

getDeclaredMethods() Bu sınıftaki tüm metodlar private için evet

// Reflection ile method invocation

public class Person {
private String firstName;
private String lastName;

public Person(String firstName, String lastName) {

[Link] = firstName;
[Link] = lastName;
}
public void displayFullName() {
[Link]("Full Name: " + firstName + " " + lastName);
}
}

// ✓ Doğru kullanım (public method)

Person bob = new Person("Bob", "Smith");
Method method = [Link]("displayFullName"); // public, setAccessible gerekmez
[Link](true); // iyi pratik olarak yine de eklenebilir
[Link](bob); // "Full Name: Bob Smith"

// Private field'a erişim

Field field = [Link]("firstName");
[Link](true); // private'ı aç
String value = (String) [Link](bob); // "Bob"
[Link](bob, "Robert"); // değer değiştir

⚠ Reflection performans açısından pahalıdır. Production'da hot path'lerde kullanmaktan kaçının.

Framework kodunda (başlangıç zamanı) uygundur.
 7 · Hibernate & HQL
Hibernate bir ORM (Object-Relational Mapping) framework'üdür. Java nesnelerini veritabanı
tablolarına eşler. HQL (Hibernate Query Language), SQL'e benzer ama veritabanı tablolarına
değil Java entity sınıflarına yöneliktir.

7.1 Entity Mapping Annotationları

@Entity // Bu sınıf bir DB tablosunu temsil eder

@Table(name = "books") // DB'deki tablo adı (opsiyonel, varsayılan = class adı)
public class Book {
@Id // Primary key
@GeneratedValue(strategy = [Link]) // Auto increment
@Column(name = "id") // DB kolon adı (opsiyonel)
private int id;

@Column(name = "title", nullable = false, length = 200)

private String title;

@Column(name = "price")
private double price;

// Getters & Setters...

}

7.2 SQL vs HQL — Kritik Fark

Özellik SQL HQL

Referans eder Veritabanı tabloları Java entity sınıfları

Tablo adı books (DB adı) Book (Java class adı)

Alan adı price (kolon adı) [Link] (Java field adı)

SELECT all SELECT * SELECT b (entity döner)

Alias Opsiyonel Genellikle kullanılır

DB bağımsızlık Hayır Evet (Hibernate dialect)

-- SQL (veritabanına özgü)
SELECT id, title, author, price FROM books WHERE price > 10;

-- HQL (Java sınıflarına yönelik)

SELECT b FROM Book b WHERE [Link] > 10

-- Book = Java class adı (DB tablo adı "books" DEĞİL)

-- b = alias
-- [Link] = Java field adı (DB kolon adı "price" değil — burada aynı ama farklı olabilir)

// Hibernate Session ile çalıştırma

Session session = [Link]();
List<Book> books = [Link](
"SELECT b FROM Book b WHERE [Link] > :minPrice", [Link])
.setParameter("minPrice", 10.0)
.getResultList();
 8 · Java'da Kriptografi
Güvenli
Algorit
Tür Anahtar Kullanım Kanal
ma
Gereki

AES Simetrik Tek anahtar Veri şifreleme (hız) Evet

RSA Asimetrik Public + Private Anahtar değişimi, imza Hayır

DSA Asimetrik Public + Private Sadece dijital imza Hayır

SHA-256 Hash Yok Bütünlük doğrulama N/A

8.1 RSA — Public Key Infrastructure

RSA asimetrik şifrelemedir. İki anahtar çifti vardır: Public Key (herkese paylaşılır) ve Private Key
(asla paylaşılmaz). Gönderen public key ile şifreler, alıcı private key ile çözer.

// RSA ile şifreleme/deşifreleme

import [Link].*;
import [Link];

// Anahtar çifti oluştur

KeyPairGenerator keyGen = [Link]("RSA");
[Link](2048); // 2048 bit — güvenli minimum
KeyPair pair = [Link]();

PublicKey publicKey = [Link](); // Paylaşılabilir

PrivateKey privateKey = [Link](); // GİZLİ KALACAK

// Şifreleme — public key ile

Cipher cipher = [Link]("RSA");
[Link](Cipher.ENCRYPT_MODE, publicKey);
byte[] encrypted = [Link]("Gizli mesaj".getBytes());

// Deşifreleme — SADECE private key ile

[Link](Cipher.DECRYPT_MODE, privateKey);
byte[] decrypted = [Link](encrypted);
[Link](new String(decrypted)); // "Gizli mesaj"

// AES — simetrik (aynı anahtar şifreler ve çözer)

// Güvenli anahtar paylaşımı için önce RSA kullanılır,
// sonra AES anahtarı RSA ile şifrelenip iletilir (hybrid encryption)

⚠ DSA dijital imza içindir, şifreleme yapamaz. AES için anahtar paylaşımı sorunu vardır — güvenli kanal
gerektirir.
 9 · Spring Boot Microservices & Load
Balancing
Microservices mimarisinde her servis bağımsız deploy edilir. Yük dengeleme ve servis keşfi için
Spring Cloud ekosistemi kullanılır.

9.1 Load Balancing Stratejileri

Bileşen Katman Açıklama

Netflix Ribbon Client-side İstemci hangi instance'a gideceğine kendisi karar verir

Spring Cloud Gateway API Gateway Gelen istekleri route eder, cross-cutting concerns

Eureka Service Registry Servisler kendini kaydeder, diğerleri IP'yi buradan öğrenir

Kubernetes (k8s) Infrastructure Pod scaling, rolling update, service discovery

Nginx / HAProxy Network LB L4/L7 load balancing, upstream round-robin

9.2 Spring Cloud Gateway Konfigürasyonu

# [Link] — Spring Cloud Gateway route tanımı

spring:
cloud:
gateway:
routes:
- id: user-service
uri: lb://USER-SERVICE # lb:// → Ribbon/LoadBalancer kullan
predicates:
- Path=/api/users/**
filters:
- StripPrefix=1
- name: CircuitBreaker
args:
name: userServiceCB
fallbackUri: forward:/fallback/users

# Eureka client
eureka:
client:
serviceUrl:
defaultZone: [Link]
// @LoadBalanced ile RestTemplate — client-side load balancing
@Configuration
public class AppConfig {
@Bean
@LoadBalanced // Eureka'dan servis adını IP'ye çevirir + load balance
public RestTemplate restTemplate() {
return new RestTemplate();
}
}

@Service
public class UserClient {
@Autowired
private RestTemplate restTemplate;

public User getUser(String userId) {

// "USER-SERVICE" → Eureka'dan IP listesi alınır, Ribbon seçer
return [Link](
"[Link] + userId,
[Link]
);
}
}

9.3 Microservices Deseni: Circuit Breaker

Bir servis devre dışıysa tüm sistem çökmemeli. Circuit Breaker (Resilience4j/Hystrix), bağlantı
denemelerini belirli bir eşiğin üzerinde başarısız olunca keser ve fallback yanıt döner.

@Service
public class PaymentService {

@CircuitBreaker(name = "paymentCB", fallbackMethod = "paymentFallback")

@Retry(name = "paymentRetry")
public PaymentResult processPayment(Order order) {
return [Link](order);
}

// Circuit açıksa bu metod çağrılır

public PaymentResult paymentFallback(Order order, Exception ex) {
return [Link]("Ödeme servisi geçici olarak kullanılamıyor.");
}
}
 Hızlı Referans — Exam Cheat Sheet
Konu Anahtar Nokta Yaygın Tuzak

Singleton private constructor + private static instance + synchronized

synchronized
getInstance()
yoksa thread-unsafe

Builder inner static Builder class, fluent API, final alanlar Constructor overloading ile karıştırma

Factory Nesne üretimini soyutla, OCP sağla new ile doğrudan oluşturma — coupling artar

Observer Publisher/Subscriber, event-driven Memory leak: unsubscribe unutmak

synchronized lock al, kritik bölge, lock bırak finally'de unlock yazmamak → deadlock

ReentrantLock lock() + try/finally + unlock() tryLock: sıralı işlem garantisi VERMEZ

scheduleAtFixedRate Başlangıç zamanları sabit aralıklı scheduleWithFixedDelay ile karıştırma

volatile Visibility garantisi, atomiklik YOK count++ için volatile yetmez, Atomic gerek

TLAB Thread başına eden bölgesi, lock-free alloc Büyük nesneler doğrudan old gen'e gider

@Value Properties'ten inject, constructor ile final Setter ile final alan kullanılamaz

@Autowired Bean inject, field injection kötü pratik @Value ile String inject edilemez

HQL Java class adı kullanılır, entity döner Tablo adı yazmak (SQL ile karıştırma)

getMethod() Sadece public metodlar getDeclaredMethod: tüm erişim + setAccessible g

RSA Asimetrik, public key paylaş, private gizli DSA imza içindir, şifreleme yapamaz

Generics T extends Number

.doubleValue() çağırmak için gerekli Raw type kullanımı compile hatasına neden olur

Bu rehber Java Senior Developer Assessment'larında çıkan gerçek sorular baz alınarak hazırlanmıştır.
Her konsept "neden" sorusuyla birlikte açıklanmıştır. İyi çalışmalar!