🎓موضوع: Bounded Generics در جاوا — محدودسازی نوع پارامترها با `extends` و `super`

در ادامه‌ی مبحث Generics، حالا به یکی از ویژگی‌های مهم آن می‌رسیم:
✅ مبحث Bounded Type Parameters
این ویژگی به ما اجازه می‌دهد نوع پارامتر Generic را محدود کنیم تا فقط از نوع خاصی (یا زیرکلاس آن) استفاده شود.


🔹 Upper Bound (`extends`)

وقتی از extends استفاده می‌کنیم، یعنی نوع پارامتر باید از یک کلاس خاص ارث‌بری کند یا یک اینترفیس خاص را پیاده‌سازی کرده باشد.

مثلاً:

class Box<T extends Number> {
    private T value;
    public void set(T value) { this.value = value; }
    public T get() { return value; }
}

✅ حالا فقط کلاس‌هایی مثل Integer, Double, Float و سایر زیرکلاس‌های Number مجاز هستند:

Box<Integer> intBox = new Box<>();
Box<Double> doubleBox = new Box<>();
// Box<String> stringBox ❌ خطا: String زیرکلاس Number نیست

🔹 Lower Bound (`super`)

وقتی از super در Wildcard استفاده می‌کنیم، یعنی نوع پارامتر باید ابرکلاس (Superclass) نوع مشخص‌شده باشد.
این روش معمولاً هنگام نوشتن داده‌ها در Collection به‌کار می‌رود.

مثلاً:

List<? super Integer> list = new ArrayList<Number>();
list.add(10);   // مجاز ✅
list.add(20);   // مجاز ✅

اما هنگام خواندن از لیست، نوع بازگشتی فقط به صورت Object شناخته می‌شود.


🔹 نکته کاربردی: PECS اصل معروف در Generics

PECS = Producer Extends, Consumer Super

* اگر فقط از مجموعه می‌خوانی (Producer) ➤ از extends استفاده کن
* اگر فقط در مجموعه می‌نویسی (Consumer) ➤ از super استفاده کن


✅ جمع‌بندی

درواقع Bounded Generics به ما کمک می‌کند:

1. از نوع‌های نامعتبر جلوگیری کنیم 🧩
2. انعطاف‌پذیری و ایمنی نوع‌ها را افزایش دهیم 🔒
3. کد قابل‌خواندن‌تر و قابل‌اعتمادتر بنویسیم 💡

#کاربرـپیشرفته

🆔 @javapro_ir
🆔 @group_javapro

🎓 متدهای Generic و Type Inference در جاوا — قدرت واقعی Generics در عمل

در پیام های قبل با مفاهیم پایه و Bounded Generics آشنا شدیم. حالا نوبت می‌رسه به بخش بسیار کاربردی این مبحث:
✅ Generic Methods و ✅ Type Inference (تشخیص خودکار نوع داده)


🔹 متد Generic چیست؟

در جاوا، می‌توان خودِ متد را Generic تعریف کرد؛ یعنی متد نوع داده‌ی ورودی و خروجی را در زمان فراخوانی مشخص می‌کند، نه هنگام تعریف کلاس.

ساختار کلی:

public <T> void printItem(T item) {
    System.out.println(item);
}

🔍 در اینجا <T> قبل از نوع بازگشتی (`void`) آمده، و نشان می‌دهد متد از نوع عمومی (Generic) است.

مثلاً:

printItem("Hello Java!");   // نوع T → String
printItem(42);              // نوع T → Integer

🔹 متد Generic با نوع بازگشتی

می‌توانیم نوع بازگشتی را نیز به‌صورت Generic تعیین کنیم:

public static <T> T getFirst(List<T> list) {
    return list.get(0);
}

هنگام فراخوانی، نوع T به‌صورت خودکار از روی نوع آرگومان تشخیص داده می‌شود (Type Inference):

List<String> names = List.of("Ali", "Reza");
String first = getFirst(names);   // نوع T → String

🔹 Type Inference (تشخیص خودکار نوع)

جاوا معمولاً می‌تواند نوع پارامتر Generic را خودش تشخیص دهد، اما در مواقعی می‌توان آن را به‌صورت صریح هم مشخص کرد:

Integer num = GenericUtils.<Integer>getFirst(List.of(1, 2, 3));

در اینجا ما نوع T را به‌صورت دستی Integer تعیین کردیم.


🔹 نکته کاربردی

متدهای Generic معمولاً در کلاس‌های Utility و کتابخانه‌های عمومی (مثل Collections و Streams) استفاده می‌شوند تا کدها قابل‌استفاده مجدد و ایمن از نظر نوع داده باشند.
برای مثال متد Collections.<T>emptyList() نمونه‌ای از همین مفهوم است.


✅ جمع‌بندی

* متدهای Generic اجازه می‌دهند نوع داده در زمان فراخوانی تعیین شود 🧩
* و Type Inference باعث سادگی و خوانایی کد می‌شود 👀
* این مفاهیم پایه‌ای‌ترین اصول در طراحی APIهای مدرن جاوا هستند 💡

#کاربرـپیشرفته

🆔 @javapro_ir
🆔 @group_javapro

🎓 تفاوت بین Stack و Heap در حافظه جاوا

