Core Java Course | Ram Sir | DeviX Solutions

01. Introduction to Java

Java Fundamentals

Java is a class-based, object-oriented programming language that is platform-independent due to the JVM. Core components: JDK, JRE, and JVM.

HelloWorld.java

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

02. Variables & Data Types

Data Storage in Java

Java supports primitive types (int, double, boolean, char) and reference types (String, arrays, objects). Supports type casting & conversions.

VariablesExample.java

public class VariablesExample {
    public static void main(String[] args) {
        // Primitive types
        int age = 25;
        double salary = 50000.75;
        boolean active = true;

        // Reference type
        String name = "John Doe";

        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

03. Operators

Working with Operators

Operators perform operations on variables. Includes arithmetic, logical, relational, assignment, and bitwise.

OperatorsExample.java

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10, b = 5;
        System.out.println("Sum: " + (a + b));
        System.out.println("Equal? " + (a == b));
        System.out.println("Logical AND: " + (a > 0 && b > 0));
    }
}

04. Control Statements

Decision Making

Control flow allows branching execution with if-else, switch-case, and ternary operator.

ControlFlowExample.java

public class ControlFlowExample {
    public static void main(String[] args) {
        int num = 0;
        if(num > 0) System.out.println("Positive");
        else if(num < 0) System.out.println("Negative");
        else System.out.println("Zero");
    }
}

05. Loops

Iteration in Java

Repeats code using for, while, do-while, and for-each.

LoopsExample.java

public class LoopsExample {
    public static void main(String[] args) {
        for(int i=1;i<=3;i++) System.out.println("For: "+i);
        int j=1;
        while(j<=3){ System.out.println("While: "+j); j++; }
    }
}

06. Arrays

Data Collections

Arrays hold multiple values. Java supports 1D and 2D arrays.

ArraysExample.java

public class ArraysExample {
    public static void main(String[] args) {
        int[] nums = {1,2,3};
        for(int n: nums) System.out.println(n);
    }
}

07. Strings

Immutable Text Handling

Strings are immutable. Use StringBuilder for mutable operations.

StringExample.java

public class StringExample {
    public static void main(String[] args) {
        String s = "Java";
        System.out.println(s.toUpperCase());
        StringBuilder sb = new StringBuilder("Hello");
        sb.append(" World");
        System.out.println(sb);
    }
}

08. Methods

Reusable Code Blocks

Methods define reusable logic. Supports static, instance, overloading.

MethodsExample.java

public class MethodsExample {
    static int add(int a, int b){ return a+b; }
    public static void main(String[] args) {
        System.out.println(add(5,3));
    }
}

09. Constructors

Special Methods for Initialization

Constructors initialize objects. Can be default, parameterized, or overloaded.

ConstructorExample.java

public class ConstructorExample {
    String name;
    ConstructorExample(String n){ name=n; }
    public static void main(String[] args){
        ConstructorExample obj = new ConstructorExample("Ram");
        System.out.println("Name: "+obj.name);
    }
}

10. Exception Handling

Error Management

Handle errors using try-catch-finally. Exceptions are checked or unchecked.

ExceptionExample.java

public class ExceptionExample {
    public static void main(String[] args){
        try{
            int x=5/0;
        }catch(Exception e){
            System.out.println("Error: "+e.getMessage());
        }
    }
}

11. Wrapper Classes & Autoboxing

Object Representation of Primitives

Each primitive has a wrapper (Integer, Double, etc). Autoboxing/unboxing allows automatic conversion.

WrapperExample.java

public class WrapperExample {
    public static void main(String[] args){
        int a=10;
        Integer obj=a; // autoboxing
        int b=obj;     // unboxing
        System.out.println("Obj:"+obj+" b:"+b);
    }
}

12. Static & Final

Class-Level and Constant Definitions

Static members belong to the class. Final makes constants, prevents overriding.

StaticFinalExample.java

public class StaticFinalExample {
    static int counter=0;
    final int id;
    StaticFinalExample(int id){ this.id=id; counter++; }
    public static void main(String[] args){
        StaticFinalExample s1=new StaticFinalExample(1);
        System.out.println("Objects created:"+counter);
    }
}

13. Packages & Access Modifiers

Organizing Code

Packages group related classes. Access modifiers: public, protected, default, private.

PackageExample.java

package mypackage;
public class PackageExample {
    public static void main(String[] args){
        System.out.println("Package Example");
    }
}

14. Multithreading Basics

Concurrent Execution

Multithreading allows multiple tasks to run simultaneously. Use Thread class or Runnable interface.

ThreadExample.java

public class ThreadExample extends Thread {
    public void run(){ System.out.println("Thread running..."); }
    public static void main(String[] args){
        ThreadExample t1=new ThreadExample();
        t1.start();
    }
}

15. Collections Framework

Dynamic Data Structures

Java Collections (List, Set, Map) are resizable and powerful for data management.

CollectionsExample.java

import java.util.*;
public class CollectionsExample {
    public static void main(String[] args){
        List list=new ArrayList<>();
        list.add("Java"); list.add("Python");
        System.out.println(list);
    }
}

16. Generics

Type-Safe Programming

Generics allow classes and methods to operate on objects of various types while providing compile-time safety.

GenericsExample.java

public class GenericsExample<T> {
    T value;
    GenericsExample(T v){ value=v; }
    public T getValue(){ return value; }
    public static void main(String[] args){
        GenericsExample<String> g=new GenericsExample<>("Hello");
        System.out.println(g.getValue());
    }
}

17. Java 8 Features

Functional Programming

Java 8 introduced Lambdas, Streams, and Functional Interfaces.

LambdaExample.java

import java.util.*;
public class LambdaExample {
    public static void main(String[] args){
        List<String> list=Arrays.asList("a","b","c");
        list.forEach(x -> System.out.println(x));
    }
}

18. File Handling

Working with Files

Java provides File, FileReader, BufferedReader, FileWriter for file handling.

FileExample.java

import java.io.*;
public class FileExample {
    public static void main(String[] args)throws Exception{
        FileWriter fw=new FileWriter("test.txt");
        fw.write("Hello File");
        fw.close();
    }
}

19. Annotations

Metadata in Java

Annotations provide metadata to classes, methods, fields. Common: @Override, @Deprecated.

AnnotationExample.java

class Parent { void show(){ System.out.println("Parent"); } }
class Child extends Parent {
    @Override
    void show(){ System.out.println("Child"); }
}
public class AnnotationExample {
    public static void main(String[] args){
        new Child().show();
    }
}

20. Enums

Constants Grouping

Enums define a fixed set of constants. Safer alternative to constants in classes.

EnumExample.java

enum Day { MON, TUE, WED }
public class EnumExample {
    public static void main(String[] args){
        Day d=Day.MON;
        System.out.println("Day: "+d);
    }
}

Core Java Mastery Course