Object-oriented programming (OOP) is a programming paradigm that is based on the concept of “objects”, which can contain data and code that manipulates that data. In Android, Java is the primary programming language used for developing Android apps. Java is an object-oriented language and it provides several features that support OOP, such as classes, objects, inheritance, and polymorphism.
Therefore, when developing Android apps, you will use OOP concepts such as classes, objects, inheritance, and polymorphism to organize and structure your code. The Android SDK also provides a set of pre-built classes and interfaces that you can use to create your app, such as the Activity and View classes. These classes and interfaces are organized into a package hierarchy, which is the core structure of the Android app.
The main idea behind OOP is to create real-world objects and then create a software representation of these objects. This allows developers to create complex and large-scale software systems in a more organized and manageable way.
1. Class
A class is a template that defines the properties and behavior of an object. In Android, classes are used to define the structure and behavior of the various components that make up an app, such as the Activity, Service, Broadcast Receiver, and Content Provider classes. Each class has its own properties, methods, and events that are used to define its behavior.
Example: The Activity class is used to create an activity, which is a single, focused task that a user can perform. For example, you can create a class called “MainActivity” that extends the Activity class, and this class will define the layout and behavior of the main screen of your app.
2. Object
An object is an instance of a class. In Android, objects are used to represent the various components of an app, such as the Activity, Service, Broadcast Receiver, and Content Provider objects. The properties of an object are defined by the class it is an instance of. Objects can also have their own unique properties, which are called instance variables.
Example: An object of the MainActivity class can be created and used to represent the main screen of the app. For example, you can create an object called “mainActivity” of the MainActivity class, and use it to start the main screen of the app.
3. Inheritance
Inheritance is a mechanism that allows one class to inherit the properties and behavior of another class. This allows developers to create a hierarchy of classes, where a subclass inherits the properties and behavior of its superclass. In Android, classes such as Activity and Service are subclasses of the ContextWrapper class, which provides the basic context for all Android components.
Example: The Service class is a subclass of the ContextWrapper class, which provides the basic context for all Android components. This allows the Service class to inherit the properties and behavior of the ContextWrapper class, such as the ability to access resources and manage the lifecycle of the service.
4. Polymorphism
Polymorphism is a mechanism that allows objects of different classes to be treated as objects of a common superclass. This allows developers to create code that can work with objects of different classes in a generic way. In Android, the View class is an example of polymorphism, as it can be used to create different types of views such as TextView, Button, and ImageView.
Example: The View class is an example of polymorphism, as it can be used to create different types of views such as TextView, Button, and ImageView. These classes are subclasses of the View class, and they inherit its properties and behavior, but can also have their own unique properties and methods.
5. Encapsulation
The benefit of using OOP in Android is the ability to encapsulate data and behavior. Encapsulation is the process of hiding the internal details of a class or object from other parts of the code. This allows developers to create code that is more modular and easier to maintain, as changes to the internal details of a class or object do not affect the rest of the code.
Example: When building a data model, it is common to use classes to encapsulate data and behavior. For example, you can create a class called “Person” which has properties like name, age, and address, and methods like setName() and getName(). By encapsulating the data and behavior in a class, it becomes easy to manage and reuse the data model throughout the app.
6. Reusability
One of the key benefits of using OOP in Android is the ability to reuse code. Classes and objects can be used as building blocks for creating different parts of an app, and by using inheritance and polymorphism, developers can create new classes and objects that inherit the properties and behavior of existing classes and objects. This makes it easier to create and maintain large and complex software systems.
Example: You can create a custom class called “Validations” that has methods for performing different types of validations such as email validation, phone number validation, etc. and this class can be reused throughout the app for input validation in different parts of the app.
7. Maintainability
OOP in Android also encourages code reusability and maintainability. By breaking down the code into smaller, more manageable chunks, it becomes easier to debug, maintain and update. OOP also allows for better code organization and improves readability.
Example: By breaking down the code into smaller, more manageable chunks, it becomes easier to debug, maintain and update. For example, you can create classes for managing different types of data such as “UserDataManager” and “ProductDataManager” which will handle all data-related operations for users and products respectively, making it easier to maintain and update the code.
Example of how these OOPs concepts can be used in an Android Application using Java and Kotlin
Kotlin
// A class called "Shape" which // will act as a super class open class Shape(var area: Double) { open fun calculateArea() { println("Area of the shape is: $area") }} // A class called "Rectangle" which will act // as a subclass and inherit from "Shape" classclass Rectangle(length: Double, width: Double) : Shape(length * width) { var length: Double = length var width: Double = width} // A class called "Circle" which will act as// a subclass and inherit from "Shape" classclass Circle(radius: Double) : Shape(Math.PI * Math.pow(radius, 2.0)) { var radius: Double = radius} // A class called "TestShapes" // which will use polymorphismfun main() { val s1 = Rectangle(5.0, 10.0) val s2 = Circle(5.0) s1.calculateArea() s2.calculateArea()} |
Java
// A class called "Shape" which // will act as a super class public class Shape { private double area; public Shape(double area) { this.area = area; } public double getArea() { return area; } public void setArea(double area) { this.area = area; } public void calculateArea() { System.out.println("Area of the shape is: " + getArea()); }} // A class called "Rectangle" which will act // as a subclass and inherit from "Shape" classpublic class Rectangle extends Shape { private double length; private double width; public Rectangle(double length, double width) { super(length * width); this.length = length; this.width = width; } public double getLength() { return length; } public double getWidth() { return width; } public void setLength(double length) { this.length = length; } public void setWidth(double width) { this.width = width; }} // A class called "Circle" which will act// as a subclass and inherit from "Shape" classpublic class Circle extends Shape { private double radius; public Circle(double radius) { super(Math.PI * Math.pow(radius, 2)); this.radius = radius; } public double getRadius() { return radius; } public void setRadius(double radius) { this.radius = radius; }} // A class called "TestShapes" // which will use polymorphismpublic class TestShapes { public static void main(String[] args) { Shape s1 = new Rectangle(5, 10); Shape s2 = new Circle(5); s1.calculateArea(); s2.calculateArea(); }} |
In this example,
- The Shape class acts as the parent class or superclass, with two subclasses Rectangle and Circle inheriting from it. The Rectangle and Circle classes have their own properties and methods but also have access to the properties and methods of the Shape class through inheritance.
- The TestShapes class uses polymorphism by creating objects of the Rectangle and Circle classes and assigning them to variables of the Shape class. This allows for the same method calculateArea() to be called on both objects, even though they are of different classes because they both inherit from the same Shape class.
- This example also illustrates encapsulation as the properties of the Shape, Rectangle, and Circle classes are kept private and are accessed using getter and setter methods. This way the code is organized, maintainable and flexible.
Both the Java and Kotlin code examples show the same concepts of classes, objects, inheritance, polymorphism, and encapsulation, but Kotlin is more concise and less verbose than Java.