در زبان جاوا، حافظه‌ی برنامه به دو بخش اصلی تقسیم می‌شود: Stack Memory و Heap Memory. درک تفاوت این دو بخش برای نوشتن برنامه‌های بهینه، جلوگیری از خطاهای حافظه و فهم رفتار اشیاء در زمان اجرا بسیار مهم است.


🧠 ۱. Stack Memory چیست؟

حافظه‌ی Stack مخصوص ذخیره‌ی متغیرهای محلی (Local Variables)**، **ارجاع‌های متدها و فریم‌های فراخوانی (Call Frames) است.
هر بار که یک متد در جاوا فراخوانی می‌شود، یک Stack Frame جدید برای آن ایجاد می‌شود که شامل پارامترهای ورودی و متغیرهای محلی همان متد است.

هنگامی که متد تمام می‌شود، Stack Frame مربوطه به‌صورت خودکار حذف می‌شود. این کار باعث می‌شود مدیریت حافظه در Stack بسیار سریع و کارآمد باشد.

📌 ویژگی‌ها:

* حافظه‌ی کوچک‌تر و سریع‌تر از Heap
* مدیریت خودکار (بدون نیاز به Garbage Collector)
* فقط داده‌های موقتی در آن نگهداری می‌شوند

📍 مثال:

public class StackExample {
    public static void main(String[] args) {
        int x = 10;         // در Stack ذخیره می‌شود
        int y = 20;         // در Stack ذخیره می‌شود
        int sum = add(x, y);
        System.out.println(sum);
    }

    static int add(int a, int b) {
        int result = a + b; // در Stack ذخیره می‌شود
        return result;
    }
}

در این مثال، هنگام فراخوانی متد add()`، یک Stack Frame جدید ایجاد می‌شود و متغیرهای `a, b, و result در آن ذخیره می‌شوند.
وقتی متد تمام می‌شود، تمام داده‌های داخل آن Frame از بین می‌روند.


💾 ۲. Heap Memory چیست؟

حافظه‌ی Heap برای نگهداری اشیاء (Objects) و مقادیر ساخته‌شده با new استفاده می‌شود.
هر چیزی که با کلیدواژه‌ی new ساخته شود، در Heap قرار می‌گیرد و ارجاع آن در Stack نگهداری می‌شود.

حافظه‌ی Heap توسط Garbage Collector مدیریت می‌شود. این به آن معناست که وقتی دیگر هیچ ارجاعی به یک شیء وجود نداشته باشد، جاوا آن را به‌صورت خودکار آزاد می‌کند.

📌 ویژگی‌ها:

* حافظه‌ی بزرگ‌تر ولی کندتر از Stack
* داده‌ها تا زمانی که به آن‌ها ارجاع وجود دارد، باقی می‌مانند
* مدیریت توسط Garbage Collector

📍 مثال:

public class HeapExample {
    public static void main(String[] args) {
        Person p1 = new Person("Saleh"); // شیء در Heap
        Person p2 = new Person("Ali");   // شیء دیگر در Heap
        p1.sayHello();
    }
}

class Person {
    String name;
    Person(String name) {
        this.name = name; // فیلد name در Heap ذخیره می‌شود
    }

    void sayHello() {
        System.out.println("Hello, " + name);
    }
}

در این مثال، اشیاء Person در حافظه‌ی Heap ذخیره می‌شوند، در حالی که ارجاع‌های p1 و p2 در Stack قرار دارند.
وقتی متد main() به پایان می‌رسد، ارجاع‌ها از بین می‌روند و در نتیجه اشیاء مربوطه در Heap توسط Garbage Collector حذف می‌شوند.


⚙️ نتیجه‌گیری:

*در واقع Stack برای داده‌های موقتی، متغیرهای محلی و فراخوانی متدهاست.
*و Heap برای اشیاء و داده‌هایی است که در زمان اجرا با new ایجاد می‌شوند.
* سرعت Stack بالاتر است، اما ظرفیت آن کمتر است.
* مدیریت Stack خودکار است، ولی Heap توسط Garbage Collector کنترل می‌شود.


✨ نکته پایانی:
درک تفاوت Stack و Heap به شما کمک می‌کند خطاهایی مانند OutOfMemoryError یا StackOverflowError را بهتر درک و رفع کنید، و طراحی بهینه‌تری برای کلاس‌ها و متدها داشته باشید.

#کاربر_مبتدی

🆔 @javapro_ir
🆔 @group_javapro

🎓 تفاوت بین Primitive Types و Reference Types در جاوا

در زبان جاوا، تمام متغیرها به دو دسته‌ی اصلی تقسیم می‌شوند:
Primitive Types (انواع پایه‌ای) و Reference Types (انواع ارجاعی).
درک تفاوت این دو نوع داده، برای جلوگیری از خطاهای مفهومی و نوشتن کدهای قابل اعتماد ضروری است.


🧩 ۱. Primitive Types — داده‌های پایه‌ای و ساده

در جاوا، Primitive Types مستقیماً مقدار خود را در حافظه ذخیره می‌کنند و به هیچ شیء یا ارجاعی وابسته نیستند.
این نوع داده‌ها به‌صورت ثابت و سریع عمل می‌کنند، چون در Stack Memory نگهداری می‌شوند.

