SOLID PRINCIPLES PART - 2:
In this post we were going to cover remaining 2 principles:
<h3>4. Interface Segregation Principle (ISP)</h3>
Definition: No client should be forced to depend on methods it does not use. This means that interfaces should be specific to the clients that use them.
Example:
<pre><code class="language-java">// Violating ISP
interface Worker {
 void work();
 void eat();
}

class Robot implements Worker {
 public void work() {
 System.out.println(&quot;Robot working...&quot;);
 }

 public void eat() {
 throw new UnsupportedOperationException(&quot;Robot does not eat&quot;);
 }
}

// Following ISP
interface Workable {
 void work();
}

interface Eatable {
 void eat();
}

class Robot implements Workable {
 public void work() {
 System.out.println(&quot;Robot working...&quot;);
 }
}

class Human implements Workable, Eatable {
 public void work() {
 System.out.println(&quot;Human working...&quot;);
 }

 public void eat() {
 System.out.println(&quot;Human eating...&quot;);
 }
}
</code></pre>
<h3>5. Dependency Inversion Principle (DIP)</h3>
Definition: High-level modules should not depend on low-level modules. Both should depend on abstractions. This means that the details should depend on abstractions, not the other way around.
Example:
<pre><code class="language-java">// Violating DIP
class LightBulb {
 public void turnOn() {
 System.out.println(&quot;LightBulb turned on&quot;);
 }
}

class Switch {
 private LightBulb lightBulb;

 public Switch(LightBulb lightBulb) {
 this.lightBulb = lightBulb;
 }

 public void operate() {
 lightBulb.turnOn();
 }
}

// Following DIP
interface Switchable {
 void turnOn();
}

class LightBulb implements Switchable {
 public void turnOn() {
 System.out.println(&quot;LightBulb turned on&quot;);
 }
}

class Switch {
 private Switchable device;

 public Switch(Switchable device) {
 this.device = device;
 }

 public void operate() {
 device.turnOn();
 }
}
</code></pre>
<h3>Conclusion</h3>
By applying the SOLID principles, you can enhance the structure and maintainability of your Java applications. Each principle is designed to promote cleaner code, making it easier to adapt and extend your systems over time.
Let’s meet tomorrow with a new topic 🤗

All Java, All the time.

Newcomers to veterans, all are welcome to post and comment about anything Java related. Love it, hate it - all topics are safe here. 

Just Java

The post discusses two SOLID principles: Interface Segregation Principle (ISP) and Dependency Inversion Principle (DIP). ISP states that no client should be forced to depend on methods it does not use, demonstrated using Java examples. DIP indicates that high-level modules should not depend on low-level modules but rather on abstractions, illustrated similarly with Java code. Applying these principles can enhance the structure and maintainability of Java applications.

Are SOLID Principles worth the hype ? 🤔(PART - 2)