Encaptulation

public class Person {
    private String name;
    private int age;

    // Getter method for 'name' field
    public String getName() {
        return name;
    }

    // Setter method for 'name' field
    public void setName(String name) {
        this.name = name;
    }

    // Getter method for 'age' field
    public int getAge() {
        return age;
    }

    // Setter method for 'age' field
    public void setAge(int age) {
        this.age = age;
    }
}

1. 1. Private Fields: The class person has two private fields: name and age. These fields are not directly accessible from outside the class, which is a crucial aspect of encapsulation. Other classes or code cannot directly modify or read these fields.
   2. Getter Methods: The class provides public getter methods to access the private fields. For the name field, the getter method getName() returns the value of the name For the age field, the getter method getAge() returns the value of the age field.
   3. Setter Methods: The class also provides public setter methods to modify the private fields. For the name field, the setter method setName(String name) takes a String parameter name and sets the value of the name field to the provided value. For the age field, the setter method setAge(int age) takes an int parameter age and sets the value of the age field to the provided value.

   By providing getter and setter methods, the class allows external code to access and modify the name and age fields indirectly, while still maintaining control over the data. If necessary, the class can add more logic to the getter and setter methods to impose restrictions or validation criteria.

   To guarantee that the supplied age is a positive number and is within a suitable range, for instance, the class can include logic in the setter method setAge(int age). Similarly, the setter method setName(String name) could check if the provided name is not empty or null.

   Overall, this is a simple example of encapsulation in Java, and it demonstrates how you can protect the internal data of a class and provide controlled access to it through well-defined interfaces (getter and setter methods).

   You must first construct an instance (object) of the Person class in order to use it and invoke its methods. Once the object is formed, you can access and alter the private fields (name and age) using its getter and setter methods. Here’s how you can do it:

