D.2 - Features of OOP

Encapsulation

• Encapsulation is the technique of making the states in a class private and providing access to those states via public behaviors (methods).

• Data and actions are limited to the object in which they are created.

  • It is a form of data hiding. If a state is declared private it cannot be accessed by any method outside the class.

Inheritance

• A process whereby one object inherits the properties of another object (called super / sub or parent / child classes).

• This is called an “is-a” relationship.

• In java you can only inherit from one class at a time.

Keyword Inheritance

• The keyword used is extends.

• In programming inheritance is implemented by using the keyword extends in the subclass to connect it to its super class.

Polymorphism

• It means that two methods can have the same name but different contents / functions.

  • Methods have the same name but different parameter lists and processes.

Types of Polymorphism

• Overloading

• Overriding

Overloading

• The same class

• Allows different methods to have the same name, but different signatures where signature can differ by the number of input parameters or type of input parameters or both.

Overriding

• Different classes / inheritance

• Allows a subclass to provide a specific implementation of a method that is already provided by one of its super classes.

• When a method in a subclass has the same name, same parameters, or signature, and same return type as a method in its super-class then the method in the subclass overrides the method in the superclass.

Overloading versus Overriding

• Overloading is about the same function having different signatures (usually in the same class).

• Overriding is about the same function, same signature, but different classes connected through inheritance.

Advantages of Encapsulation

• Data hiding

• Reusability

• Testing code ease

• Increased flexibility

Data Hiding

• The user will have no idea about the inner implementation of the class (implies security)

• It will not be visible to the user how the class is storing values in the variables.

• They only know that we are passing the values to a setter method and variables are getting initialized with that value.

Reusability (Encapsulation)

• Encapsulation also improves the reusability of the code (write once / use many times)

• Methods can be copied to different / new classes and help meet new requirements.

Ease of testing code (Encapsulation)

• Encapsulated code is easy to test with unit testing (a type of automated testing that tests many different types of data quickly)

• It is easier to fix larger problems if you know which method is returning the wrong response.

Increased Flexibility (Encapsulation)

• We can make the variables of the class as read-only or write-only depending on our requirement

• If we wish to make the variables as read-only then we can omit the setter methods

• Or if we wish to make the variables as write-only then we have to omit the get methods.

Advantages of Inheritance

• Minimizes the amount of duplicate code

  • Common code becomes the superclass

• Organizes code better

  • Using a superclass has better abstraction

• Makes code more flexible to change

  • Can make application code more flexible to change as classes that inherit from a common super class can be used interchangeably.

• a parent object holds common data and actions, which enhances reuse and reduces maintenance overheads

Advantages of Polymorphism

• Overriding

  • It allows a general class to specify methods that will be common to all of its derivatives while allowing sub classes to define the specific implementation of some or all of those methods.

  • One interface, multiple methods - overridden methods

  • Allow you to call methods of any of the derived classes without even knowing the type of derived class object.

• Overloading

  • Do not need different names for functions doing the same thing

Advantages of Libraries of Objects

• Time saving:

  • Sorting algorithms do not have to be re-invented

  • Complex algorithms and processes can be reused

Libraries of Objects

• JUnit (64% of top Java projects)

  • Testing framework for java programs

• SLF4J 22%

  • Allow the end-user to plug-in the desired logging system

• Log4j 16.76%

  • A tool to help the programmer output log statements to a variety of output targets

• Google Guava 15.6%

  • Common libraries for Java, mainly developed by Google engineers.

• Apache-commons 12.63%

  • Commons proper is dedicated to one goal: create and maintain reusable Java components.

Disadvantages of OOP

• Increased complexity of small problems

  • OOP typically involves more lines of code than procedural programs.

  • OOP are typically slower than procedure-based programs, as they typically require more instructions to be executed.

• Unsuited to particular classes of problems

  • Programs may lend themselves well to functional-programming style, logic-programming style, or procedural-based programming, and using object oriented will not create efficient programs.

  • Problems that tend to be small and involve only one data source.

Programming Teams Advantages

• Speed of completion (concurrent working)

• Information hiding to reduce module dependencies

  • Developers only need to know the name and required parameters to use a behavior, they can use code without needing to understand how it functions

  • Security benefit as coders do not have access to the actual data themselves

• Expertise in a narrow field

  • Assembling a complex project requires many different skills.

  • By allowing each part of the program to be programmed by an expert in that field, the quality of the final product is higher than one by a jack of all trades.

Programming Teams Disadvantage

You need a common language to resolve problems

Advantages of Modularity

• Easier debugging and testing

  • By having smaller modules to test, it is easier to find and fix bugs

  • The number of tests that have to be run to confirm a module is fully operational is reduced according to the number of functions in a particular module.

• Speedier completion

  • By breaking the project into smaller modules, you could save time by finding modules that already exist in libraries that do the function you are looking for

  • By splitting the task into different modules, each module can be worked on concurrently (except for particular circumstances) thus leading to a speedier completion of the overall project

• Code blocks are reusable

  • Some problems / functions are very common and possibly occur in multiple different programs (for example the need to make a text box or a clickable button to start a task)

  • By resusing blocks of code, the development time is slashed and the project is completed sooner.