Java encapsulation w3schools example

Java encapsulation w3schools example

Java Encapsulation Example by W3Schools:

In object-oriented programming (OOP), encapsulation is the concept of bundling an object's properties and methods that operate on those properties within a single unit, known as a class or struct. This technique helps to hide the implementation details of an object from other parts of your program, improving modularity and reducing complexity.

Let's consider an example of encapsulation in Java using W3Schools' code snippet:

public class Employee {
private String name;
private int age;
public Employee(String n, int a) {
this.name = n;
this.age = a;
}
public void setName(String n) {
name = n;
}
public void setAge(int a) {
if (a > 0) {
age = a;
} else {
System.out.println("Invalid age. Age must be greater than zero.");
}
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}

In this code, the Employee class encapsulates its properties (name and age) and methods (setName, setAge, getName, and getAge). The class uses private variables to hide the internal implementation details. This approach helps prevent direct access to these internal variables from outside the class.

Benefits of Encapsulation:

Example Usage:

public class Main {
public static void main(String[] args) {
Employee emp = new Employee("John", 30);
System.out.println("Name: " + emp.getName());
System.out.println("Age: " + emp.getAge());
// Trying to set invalid age
emp.setAge(25); // Okay, this is allowed
try {
emp.setAge(-1); // Error! Invalid age.
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}

In the Main class, we create an instance of the Employee class and access its public methods (getName and getAge) to retrieve and manipulate data. The encapsulation ensures that the internal state is protected from direct modification by other parts of your program.

W3Schools' example illustrates how Java encapsulation can help maintain object-oriented programming principles, making your code more robust, modular, and easier to understand and maintain.

Java encapsulation w3schools tutorial

I'll provide an explanation of Java encapsulation using the W3Schools tutorial.

W3Schools defines encapsulation as a fundamental concept in object-oriented programming (OOP) that binds together the data and methods that manipulate the data, and that hides them from the outside world. In other words, encapsulation is about hiding the internal details of an object from the outside world and only providing access to it through a public interface.

Java supports encapsulation using classes. A class defines a blueprint for creating objects, which are instances of the class. The class consists of two main parts: variables (data) and methods (functions). In Java, these variables are called instance variables or data members.

The importance of encapsulation lies in its ability to control access to the internal state of an object. You can restrict access to certain parts of the object by making them private, which means they can only be accessed within the class itself.

Here is a simple example from W3Schools:

public class Person {
// Private data members
private String name;
private int age;
// Public constructor
public Person(String n, int a) {
name = n;
age = a;
}
// Public method to get the name
public String getName() {
return name;
}
// Public method to get the age
public int getAge() {
return age;
}
}

In this example, the Person class encapsulates its private variables (name and age) within the class itself. The constructor is used to set these private variables when an object of type Person is created. The getter methods (getName() and getAge()) provide public access to these private variables.

W3Schools also explains that there are two types of encapsulation in Java: package-level encapsulation and instance-level encapsulation.

In conclusion, Java encapsulation is a fundamental concept that allows you to control access to an object's internal state by hiding it from the outside world and providing public interfaces for interaction. This helps in creating robust and maintainable software systems.