Understanding Programming Methodologies: A Comprehensive Guide Introduction Programming methodologies define structured approaches to writing code, improving efficiency, maintainability, and scalability. Different methodologies provide distinct ways of thinking about problem-solving, organizing logic, and structuring applications. This blog explores various programming methodologies, their advantages, drawbacks, applications, and best use cases. 1. Procedural Programming Procedural programming follows a step-by-step approach where code is structured as procedures or functions. Characteristics: Based on the concept of procedure calls. Follows a linear, top-down execution model. Uses variables, loops, and control structures. Languages: C, Pascal, Fortran Sample Code (C): #include <stdio.h> void greet() { printf("Hello, World!\n"); } int main() { greet(); return 0; } Applications: Embedded systems (e.g., firmware, microcontrollers) Operating systems (e.g., Li...
Getter and setter methods, also known as accessor and mutator methods, are used to retrieve and modify the values of private variables (fields) in a class. They provide controlled access to the class attributes, allowing encapsulation and maintaining data integrity. Here's an example demonstrating getter and setter methods in Java:
public class Person {
private String name;
private int age;
// Getter method for the name attribute
public String getName() {
return name;
}
// Setter method for the name attribute
public void setName(String name) {
this.name = name;
}
// Getter method for the age attribute
public int getAge() {
return age;
}
// Setter method for the age attribute
public void setAge(int age) {
if (age >= 0 && age <= 120) { // Validate age
this.age = age;
} else {
System.out.println("Invalid age! Age should be between 0 and 120.");
}
}
public static void main(String[] args) {
Person person1 = new Person();
person1.setName("Alice");
person1.setAge(30);
// Retrieve and display the person's name and age
System.out.println("Person 1 - Name: " + person1.getName() + ", Age: " + person1.getAge());
Person person2 = new Person();
person2.setName("Bob");
person2.setAge(-5); // Invalid age
// Retrieve and display the person's name and age
System.out.println("Person 2 - Name: " + person2.getName() + ", Age: " + person2.getAge());
}
}
In this example:
We have a class Person with private attributes name and age.
Getter methods (getName and getAge) are used to access the values of these attributes from outside the class.
Setter methods (setName and setAge) are used to modify the values of these attributes. The setAge method includes validation to ensure that the age is within a valid range.
In the main method, we create two Person objects, set their attributes using setter methods, and retrieve their attributes using getter methods.
_____________________________________
If you're using constructor-based initialization for private attributes, the structure of the class and the way you initialize the attributes will be slightly different. In this approach, you would typically provide a constructor that accepts parameters for initializing the private attributes. Here's how you can modify the Person class to use constructor-based initialization:
public class Person {
private String name;
private int age;
// Constructor with parameters for initializing name and age
public Person(String name, int age) {
this.name = name;
if (age >= 0 && age <= 120) {
this.age = age;
} else {
System.out.println("Invalid age! Age should be between 0 and 120.");
}
}
// Getter method for the name attribute
public String getName() {
return name;
}
// Getter method for the age attribute
public int getAge() {
return age;
}
public static void main(String[] args) {
// Create Person objects using the constructor
Person person1 = new Person("Alice", 30);
Person person2 = new Person("Bob", -5); // Invalid age
// Retrieve and display the person's name and age using getter methods
System.out.println("Person 1 - Name: " + person1.getName() + ", Age: " + person1.getAge());
System.out.println("Person 2 - Name: " + person2.getName() + ", Age: " + person2.getAge());
}
}
In this modified version:
We've removed the setter methods since the attributes are initialized through the constructor and can't be modified afterwards.
The constructor Person(String name, int age) takes parameters name and age, initializes the private attributes name and age accordingly, and performs age validation.
When creating Person objects in the main method, we provide the values for name and age directly as arguments to the constructor.
Comments
Post a Comment