Xgare Technologies

Posted on Oct 30

Top 10 Core Java Concepts Every Beginner Should Know

Learning Java can feel overwhelming at first, but once you understand the core concepts, everything else becomes much easier to grasp.

In this post, we’ll walk through the 10 most important Java fundamentals every beginner should know — with clear explanations and short code examples.

Let’s dive in

1. Variables and Data Types

Variables are used to store data, and every variable in Java has a type.

Java is strongly typed, meaning you must declare the data type before using a variable.

int age = 25; // integer double price = 99.99; // decimal number char grade = 'A'; // single character boolean isJavaFun = true; // true/false String name = "Hello"; // text

Tip: Always choose the right data type to save memory and improve performance.

2. Object-Oriented Programming (OOP)

Java is built around OOP principles, which make your code organized and reusable.

The 4 pillars of OOP are:

Encapsulation — wrapping data and methods into a single unit (class)
Inheritance — one class can use properties of another
Polymorphism — one action behaves differently in different situations
Abstraction — hiding complex details and showing only essential features

`class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}

class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}

public class Main {
public static void main(String[] args) {
Animal a = new Dog();
a.sound(); // Output: Dog barks
}
}`

3. Classes and Objects

A class is a blueprint, and an object is an instance of that class.

`class Car {
String brand = "Tesla";

void drive() {
    System.out.println("Car is driving...");
}

}

public class Main {
public static void main(String[] args) {
Car myCar = new Car(); // Create object
System.out.println(myCar.brand);
myCar.drive();
}
}`

Tip: Use classes to represent real-world entities like User, BankAccount, Product, etc.

4. Constructors

A constructor initializes objects when they are created.
It has the same name as the class and no return type.

`class Student {
String name;

// Constructor
Student(String n) {
    name = n;
}

void display() {
    System.out.println("Student name: " + name);
}

}

public class Main {
public static void main(String[] args) {
Student s = new Student("Developer");
s.display();
}
}`

5. Inheritance

Inheritance allows one class to acquire properties and methods of another.

`class Parent {
void greet() {
System.out.println("Hello from Parent!");
}
}

class Child extends Parent {
void play() {
System.out.println("Child is playing");
}
}

public class Main {
public static void main(String[] args) {
Child c = new Child();
c.greet(); // from Parent
c.play(); // from Child
}
}
`

Tip: Use inheritance to avoid code duplication and improve maintainability.

6. Interfaces and Abstract Classes

Both are used to achieve abstraction.

Abstract class: Can have both abstract and normal methods.
Interface: All methods are abstract by default (until Java 8 introduced default methods).

`interface Animal {
void makeSound();
}

class Cat implements Animal {
public void makeSound() {
System.out.println("Meow!");
}
}

public class Main {
public static void main(String[] args) {
Animal cat = new Cat();
cat.makeSound();
}
}

`

7. Exception Handling

Exceptions are errors that occur during runtime.
To prevent your program from crashing, use try, catch, and finally.

public class Main { public static void main(String[] args) { try { int result = 10 / 0; } catch (ArithmeticException e) { System.out.println("Error: " + e.getMessage()); } finally { System.out.println("This always executes!"); } } }

Tip: Handle exceptions gracefully to make your applications stable.

8. Collections Framework

Collections are used to store, manage, and manipulate groups of objects.

Common interfaces:

List — ordered, allows duplicates (ArrayList, LinkedList)
Set — unique elements (HashSet, TreeSet)
Map — key-value pairs (HashMap, TreeMap)

`import java.util.*;

public class Main {
public static void main(String[] args) {
List names = new ArrayList<>();
names.add("Adam");
names.add("Alan");
names.add("Adam"); // duplicates allowed
System.out.println(names);
}
}
`

9. Java Strings and StringBuilder

Strings are widely used for text manipulation.
String is immutable, meaning once created, it cannot be changed.
For better performance when modifying text, use StringBuilder.

public class Main { public static void main(String[] args) { StringBuilder sb = new StringBuilder("Hello"); sb.append(" Java"); System.out.println(sb); // Output: Hello Java } }

10. File Handling in Java

You can read and write files using classes like File, FileWriter, and Scanner.

`import java.io.FileWriter;
import java.io.IOException;

public class Main {
public static void main(String[] args) {
try {
FileWriter writer = new FileWriter("output.txt");
writer.write("Hello, Dev.to readers!");
writer.close();
System.out.println("File written successfully!");
} catch (IOException e) {
System.out.println("An error occurred.");
}
}
}

`

Conclusion

These are the 10 fundamental Java concepts every beginner should master.
Understanding these will give you a strong foundation to explore advanced topics like: