ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગ ચાર મૂળ સિદ્ધાંતો પર આધારિત છે — Encapsulation, Inheritance, Polymorphism, અને Abstraction. Java આ આસપાસ બનાવવામાં આવ્યો છે, અને તેમને સમજવું Java પ્રોગ્રામ્સ ડિજાઇન કરવા માટે મૌલિક છે.
{
balance;
{
(amount > ) balance += amount;
}
{ balance; }
}
Encapsulation આંતરિક સ્થિતિ (private) ને છુપાવે છે અને નિયંત્રિત વહેંચણી (જાહેર પદ્ધતિ/getters/setters) આવશ્યક કરે છે. આ અપરિવર્તનીયતા સુરક્ષિત કરે છે — તમે સીધું નકારાત્મક બેલેન્સ સેટ કરી શકતા નથી — અને તમને આંતરિક બદલી શકવા દે છે કોલર્સને તોડ્યા વિના.
class Animal {
void eat() { System.out.println("eating"); }
}
class Dog extends Animal { // Dog IS-A Animal — inherits eat()
void bark() { System.out.println("woof"); }
}
Inheritance સબક્લાસને સુપરક્લાસના વર્તનને ફરીથી વાપરી શકે છે અને વિસ્તૃત કરી શકે છે, "is-a" સંબંધોને મોડલ કરે છે અને કોડ ડુપ્લિકેશન ટાળે છે.
Animal a = new Dog(); // a Dog treated as an Animal
a.makeSound(); // calls Dog's overridden version at RUNTIME (dynamic dispatch)
// the same method behaves differently depending on the actual object:
List<Animal> animals = List.of(new Dog(), new Cat());
for (Animal animal : animals) animal.makeSound(); // each makes its own sound
Polymorphism તમને સામાન્ય પ્રકાર દ્વારા વિવિધ સબક્લાસેસને સમાન રીતે કાર્ય કરવા દે છે, વાસ્તવિક ઑબ્જેક્ટની overridden પદ્ધતિ રનટાઇમ પર બોલાવવામાં આવે છે — લવચીક, વિસ્તૃત કોડ સક્ષમ કરે છે.
interface PaymentProcessor {
void pay(double amount); // WHAT it does, not HOW
}
class StripeProcessor implements PaymentProcessor {
public void pay(double amount) { /* complex implementation hidden */ }
}
// callers depend on the abstraction, not the concrete implementation
PaymentProcessor processor = new StripeProcessor();
Abstraction (ઈન્ટરફેસ/અમૂર્ત વર્ગો દ્વારા) સરળ અનુબંધ પ્રકાશિત કરે છે જ્યારે જટીલ અમલીકરણ છુપાવે છે — તમને અમલીકરણો સ્વેપ કરવા અને coupling ઘટાવવા દે છે.
ચાર સ્તંભ ઑબ્જેક્ટ-ઓરિએન્ટેડ ડિજાઇન અને Java નું પાયા છે.
Encapsulation ડેટા અખંડતા રક્ષણ કરે છે અને સુરક્ષિત પરિવર્તન સક્ષમ કરે છે; Inheritance પુનઃવહેંચણીને પ્રોત્સાહિત કરે છે; Polymorphism લવચીકતા અને વિસ્તારણશીલતા પ્રદાન કરે છે (ઘણા પ્રકારો સમાન રીતે કાર્ય કરો, વર્તન રનટાઇમ પર ઠરાવવામાં આવે છે); Abstraction coupling અને જટિલતા ઘટાવે છે.
તેમને સમજવું માત્ર પરિભાષા નથી — તે તમારે કક્ષાઓ કેવી રીતે રચવી, APIs કેવી રીતે ડિજાઇન કરવી, અને જાળવણીયોગ્ય, વિસ્તૃત સિસ્ટમ્સ બનાવવી તે માર્ગદર્શન આપે છે.
તે પણ સૌથી સામાન્ય મુલાકાત વિષયોમાંનો છે કારણ કે તે વણસે છે કે શું એક વિકાસક કર્તા યોગ્ય OOP શરતોમાં વિચાર કરે છે, જે Java ના વર્ગ-કેન્દ્રિત ઇકોસિસ્ટમમાં અસરકારક રીતે કાર્ય કરવા માટે આવશ્યક છે.