📌 هشت نوع Primitive Type در جاوا وجود دارد:
byte, short, int, long, float, double, char, boolean

📍 مثال:

int a = 10;
int b = a;
b = 20;

System.out.println(a); // 10
System.out.println(b); // 20

در این مثال، مقدار a در حافظه Stack ذخیره شده و وقتی مقدار آن به b داده می‌شود، کپی می‌شود نه ارجاع.
در نتیجه تغییر مقدار b هیچ اثری روی a ندارد.


🏗️ ۲. Reference Types — ارجاع به اشیاء در حافظه Heap

هر داده‌ای که از نوع Primitive نباشد، یک Reference Type محسوب می‌شود.
به‌جای نگهداری مقدار مستقیم، در این نوع متغیرها آدرس (Reference) شیء در حافظه‌ی Heap ذخیره می‌شود.

📍 مثال:

class Person {
    String name;
    Person(String name) {
        this.name = name;
    }
}

public class ReferenceExample {
    public static void main(String[] args) {
        Person p1 = new Person("Saleh");
        Person p2 = p1;     // هر دو به یک شیء اشاره می‌کنند
        p2.name = "Ali";

        System.out.println(p1.name); // Ali
        System.out.println(p2.name); // Ali
    }
}

در این مثال، متغیرهای p1 و p2 هر دو به همان شیء در Heap اشاره می‌کنند.
بنابراین تغییر در p2 باعث تغییر در p1 نیز می‌شود، چون هر دو یک آدرس مشترک دارند.


🧠 ۳. تفاوت مفهومی بین Primitive و Reference Types

* Primitive Types: مقدار را مستقیماً در خود ذخیره می‌کنند.
* Reference Types: فقط آدرس شیء را در خود نگه می‌دارند.
* Primitive Types در Stack ذخیره می‌شوند، در حالی که Reference Types معمولاً در Heap قرار دارند.
* هنگام مقایسه با ==، در Primitive مقدار مقایسه می‌شود، ولی در Reference آدرس حافظه بررسی می‌شود.

📍 نمونه تفاوت مقایسه:

int x = 5;
int y = 5;
System.out.println(x == y); // true → مقدارها برابرند

String s1 = new String("Hello");
String s2 = new String("Hello");
System.out.println(s1 == s2);      // false → آدرس‌ها متفاوت‌اند
System.out.println(s1.equals(s2)); // true → محتوا برابر است

⚙️ ۴. نکته‌ی مهم درباره‌ی Wrapper Classes

جاوا برای هر نوع Primitive یک کلاس Wrapper در پکیج java.lang دارد (مثل Integer, Double, Boolean و ...).
این کلاس‌ها Reference Type هستند اما رفتارشان تا حد زیادی شبیه Primitive است.

📍 مثال:

int num1 = 100;
Integer num2 = 100; // Auto-boxing از int به Integer

System.out.println(num1 == num2);  // true → به‌خاطر unboxing خودکار

✨ جمع‌بندی:

* Primitive Types ساده، سریع و کم‌حافظه هستند.
* Reference Types پیچیده‌ترند و برای اشیاء استفاده می‌شوند.
* تفاوت در نحوه‌ی نگهداری داده، مقایسه، و رفتار در متدها باعث تفاوت بنیادی در عملکرد این دو نوع داده می‌شود.
* درک درست این تفاوت از خطاهایی مانند NullPointerException و Unexpected Mutations جلوگیری می‌کند.


📘 نکته پایانی:
در جاوا همه‌چیز شیء نیست — انواع پایه‌ای (int, double, boolean و غیره) استثنا هستند.
اما وقتی وارد ساختارهای داده‌ای مثل List<Integer> یا Map<String, Object> می‌شویم، جاوا از Wrapper Classes برای تبدیل خودکار آن‌ها به Reference Types استفاده می‌کند (این فرایند را *Auto-boxing* می‌گویند).

#کاربر_مبتدی

🆔 @javapro_ir
🆔 @group_javapro

امروز یک آگهی استخدام در جاوا رو دیدم و گفتم برداشتم رو از این فرصت شغلی جاوا باهاتون به اشتراک بذارم.

❇️ Junior Java Developer:

تسلط بر مفاهیم پایه جاوا و OOP

آشنایی با Spring Boot و SQL

آشنایی با Git و Clean Code


❇️ Mid-Level Java Developer:

✳️تسلط بر Spring Boot، Hibernate، و Concurrency

✳️آشنایی با Spring Security و Docker

✳️درک مفاهیم دیتابیس و Performance


❇️ Senior Java Developer:

✳️تجربه معماری سیستم و Microservices

✳️تسلط بر Kafka، Elasticsearch، OAuth 2.0

✳️درک عملکرد، مقیاس‌پذیری و طراحی سیستم‌های Enterprise

📌 حالا وقت سرمایه‌گذاری روی مهارت‌هاته:
یادگیری اصولی Java + Spring Boot + Microservices
یعنی گام گذاشتن در مسیر توسعه‌دهنده‌های حرفه‌ای با درآمدهای بالا و جایگاه واقعی در تیم‌های نرم‌افزاری.

جاوا فقط یک زبان نیست؛
💬 جاوا یعنی ساختن سیستم‌هایی که دنیا رویش می‌چرخه....

