Methods are an integral part of object-oriented programming (OOP). In OOP, classes are used to create objects that contain data and behavior. Methods define the behaviors and actions that an object can perform.
On LinkedIn, which utilizes OOP extensively, methods play an important role in enabling the various features and functionality of the platform. LinkedIn is built using languages like Java, Python, and JavaScript, which support OOP principles.
In this article, we’ll provide an overview of methods in OOP and examine how LinkedIn leverages methods to power key features like profiles, jobs, messaging, and more.
What are Methods in OOP?
Methods are functions that are defined as part of a class. They describe the behaviors and actions that an object created from that class can perform.
Here are some key characteristics of methods in OOP:
- Methods are defined within a class.
- They are associated with an object instance of that class.
- Methods can access and modify the state of an object (its attributes).
- They define the behaviors and actions that the object can perform.
- Methods may or may not return a value.
- They can accept parameters and arguments.
For example, a Person class may have methods like walk(), talk(), and eat() that define actions a Person can do. A LinkedIn profile object would have methods like addExperience(), getProfileViews() etc.
Why are Methods Important in OOP?
Here are some reasons why methods are essential in OOP:
- Methods help encapsulate logic and functionality in a class.
- They enable code reuse since methods defined in a class can be used by any instance of that class.
- Methods allow objects to interact with each other via method calls.
- They help divide responsibilities between classes so each class handles its own actions.
- Methods support polymorphism which allows subclasses to override parent methods.
- Grouping methods with data in a class leads to modular and organized code.
Without methods, classes would just contain data/state but no functionality. Methods bring the objects to life by enabling their behaviors.
Common Types of Methods in OOP
There are several common classifications of methods in OOP:
1. Accessor Methods
These are used to access the attributes of an object. They don’t modify the state but simply return the value of an attribute.
For example:
public int getAge() { return age; }
2. Mutator Methods
Mutator methods modify the state of an object by changing the value of its attributes. They may return a value or be void.
For example:
public void setAge(int newAge) { age = newAge; }
3. Constructor Methods
Constructor methods are used to initialize new objects. They have the same name as the class and no return type.
For example:
public Person(String name) { this.name = name; }
4. Static Methods
Static methods can be called directly on the class without needing an instance of the class. They cannot access non-static attributes and methods.
For example:
public static calculateAverage(int[] numbers) { // calculate and return average }
Methods in LinkedIn’s Codebase
Now that we’ve covered the basics of methods in OOP, let’s see how LinkedIn makes extensive use of methods within its codebase:
Profile Methods
The LinkedIn Profile is one of the core entities within LinkedIn’s architecture. The Profile object would have methods like:
- getWorkExperience() – returns work experience
- addSkill(String skill) – adds a new skill
- removeRecommendation(Recommendation r) – removes a recommendation
- getLastName() – returns last name
These methods enable creating, updating, and working with Profile objects.
Job Methods
Similarly, the Job object has methods like:
- getDescription() – returns job description
- setSalaryRange(int min, int max) – sets salary range
- isActive() – returns if job is active
- apply(Profile p) – a profile applies to a job
Messaging Methods
The Messaging modules would have methods like:
- sendMessage(Message m) – sends a message
- receiveMessage(Message m) – receives a new message
- createChat(Participants p) – creates a new chat
- deleteChat(Chat c) – deletes a chat
Connection Methods
The networking related classes would expose methods like:
- sendConnectionRequest(Profile p) – sends a connection request
- acceptConnection(Profile p) – accepts a connection
- removeConnection(Profile p) – removes a connection
- getConnectionsCount() – gets total connections
Notification Methods
Notification related methods:
- sendNotification(Notification n) – sends a notification
- markNotificationRead(Notification n) – marks notification as read
- getUnreadCount() – gets count of unread notifications
Benefits of Using Methods on LinkedIn
Let’s summarize some of the key benefits LinkedIn derives from using methods in its OO codebase:
- Methods enable the encapsulation of complex logic and functionality behind clean interfaces.
- LinkedIn leverages inheritance and polymorphism via methods effectively. Child classes can override parent methods.
- Methods allow for modular and organized code by dividing responsibilities across classes.
- By grouping related data and methods together in a class, LinkedIn improves maintainability of its codebase.
- Methods can be called from anywhere in the codebase which improves reusability.
- Public methods enable different LinkedIn modules to communicate with each other programmatically.
- Static helper methods reduce duplication of common logic across the codebase.
- Overall, methods enable LinkedIn to build a complex application in an scalable and extensible manner.
Conclusion
Methods are a fundamental building block in object-oriented programming. LinkedIn relies extensively on methods to enable profiles, jobs, messaging, notifications and other core features.
Methods encapsulate logic, enable polymorphism and inheritance, improve organization and reuse, and allow objects to communicate. By mastering methods in OOP, LinkedIn has been able to create a robust, scalable platform that serves millions of users globally.
Understanding how methods work is key for any programmer building large-scale OOP software. LinkedIn provides an excellent case study of OOP and methods done right at massive scale.