Java Basic Concepts

Java, being a versatile and robust programming language, offers several advanced features and concepts that enable developers to build scalable, efficient, and secure applications. This document explores some of the key advanced concepts in Java with examples.

1. Generics

Generics allow you to write classes and methods that operate on parameters, which are specified as types. They provide compile-time type safety by allowing you to specify the type of objects that a collection can contain.

Example:

// A generic class example
class Box<T> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

public class GenericsExample {
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<>();
        integerBox.set(10); // Autoboxing
        System.out.println("Integer Value: " + integerBox.get());

        Box<String> stringBox = new Box<>();
        stringBox.set("Hello, Generics!");
        System.out.println("String Value: " + stringBox.get());
    }
}

2. Collections Framework

Java Collections Framework provides a set of interfaces and classes to store, manipulate, and retrieve collections of objects. It includes List, Set, Queue, and Map interfaces along with their implementations like ArrayList, HashSet, LinkedList, etc.

Example:

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        // Creating a list
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("JavaScript");

        // Iterating over elements using forEach method
        System.out.println("List of Programming Languages:");
        list.forEach(language -> System.out.println(language));
        
        // Creating a set
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);

        // Iterating over elements using Iterator
        System.out.println("Set of Numbers:");
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

3. Multithreading

Multithreading allows concurrent execution of multiple threads within a single process. Java provides built-in support for multithreading through its Thread class and Runnable interface, allowing developers to write concurrent programs to improve application performance.

Example:

public class MultithreadingExample {
    public static void main(String[] args) {
        // Creating a thread using Thread class
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread 1 is running.");
            }
        });

        // Creating a thread using lambda expression
        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 is running.");
        });

        // Starting threads
        thread1.start();
        thread2.start();
    }
}

4. Annotations

Annotations provide metadata about a program that can be processed at compile time or runtime. Java annotations can be used to provide information to the compiler or runtime environment about how classes, methods, or other program elements should be processed.

Example:

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Test {
    String value() default "";
}

public class AnnotationsExample {

    @Test(value = "Example Test")
    public void testMethod() {
        System.out.println("Executing test method.");
    }

    public static void main(String[] args) throws Exception {
        AnnotationsExample example = new AnnotationsExample();
        example.getClass().getMethod("testMethod").invoke(example);
    }
}

5. Reflection API

Reflection in Java allows examination of classes, interfaces, fields, and methods at runtime without knowing their names at compile time. It is used extensively in frameworks like Spring and Hibernate for dependency injection and object-relational mapping.

Example:

import java.lang.reflect.*;

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        // Getting class information
        Class<?> clazz = Class.forName("java.lang.String");
        System.out.println("Class Name: " + clazz.getName());

        // Getting methods
        Method[] methods = clazz.getDeclaredMethods();
        System.out.println("Methods of String class:");
        for (Method method : methods) {
            System.out.println(method.getName());
        }

        // Creating instance using reflection
        Constructor<?> constructor = clazz.getConstructor(String.class);
        String str = (String) constructor.newInstance("Hello, Reflection!");
        System.out.println("Created String: " + str);
    }
}

---

Conclusion

Advanced Java concepts like Generics, Collections, Multithreading, Annotations, and Reflection enhance the capabilities of Java applications, making them more efficient, scalable, and maintainable. Mastering these concepts empowers developers to build robust and sophisticated software solutions.