💻 مسیرت رو از امروز بساز...
روی مهارتت سرمایه‌گذاری کن، نه فقط برای استخدام،
بلکه برای اینکه «در هر شرایطی، خواستنی باشی».

#جاوا #Java #استخدام #برنامه_نویسی #SpringBoot #Microservices #فرصت_شغلی #JavaDeveloper

🆔 @javapro_ir
🆔 @group_javapro

به‌عنوان یک توسعه‌دهنده بک‌اند جاوا (Java Backend Developer)، بهتر است درک و آشنایی خوبی با موضوعات زیر داشته باشید 👇

۱. قضیه CAP
۲. مدل‌های سازگاری (Consistency Models)
۳. معماری‌های سیستم‌های توزیع‌شده
۴. برنامه‌نویسی سوکت (Socket Programming) با TCP/IP و UDP
۵. پروتکل HTTP و APIهای RESTful
۶. فراخوانی رویه از راه دور (RPC) مانند gRPC، Thrift و RMI
۷. صف‌های پیام (Message Queues) مانند Kafka، RabbitMQ و JMS
۸. همروندی در جاوا (Java Concurrency) — شامل ExecutorService، Future و ForkJoinPool
۹. ایمنی نخ‌ها (Thread Safety) و همگام‌سازی (Synchronization)
۱۰. مدل حافظه جاوا (Java Memory Model)
۱۱. پایگاه‌داده‌های توزیع‌شده مانند Cassandra، MongoDB و HBase
۱۲. تقسیم‌بندی و پارتیشن‌بندی داده‌ها (Data Sharding & Partitioning)
۱۳. مکانیزم‌های کش (Caching Mechanisms) مانند Redis، Memcached و Ehcache
۱۴. استفاده از Zookeeper برای هماهنگی در سیستم‌های توزیع‌شده
۱۵. الگوریتم‌های اجماع (Consensus Algorithms) مانند Paxos و Raft
۱۶. قفل‌های توزیع‌شده (Distributed Locks) با Zookeeper یا Redis
۱۷. فریم‌ورک‌های Spring Boot و Spring Cloud برای معماری مایکروسرویس‌ها
۱۸. کشف سرویس‌ها (Service Discovery) با Consul، Eureka و Kubernetes
۱۹. دروازه‌های API (API Gateways) مانند Zuul، NGINX و Spring Cloud Gateway
۲۰. ارتباط بین سرویس‌ها (Inter-service Communication) با REST، gRPC یا Kafka
۲۱. الگوهای شکست مدار و تلاش مجدد (Circuit Breakers & Retry Patterns) — مانند Hystrix و Resilience4j
۲۲. توازن بار (Load Balancing) با NGINX، Kubernetes و Ribbon
۲۳. مکانیزم‌های Failover برای پایداری سیستم
۲۴. تراکنش‌های توزیع‌شده (Distributed Transactions) — شامل 2PC و الگوی Saga
۲۵. لاگ‌گیری و ردیابی توزیع‌شده (Logging & Distributed Tracing) با ELK Stack، Jaeger یا Zipkin
۲۶. مانیتورینگ و شاخص‌ها (Monitoring & Metrics) با Prometheus، Grafana و Micrometer
۲۷. سیستم‌های هشداردهی (Alerting Systems)
۲۸. احراز هویت و مجوزدهی (Authentication & Authorization) — شامل OAuth و JWT
۲۹. رمزنگاری (Encryption) با SSL/TLS
۳۰. محدودسازی نرخ درخواست‌ها (Rate Limiting & Throttling)
۳۱. استفاده از Apache Kafka برای پردازش جریان داده‌های توزیع‌شده
۳۲. Apache Zookeeper برای هماهنگی سرویس‌ها
۳۳. شبکه‌های داده درون‌حافظه‌ای (In-memory Data Grids) مانند Hazelcast و Infinispan
۳۴. Akka برای همروندی مبتنی بر Actor
۳۵. معماری رویدادمحور (Event-Driven Architecture): شامل Event Sourcing و CQRS (تفکیک فرمان و پرس‌وجو)
۳۶. مدیریت کلاستر (Cluster Management): با Kubernetes برای ارکستراسیون کانتینرها
۳۷. توسعه بومی ابری (Cloud-Native Development): با استفاده از پلتفرم‌های ابری مانند AWS، GCP و Azure، و محاسبات Serverless مثل AWS Lambda
۳۸. پردازش داده‌های توزیع‌شده (Distributed Data Processing): با فریم‌ورک‌هایی مثل Apache Spark یا Apache Flink برای پردازش داده‌های در مقیاس بزرگ
۳۹. GraphQL: جایگزینی برای REST در ارتباط بین سرویس‌ها
۴۰. تنظیم و بهینه‌سازی JVM برای سیستم‌های توزیع‌شده: شامل مدیریت حافظه و بهینه‌سازی عملکرد

🆔 @javapro_ir
🆔 @group_javapro

یادگیری Spring Boot در سه مرحله (نقشه راه ساده)

🔹 مرحله ۱ – مبانی و مقدمات

در این مرحله باید با پایه‌های اصلی Spring Boot آشنا بشی:

یاد بگیر چطور با Spring Initializr یه پروژه‌ی جدید بسازی.

بفهم Maven و Gradle چی هستن (ابزارهایی برای ساخت و مدیریت پروژه).

یاد بگیر از Annotationها استفاده کنی (علامت‌هایی که به Spring می‌گن هر بخش از برنامه چه کاری انجام بده).

یادبگیر چطور تنظیمات مخصوص هر محیط (مثلاً تست، توسعه یا تولید) رو بسازی با استفاده از Profiles.

آشنا شو با دستورهای مهم مثل:

@GetMapping برای گرفتن داده از سرور

@PostMapping برای ارسال داده

@PutMapping برای ویرایش داده

@DeleteMapping برای حذف داده


یاد بگیر چطور داده‌هایی که در مسیر یا پارامتر آدرس هستن رو بگیری (Path Variable و Request Parameter).

یاد بگیر چطور برنامه‌ات رو به پایگاه داده وصل کنی (مثل H2، MySQL یا PostgreSQL).

یاد بگیر چطور از JpaRepository و CrudRepository برای ذخیره و خواندن داده‌ها استفاده کنی.

با ابزار Spring Boot DevTools آشنا شو تا وقتی برنامه‌ات رو تغییر دادی، خودش سریع دوباره اجرا بشه (Hot Reloading).

در آخر هم یه نگاهی بنداز به Spring Batch (برای کارهای زمان‌بندی‌شده) و تنظیم زمان با Cron Expressions.

🔹 مرحله ۲ – سطح متوسط

وقتی مقدمات رو یاد گرفتی، باید وارد مفاهیم عمیق‌تر بشی:

یاد بگیر چطور با @ControllerAdvice و @ExceptionHandler خطاها رو مدیریت کنی.

بتونی پیام‌های خطای مخصوص خودت بسازی و همه‌ی خطاهای برنامه رو به شکل سراسری کنترل کنی.

یاد بگیر چطور از احراز هویت ساده (Basic Authentication) استفاده کنی.

چطور امنیت APIها رو تنظیم کنی.

یاد بگیر چطور با JWT (Json Web Token) سیستم ورود بدون نیاز به نشست (Stateless) بسازی.

با مفهوم HATEOAS آشنا شو (اضافه کردن لینک‌های مفید به پاسخ‌های API).

یاد بگیر چطور نسخه‌بندی API انجام بدی (مثلاً از طریق آدرس، پارامتر یا هدر).

تست‌نویسی یاد بگیر:

با JUnit و Mockito برای تست واحدها (Unit Test)

با Spring Boot Test برای تست یکپارچه (Integration Test)

با MockMvc برای تست سرویس‌های REST


یاد بگیر از Spring Boot Actuator استفاده کنی تا سلامت و وضعیت برنامه‌ات رو بررسی کنی.

حتی می‌تونی شاخص سلامت سفارشی (Custom Health Indicators) بسازی.


🔹 مرحله ۳ – سطح پیشرفته

حالا وقتشه وارد دنیای حرفه‌ای‌تر بشی:

یاد بگیر از @Profile برای ساخت Beanهای مخصوص هر محیط استفاده کنی.

یاد بگیر چطور بین محیط‌ها (مثل dev، test، prod) جابه‌جا بشی.

شروع کن به ساخت پروژه‌ای با Spring Cloud.

با اجزای اصلی Spring Cloud آشنا شو:

راه‌اندازی Eureka Server برای ثبت سرویس‌ها

ثبت میکروسرویس‌ها در Eureka

انجام Service Discovery یعنی سرویس‌ها خودشون همدیگه رو پیدا کنن


یاد بگیر API Gateway چیه و چطور با Spring Cloud Gateway راهش بندازی.

مسیرها (Routes) و فیلترها (Filters) رو تنظیم کن.

یاد بگیر Spring Cloud Config Server چیه و چطور می‌تونی همه‌ی تنظیمات پروژه‌هات رو در یه جای مرکزی نگه‌داری کنی.

در آخر یاد بگیر چطور پروژه‌هات رو طوری تنظیم کنی که از Config Server استفاده کنن.


✅ نکته مهم

این نقشه راه تقریباً همه چیز رو برای یادگیری Spring Boot پوشش می‌ده،
اما بدون یه چیز مهم هنوز ناقصه 👇🏻
باید پروژه‌های واقعی و باکیفیت بسازی و بتونی این مفاهیم رو برای دیگران توضیح بدی 💯

🆔 @javapro_ir
🆔 @group_javapro

دوره پروژه محور مدیریت رستوران با معماری مایکروسرویس و Spring Boot به صورت دیپلوی و واقعی بزودی در آکادمی جاواپرو خواهیم داشت....

این دوره توسط یکی از سینیورهای عاشق جاوا، با بیش از ۲۰ سال سابقه برنامه‌نویسی در این زبان و بیش از ۱۰ سال تجربه در حوزه دواپس، تهیه می‌شود. ایشان دانشجوی سال آخر دکتری هوش مصنوعی، از لینوکس کارهای باسابقه و مدیرعامل استارتاپ «جاواهاستینگ» هستند.

در جاواپرو تلاش می‌کنیم سطح آموزش‌های جاوا در ایران را چندین پله ارتقا دهیم. اگر شما هم به رشد جامعه برنامه‌نویسی جاوا در ایران باور دارید، با معرفی جاواپرو به دوستان خود، ما را در این مسیر همراهی کنید.🤝

🆔 @javapro_ir
🆔 @group_javapro

🎓 موضوع: Auto-boxing و Unboxing در جاوا — پلی بین Primitive و Reference Types

در زبان جاوا، نوع‌های Primitive (مثل int, double, boolean) و نوع‌های Reference (مثل Integer, Double, Boolean) از هم جدا هستند.
اما جاوا برای سهولت کار، قابلیتی به نام Auto-boxing و Unboxing معرفی کرده است که به‌صورت خودکار بین این دو نوع تبدیل انجام می‌دهد.


🧩 ۱. Auto-boxing چیست؟

فرآیند تبدیل خودکار یک مقدار Primitive به شیء متناظر آن (Wrapper Class) را Auto-boxing می‌گویند.
یعنی جاوا خودش به‌صورت خودکار، نوع پایه‌ای را داخل یک کلاس بسته‌بندی (wrap) می‌کند.

📍 مثال:

public class AutoBoxingExample {
    public static void main(String[] args) {
        int num = 10;              // نوع Primitive
        Integer obj = num;         // Auto-boxing → از int به Integer

        System.out.println(obj);   // خروجی: 10
    }
}

در اینجا، جاوا به‌صورت خودکار مقدار num را به Integer.valueOf(num) تبدیل کرده است.
یعنی نیازی به نوشتن تبدیل دستی نیست.


⚙️ ۲. Unboxing چیست؟

فرآیند تبدیل خودکار یک شیء Wrapper به نوع Primitive معادلش را Unboxing می‌نامند.
در این حالت جاوا مقدار درون شیء را بیرون می‌کشد تا بتوان از آن در محاسبات عددی یا منطقی استفاده کرد.

📍 مثال:

public class UnboxingExample {
    public static void main(String[] args) {
        Integer obj = 25;          // Auto-boxing
        int num = obj;             // Unboxing → از Integer به int

        System.out.println(num + 5); // خروجی: 30
    }
}

در اینجا جاوا خودش obj.intValue() را فراخوانی کرده و مقدار پایه‌ای را به num اختصاص داده است.


💡 ۳. کاربرد Auto-boxing در Collectionها

ساختارهایی مانند ArrayList فقط با Reference Types کار می‌کنند.
بنابراین وقتی نوعی مثل int را در آن‌ها ذخیره می‌کنیم، جاوا خودش Auto-boxing انجام می‌دهد.

📍 مثال:

import java.util.ArrayList;

public class CollectionBoxing {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);  // Auto-boxing → int → Integer
        list.add(20);

        int sum = list.get(0) + list.get(1); // Unboxing خودکار
        System.out.println(sum); // خروجی: 30
    }
}

در این مثال، نیازی نیست خودمان بنویسیم new Integer(10) یا list.get(0).intValue()
جاوا تمام این کارها را پشت صحنه انجام می‌دهد.


⚠️ ۴. نکات و دام‌های مهم Auto-boxing

هرچند این ویژگی بسیار راحت است، اما اگر درست استفاده نشود، باعث مشکلات کارایی یا حتی خطاهای منطقی می‌شود.

📌 الف) مقایسه اشتباه با ==

Integer a = 1000;
Integer b = 1000;

System.out.println(a == b);      // false → آدرس‌ها متفاوت
System.out.println(a.equals(b)); // true  → مقدار برابر

در مقایسه‌ی ==، دو شیء Integer در حافظه‌ی جداگانه قرار دارند.
فقط مقادیر بین -128 تا 127 در cache نگهداری می‌شوند و ممکن است با == برابر شوند، ولی بقیه‌ی مقادیر خیر.


📌 ب) مصرف زیاد حافظه در حلقه‌ها

اگر در حلقه‌ها از Auto-boxing استفاده کنید، ممکن است تعداد زیادی شیء اضافی در Heap ساخته شود.

📍 مثال:

Long sum = 0L;
for (long i = 0; i < 1_000_000; i++) {
    sum += i; // هر بار Auto-boxing انجام می‌شود!
}
System.out.println(sum);

در اینجا در هر تکرار، جاوا یک شیء جدید Long می‌سازد چون sum از نوع Reference است.
برای جلوگیری از این مشکل، باید از نوع Primitive (long sum = 0;) استفاده کنید.


✨ ۵. جمع‌بندی

* در واقع Auto-boxing: تبدیل خودکار از نوع Primitive به Wrapper
* و Unboxing: تبدیل خودکار از Wrapper به Primitive
* استفاده از آن باعث ساده‌تر شدن کد می‌شود اما باید مراقب عملکرد و مقایسه‌ی اشتباه باشید.
* همیشه در حلقه‌ها و عملیات پرتکرار از انواع Primitive استفاده کنید تا از ایجاد اشیاء غیرضروری جلوگیری شود.


📘 نکته پایانی:
خب Auto-boxing یکی از ویژگی‌هایی است که باعث می‌شود جاوا هم “شیءگرا” باقی بماند و هم با نوع‌های پایه‌ای به‌صورت بهینه کار کند.
اما فهم درست تفاوت بین مقدار (Value) و ارجاع (Reference) همچنان کلید اصلی درک رفتار واقعی آن است.

