core java tutorial for beginners with examples

Core Java Tutorial for Beginners with Examples

Java is one of the most popular programming languages in the world, known for its portability, performance, and security features. In this Core Java tutorial for beginners, we will cover the fundamental concepts of Java programming, providing clear explanations along with practical examples. Whether you are a complete novice or someone who wants to brush up on your Java skills, this tutorial will guide you through the essentials of Core Java, laying a solid foundation for your programming journey.

1. Introduction to Java

Java, developed by Sun Microsystems in the mid-1990s, is an object-oriented programming language that follows the principle of "Write Once, Run Anywhere" (WORA). This means that Java code can be written on one platform and run on any other platform that supports Java without the need for recompilation.

Key features of Java include:

• Object-Oriented: Java promotes the use of objects and classes, which makes it easier to manage and maintain code.


• Platform Independent: Java programs are compiled into bytecode, which can run on any system with a Java Virtual Machine (JVM).


• Robust: Java has strong memory management, exception handling, and type checking, making it less prone to errors.


• Security: Java provides a secure environment through its runtime environment and APIs.

2. Setting Up the Java Development Environment

Before diving into coding, you need to set up your Java development environment. Follow these steps:

2.1 Install the Java Development Kit (JDK)

1. Visit the official Oracle website or OpenJDK.
2. Download the latest version of the JDK.
3. Follow the installation instructions based on your operating system (Windows, macOS, or Linux).

2.2 Install an Integrated Development Environment (IDE)

Although you can write Java programs in any text editor, using an IDE makes the process much easier. Some popular IDEs for Java are:

• Eclipse


• IntelliJ IDEA


• NetBeans

Install one of these IDEs and set it up to work with the JDK you just installed.

3. Java Basics

Now that your environment is set up, let’s start with the basics of Java programming.

3.1 Writing Your First Java Program

The classic first program in any programming language is the "Hello, World!" program. Here’s how to write it in Java:

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

• Explanation:


• `public class HelloWorld` defines a class named HelloWorld.


• `public static void main(String[] args)` is the entry point of the program.


• `System.out.println("Hello, World!");` prints the message to the console.

3.2 Data Types in Java

Java is a statically typed language, which means you must declare the type of variables. Here are some common data types:

• int: Integer values (e.g., `int age = 25;`)


• double: Floating-point numbers (e.g., `double salary = 2500.50;`)


• char: Single characters (e.g., `char grade = 'A';`)


• boolean: True or false values (e.g., `boolean isJavaFun = true;`)

3.3 Variables and Constants

Variables store data that can change during program execution, while constants store data that cannot change. Here’s how to declare them:

```java
int number = 10; // Variable
final double PI = 3.14; // Constant
```

4. Control Flow Statements

Control flow statements help in controlling the execution flow of the program. The primary control flow statements in Java are:

4.1 Conditional Statements

• If statement: Executes a block of code if a specified condition is true.

```java if (number > 0) { System.out.println("Number is positive."); } ```

• Switch statement: Allows the variable to be tested for equality against a list of values.

```java switch (day) { case 1: System.out.println("Monday"); break; case 2: System.out.println("Tuesday"); break; default: System.out.println("Invalid day"); } ```

4.2 Loops

Loops are used to execute a block of code multiple times. The primary types of loops in Java are:

• For Loop: Repeats a block of code a specific number of times.

```java
for (int i = 0; i < 5; i++) {
System.out.println("Iteration: " + i);
}
```

• While Loop: Repeats a block of code as long as a specified condition is true.

```java
int count = 0;
while (count < 5) {
System.out.println("Count: " + count);
count++;
}
```

5. Object-Oriented Programming Concepts

Java is an object-oriented language, which means it supports the principles of encapsulation, inheritance, and polymorphism.

5.1 Classes and Objects

A class is a blueprint for creating objects. An object is an instance of a class. Here’s how to create a class and an object:

```java
class Dog {
String breed;
int age;

void bark() {
System.out.println("Woof! Woof!");
}
}

public class Main {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.breed = "Labrador";
myDog.age = 3;
myDog.bark();
}
}
```

5.2 Inheritance

Inheritance allows a new class to inherit properties and behaviors from an existing class.

```java
class Animal {
void eat() {
System.out.println("Eating...");
}
}

class Cat extends Animal {
void meow() {
System.out.println("Meow!");
}
}

public class Main {
public static void main(String[] args) {
Cat myCat = new Cat();
myCat.eat();
myCat.meow();
}
}
```

5.3 Polymorphism

Polymorphism allows methods to do different things based on the object it is acting upon.

```java
class Bird {
void sound() {
System.out.println("Chirp!");
}
}

class Parrot extends Bird {
void sound() {
System.out.println("Squawk!");
}
}
```

In this example, the `sound` method is overridden in the `Parrot` class.

6. Exception Handling

Java provides a robust mechanism to handle exceptions, which are runtime errors. The main keywords used in exception handling are `try`, `catch`, and `finally`.

```java
try {
int result = 10 / 0; // This will throw an ArithmeticException
} catch (ArithmeticException e) {
System.out.println("Cannot divide by zero!");
} finally {
System.out.println("This block is always executed.");
}
```

7. Conclusion

In this Core Java tutorial for beginners, we covered the essential concepts of Java programming, from setting up the environment to understanding object-oriented programming principles. Mastering these fundamentals will equip you with the knowledge needed to tackle more advanced topics in Java, such as multithreading, networking, and Java frameworks like Spring and Hibernate.

As you continue your journey in Java programming, practice is key. Write code, experiment with examples, and build small projects to reinforce your understanding. Happy coding!