public class Main {
    public static void main(String[] args) {
        // Create an instance of the Person class
        Person person = new Person();

        // Use the setter methods to set the name and age of the person
        person.setName("John Doe");
        person.setAge(30);

        // Use the getter methods to retrieve and display the name and age of the person
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

In this example, we’ve created a Main class with a main method. Inside the main method, we create an object of the Person class named person.
We then use the setter methods (setName and setAge) to set the name to “John Doe” and the age to 30.
Finally, we use the getter methods (getName and getAge) to retrieve the name and age of the person object and print them to the console.

When you run the Main class, it will output:

This demonstrates how to call the methods of the Person class and access its encapsulated data through the getter and setter methods.

How does encapsulation work?

Encapsulation involves combining data attributes and their associated methods into a cohesive unit, commonly referred to as a class. The structure and behavior of objects that belong to a class are defined by the class, which acts as a blueprint or template. A class’s encapsulation acts as a barrier, keeping outside observers from seeing into its internal workings. It orchestrates access to the class’s inner workings through precisely defined interfaces, maintaining the integrity and security of its data and functionality.

Here’s how encapsulation works in Java:

1. Access Modifiers: In Java, access modifiers are used to control the visibility of class members (fields and methods) from outside the class. The four access modifiers are public, protected, default(package-private), and private.
   • public: Members with this modifier are accessible from any other class.
   • protected: Members with this modifier are accessible within the same package and subclasses (even if they are in a different package).
   • default(package-private): Members with no explicit access modifier are accessible only within the same package.
   • private: Members with this modifier are accessible only within the same class.
2. Private Fields: Encapsulation primarily revolves around the practice of setting class fields (data members) to a private visibility level, ensuring data protection and control. By doing so, these fields are not directly accessible from outside the class, and their values can only be read or modified through methods provided by the class (getter and setter methods).
3. Getter and Setter Methods: Public getter and setter methods, often referred to as accessors and mutators, serve the purpose of offering controlled access to private fields. They grant external code the ability to both retrieve and update the private field values, while also enabling the class to enforce validation rules or other operations as needed.
4. Data Integrity and Validation: By encapsulating the data and providing controlled access through setter methods, the class can ensure that the data adheres to specific rules and constraints. For example, a class might enforce that a certain field can only accept positive integers or that a string field must not be empty.

Encapsulation is essential for maintaining the integrity of the class’s data and protecting it from accidental or unauthorized modifications. It also empowers the class to adapt and modify its internal workings without causing disruptions to the code that relies on the class’s public interface. Users of the class don’t need to know anything about the internal workings of the class; they just need to know how to interact with its public methods.

EWhen it comes to object-oriented programming, encapsulation is similar to the magic ingredient that makes your code stronger, clearer, and less prone to errors. It’s all about tucking away the inner workings of your objects to keep your code tidy and safe. This division of responsibilities protects your code from inadvertent hiccups and bugs while also making it easier to read. In a nutshell, encapsulation is your trusty tool for maintaining well-structured and hassle-free code.

More example:

// Employee is a class 

public class Employee {
        //HERE  id, name, ssn, a are 
        //Class Properties OR Class varible OR
        //Class Attribute OR class field
        
        int id;              //instance variable
        private String name; //instance variable
        private int ssn;     //instance variable  
        //Access Modifier
        
        int a;      //NOT an instance variable
        
        //Q: What is instance Variable?
        //Ans:The class variable which is used during instantiation.
        
        
        
        //Here Private(keyword) is called an Access Modifier
        //Q: What is Access Modifier?
        //Ans: Access Modifier Modify's the   
        //     Visibility and Accessibility of any Data
        
        //Access Modifier GRANT Visibility and Accessibility Privilege
        //Access Modifier REVOKE Visibility and Accessibility Privilege

        //For Private Access Modifier
        //Host Class - has Visibility and Accessibility ONLY
        //Other Class - NO Visibility and Accessibility
        Employee(int id, String name, int ssn) {
                this.id = id;
                this.name = name;
                this.ssn = ssn;
        }
        //this method is called Setters 
        //- which set's any value to a Variable 
        void setSsn(int ssn) {
                this.ssn=ssn;
        }
        //this method is called Getters
        //- which get's any value from a Variable 
        int getSsn() {
                return this.ssn;
        }
        
        void setName(String name) {
                this.name = name;
        }
        
        String getName() {    
                return this.name;
        }
          
}



public class EmployeeDemo {

        
        public static void main(String[] args) {
                
                Employee karim;
                // instantiating karim
                karim = new Employee(1, "Karim", 11111111); 
                
                //replace SSN value
                //karim.ssn =2222222;
                karim.setSsn(22222222);
                
                System.out.println(karim.a);
                
                //here we hide the name of SSN variable successfully 
                //This process is called Encapsulation
                //Q: What is Encapsulation?
                //Ans: Encapsulation is the process of Hiding any Class Member
                //     from Other Classes
                
                int r = karim.getSsn();
                System.out.println("Karim ssn: " + r );
                //karim.name = "Karim Ali";
                karim.setName("Karim Ali");
                System.out.println("Karim Name: " + karim.getName()  );
                //System.out.println("Karim ssn: " + karim.ssn );
                //Req: Hide ssn
                
                Employee maria;
                maria = new Employee(2, "Maria", 55555555);
                maria.setSsn(88888888);
                
                
        }//main


}//class

Output:

Explanation of this code: 

The code you’ve shared defines two Java classes: Employee and EmployeeDemo, which illustrate the concepts of instance variables, access modifiers, encapsulation, and getters and setters. Here’s a breakdown of the code:

1. Employee Class:
   • The Employee class represents an employee and has three instance variables: id, name, and ssn. These variables are private, which means they can only be accessed within the class.
   • a is declared but not used as an instance variable because it lacks the “private” keyword.
   • An instance variable is a class variable that is specific to each instance of the class (each employee in this case).
2. Instance Variables and Access Modifiers:
   • Instance variables are attributes associated with each instance of the class.
   • Access modifiers like private control the visibility and accessibility of class members. Private variables can only be accessed within the same class.
3. Setters and Getters:
   • Setters (e.g., setSsn) are methods used to set the values of private instance variables.
   • Getters (e.g., getSsn) are methods used to retrieve the values of private instance variables.
4. Encapsulation:
   • The code demonstrates encapsulation, which is the practice of hiding the implementation details (in this case, the ssn and name variables) and providing controlled access to the data through methods like setSsn and getSsn.
   • Encapsulation helps maintain data integrity and security by preventing unauthorized access to private variables.
5. EmployeeDemo Class:
   • The EmployeeDemo class is used to demonstrate the Employee class.
   • It creates instances of the Employee class for employees named Karim and Maria.
   • It showcases how to set and get values for their attributes (ssn and name) using setters and getters.
   • It also hides the ssn value from direct access by using the encapsulation concept, ensuring that the ssn variable is not accessible outside the class.

In summary, the code provides a basic example of an Employee class with private instance variables, access modifiers, and encapsulation principles for data security. The EmployeeDemo class demonstrates how to create and interact with Employee objects while adhering to encapsulation practices to protect sensitive information like Social Security Numbers (ssn).

Access Modifiers with a table chart

public class Calculator {
        public int a;
        protected int b;
        private int c;
        int d;
        public Calculator(int a, int b) {
                this.a=a;
                this.b=b;
        }
        
        public int addition(int a, int b) {
                return a+b;
                
        }
        
        private int findSFT(int width, int length) {
                return width*length;
        }
        
        double calculateRent(int width, int length, double rate) {
                return this.findSFT(width, length) * rate;
                
        }
        

}




public class MainCalculator {
        
        public static void main(String[] args) {
                
                Calculator myCal;
                myCal = new Calculator(5, 2);
                
                int result =myCal.addition(5, 2);
                
                System.out.println("Addition result: " + result);
                
                double rent = myCal.calculateRent(10, 20, 5.0);
                System.out.println("Rent is " + rent);
                
                
        }//main

}//class