#کاربر_مبتدی

📚لیست دوره های مرتبط با جاوا-آکادمی جاواپرو

🆔 @javapro_ir
🆔 @group_javapro

🟣 اشیای String در جاوا و مسائل مربوط به حافظه و عملکرد

✅️ رشته (String) یکی از پرکاربردترین اشیای جاوا در تقریباً تمام پروژه‌ها و برنامه‌ها است. بنابراین، نحوه استفاده مؤثر از آن به‌گونه‌ای که بر حافظه تأثیر منفی نگذارد، خود نوعی مهارت محسوب می‌شود. در این مطلب به بررسی آن می‌پردازیم.

🟣 اشیای String در جاوا می‌توانند منجر به مشکلات مختلفی در زمینه حافظه و عملکرد شوند، که عمدتاً به دلیل غیرقابل‌تغییر بودن (immutability) و نحوه ذخیره‌سازی آن‌ها است.

✅️ مصرف حافظه و String Pool

🔹 هر رشته در جاوا غیرقابل‌تغییر است، بنابراین هرگونه تغییر یا الحاق (concatenation) باعث ایجاد یک شیء جدید از نوع String می‌شود. این موضوع می‌تواند باعث افزایش مصرف حافظه شود، به‌ویژه در حلقه‌ها یا عملیات سنگین متنی.

🔹 جاوا از ناحیه حافظه‌ای ویژه به نام String Pool برای ذخیره مقادیر رشته‌ای ثابت (string literals) استفاده می‌کند تا رشته‌های تکراری را مجدداً به‌کار گیرد و در نتیجه در مصرف حافظه صرفه‌جویی شود. با این حال، اگر رشته‌ها را با استفاده از کلیدواژه new ایجاد کنید، این اشیا در Heap قرار می‌گیرند و قابل استفاده مجدد نیستند، که منجر به غیربهینه بودن حافظه می‌شود.

🔹 هر شیء String شامل یک آرایه کاراکتر (با فرمت UTF-16، یعنی ۲ بایت برای هر کاراکتر) و اطلاعات جانبی (metadata) است، که معمولاً باعث می‌شود هر رشته بیش از مقدار واقعی کاراکترها حافظه مصرف کند.

🟣 مشکلات عملکرد (Performance Issues)

🔹 الحاق مکرر رشته‌ها با استفاده از علامت + درون حلقه‌ها بسیار ناکارآمد است، زیرا هر بار یک شیء جدید ساخته می‌شود. این امر باعث پیچیدگی زمانی O(n²) و ایجاد تعداد زیادی شیء موقتی می‌گردد که در نتیجه فشار زیادی به Garbage Collector وارد می‌کند.

🔹 استفاده از String.format در مقایسه با الحاق ساده برای موارد معمول کندتر است، هرچند در برخی موقعیت‌ها مانند ثبت گزارش‌ها (logging) مناسب‌تر است.

🔹 استفاده بیش‌ازحد از اشیای String در بخش‌های حساس به عملکرد (performance-critical sections) می‌تواند باعث افزایش توقف‌های Garbage Collection شود، به دلیل ساخت مداوم اشیای جدید.

🟣 بهترین روش‌ها و راهکارهای بهینه‌سازی

🔹 برای عملیات متنی سنگین و الحاق رشته‌ها درون حلقه‌ها، از StringBuilder یا StringBuffer استفاده کنید، چون این کلاس‌ها قابل‌تغییر (mutable) هستند و داده‌ها را در یک بافر داخلی ویرایش می‌کنند، بدون اینکه هر بار شیء جدیدی بسازند.

🔹 از ایجاد غیرضروری اشیای جدید با new String() خودداری کنید، زمانی که می‌توان از رشته‌های ثابت یا ارجاع‌های موجود استفاده کرد.

🔹 ساختار حافظه و نحوه کار String Pool را درک کنید و بسته به شرایط، از روش‌های مناسب (مثل interning یا آگاهی از محل ذخیره‌سازی رشته‌ها) استفاده کنید تا هم عملکرد و هم مصرف حافظه بهینه شود.

✳️ مدیریت نادرست رشته‌ها یکی از منابع پنهان کاهش کارایی در کدهای جاوا است، به‌ویژه زمانی که برنامه‌ها در مقیاس بزرگ یا با داده‌های متنی حجیم کار می‌کنند.


📚لیست دوره های مرتبط با جاوا-آکادمی جاواپرو

🆔 @javapro_ir
🆔 @group_javapro

دوره جامع نخبگان معماری میکروسرویس ها با Java و Spring Boot بروزرسانی شد

فصل ۲۲ به دوره اضاف شد
تاریخ آخرین بروزرسانی:  ۱۳ آبان ۱۴٠۴

مشاهده

تهیه دوره جامع نخبگان معماری میکروسرویس ها با Java و Spring Boot به صورت اقساط بدون ضمانت و بدون سود

🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥

امکان تهیه دوره میکروسرویس طی ۴ قسط برای مدت محدود، جهت خرید به صورت اقساط به آی دی زیر پیام بدید👇
@rzutab

🎯 سینیور جاوا دولوپر بودن یعنی فقط “تجربه زیاد” داشتن؟ نه!

