Object-Oriented Programming (OOP)

Object-Oriented Programming (OOP)

• OOP stands for Object-Oriented Programming.
• OOP creates objects that contain both data and methods.
• OOP helps to keep the Java code DRY "Don't Repeat Yourself", and makes the code easier to maintain, modify and debug.
• OOP makes it possible to create full reusable applications with less code and shorter development time.
• The DRY promotes reducing code repetition by extracting common codes and reusing them.

OOP Structure

• Classes are user-defined data types that act as the blueprint for individual objects, attributes and methods.
• Objects correspond to real-world or abstract entities, and are instances of a Class.
• Attributes are defined in the class template and represent the state of an object.
• Methods are functions defined inside a class that describe the behaviors of an object.

Class Creation

• Here is an example of a Class:

Modifier Class Classname {
  //Attributes
  //Object Methods
}

Class Instantiation

• Class instantiation is the process of creating an object using a class.
• Here is an example of instantiation:

Classname Identifier = new Classname(Parameter) {}

Accessing Attributes

• Here is how you access an attribute with writing

Classname Identifier = new Classname(Parameter) {
  //Writing Attributes
  Identifier.Attribute = Value;
}

• Here is how you access an attribute with reading:

Classname Identifier = new Classname(Parameter) {
  //Reading Attributes
  System.out.println(Identifier.attribute);
}

Creating Object Methods

• Here's is an example of an object Method:

Modifier returntype Methodname (Parameter){
  // to do code
}

Calling Object Method

• Here is an example of calling object method

Classname Identifier = new Classname (Parameter)
Identifier.methodname(parameters);

Java Constructors

• A constructor in Java is a special method used to initialize objects.
• The constructor is called when an object of a class is created & can be used to set initial values for object attributes.
• Here is an example of a constructor method:

Modifier classname {
  classname(){
    // constructor
  }
}

Using Constructors

• The code public static void main(String[] args) contains Classname identifier = new Classname (parameters).
• The this keyword refers to the class itself. The this keyword will enables accessing global variables with the same variable names in a parameter.

Packages

• A package in Java is a mechanism to encapsulate a group of classes, sub packages and interfaces.
• Packages prevent naming conflicts and providing controlled access.
• Packages can be considered as data encapsulation or data-hiding since the make searching/locating easier.
• The import keyword is needed to use a class or a package from the library.

Modifiers

• Access modifiers restrict the scope of a class, constructor, variable, method, or data member.
• The public keyword is an access modifier that sets the access level for classes, attributes, methods, and constructors.
• Modifers are divided into two groups: Access Modifiers and Non-Access Modifiers
• Access Modifiers control the access level while Non-Access Modifiers do not control access level, but provide other functionality

Access Modifiers

• Access Modifiers in Java specifies the accessibility or scope of a field, method, constructor, or class & can change the access level.
• For classes, use public, makes the class accessible by any other class, or default, only accessible by classes in the same package( this applied when a modifier is unspecified).
• For attributes, methods and constructors, you can use public, the code is accessible for all classess, private, the code is only accessible within the declared class, default, the code is only accessible in the same package and when you don't specify a modifer, or protected, the code is accessible in the same package and subclasses.

Non-Access Modifiers

• For classes, use final, which means the class cannot be inherited by other classes, or abstract, the class cannot be used to create objects; to access an abstract class, it must be inherited from another class.
• For attributes and methods, can use final, meaning attributes and methods cannot be overridden/modified, static, their attributes and methods belongs to the class, rather than an object, and abstract, can only be used in an abstract class. The method does not have a body, its body is provided by the subclass that inherited from it.