سینیور واقعی کسیه که ترکیب «دانش عمیق، تفکر سیستمی و توان تصمیم‌گیری معماری» رو داره، نه صرفاً کسی که چند سال کد زده.

🧠 مقاله Droomwork دقیقاً می‌گه یه Java Developer برای رسیدن به سطح سینیور باید روی ۵ مهارت کلیدی مسلط بشه 👇

1️⃣ Java Core & Frameworks
از جاوا، سروِلت، JSP تا Spring و Hibernate — بدون تسلط به این‌ها حتی نباید از «سینیور» حرف زد.

2️⃣ Database Mastery
شناخت حرفه‌ای از MySQL، Oracle یا MongoDB برای ساخت سیستم‌های مقیاس‌پذیر و امن حیاتی‌ه.

3️⃣ Enterprise Architecture Patterns
درک الگوهای معماری سازمانی یعنی بدونی چرا یه ساختار درست باعث میشه نرم‌افزار در آینده هم زنده بمونه.

4️⃣ Agile Mindset
سینیور کسیه که تیم‌بلدره؛ همکاری، سازگاری و تحویل مداوم رو بلده نه فقط کدنویسی تکی.

5️⃣ Libraries & Modern Tools
کتابخونه‌ها و ابزارهایی مثل Retrofit، Firebase یا Jenkins فقط ابزار نیستن — کلید سرعت و انعطاف در توسعه‌ان.

💡 در نهایت، سینیور بودن یعنی بتونی مسائل پیچیده رو ساده کنی و به تیم جهت بدی، نه اینکه فقط دست‌هات سریع‌تر تایپ کنن

در مصاحبه‌های استخدامی برنامه‌نویس جاوا، اگر در معماری میکروسرویس مسلط باشید، اولین مزیت شما این است که با اعتماد به نفس بالا در جلسه مصاحبه حاضر می‌شوید و مصاحبه‌کننده روی توانایی‌های شما حساب ویژه‌ای باز خواهد کرد.

شما می‌توانید به صورت خودآموز از منابع مختلف اقدام به یادگیری کنید. اما اگر جزو افرادی هستید که وقت محدودی دارید و می‌خواهید مسیر یادگیری را منظم، پیوسته و اصولی طی کنید، می‌توانید در دوره جامع نخبگان میکروسرویس با جاوا و Spring آکادمی جاواپرو شرکت نمایید.

👇📚
ثبت‌نام در دوره جامع نخبگان معماری میکروسرویس با Java و Spring Boot

نکته قابل توجه: برخی از دانشجویان این دوره، از سوی شرکت خود تشویق به شرکت در آن شده و مبلغ سرمایه‌گذاری دوره توسط شرکت پرداخت شده است.

🆔 @javapro_ir
🆔 @group_javapro

🧩 سازنده‌ها (Constructors) و زنجیره‌سازی سازنده‌ها (Constructor Chaining)

در زبان جاوا، سازنده (Constructor) متدی ویژه است که هنگام ایجاد یک شیء (Object) از کلاس، به‌صورت خودکار فراخوانی می‌شود و وظیفه‌ی مقداردهی اولیه‌ی فیلدها را بر عهده دارد.


✳️ نکات کلیدی درباره‌ی Constructor

* نام سازنده باید دقیقاً با نام کلاس یکسان باشد.
* سازنده هیچ نوع بازگشتی (حتی void) ندارد.
* اگر هیچ سازنده‌ای تعریف نکنید، جاوا به‌صورت خودکار یک سازنده پیش‌فرض (default constructor) بدون پارامتر ایجاد می‌کند.

🔹 مثال:

class Person {
    String name;
    int age;

    // سازنده با پارامتر
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

🔁 زنجیره‌سازی سازنده‌ها (Constructor Chaining)

زنجیره‌سازی زمانی اتفاق می‌افتد که یک سازنده، سازنده‌ی دیگری از همان کلاس یا کلاس پدر را فراخوانی کند.
برای این کار از کلیدواژه‌های this() و super() استفاده می‌شود.

🔹 this() → برای فراخوانی سازنده‌ی دیگری از همان کلاس
🔹 super() → برای فراخوانی سازنده‌ی کلاس پدر (superclass)

📘 مثال:

class Vehicle {
    Vehicle() {
        System.out.println("Vehicle constructor called");
    }
}

class Car extends Vehicle {
    Car() {
        this("Sedan");
        System.out.println("Car default constructor called");
    }

    Car(String type) {
        super();
        System.out.println("Car type: " + type);
    }
}

🔹 خروجی:

Vehicle constructor called
Car type: Sedan
Car default constructor called

📚 جمع‌بندی:
زنجیره‌سازی سازنده‌ها به شما کمک می‌کند کد تکراری را کاهش دهید و سازمان‌دهی منطقی بین کلاس‌ها ایجاد کنید.
استفاده‌ی درست از this() و super() در طراحی شی‌ءگرا، یکی از اصول مهم برای کدنویسی تمیز و قابل نگهداری در جاوا است.

#کاربرـپیشرفته

📚لیست دوره های مرتبط با جاوا-آکادمی جاواپرو

🆔 @javapro_ir
🆔 @group_javapro

الگوهای طراحی مهم برای میکروسرویس‌های Java + Spring Boot

@javapro_ir
🆔 @group_javapro