Add composition to Other concepts along with an example in Java

Author: olgierdg

Composition in Java.txt

@@ -0,0 +1,46 @@
+Composition in Java is achieved by using instance variables that refer to other objects. For example, a Person class can have a Job instance variable which refers to their actual job, in this case Developer.
+
+First we define Job as an interface, for polymorphism:
+
+public interface Job {
+    public String getRole();
+    public void setRole(String role);
+    public long getSalary();
+    public void setSalary(long salary);
+}
+
+Then we define the Developer Job:
+
+public class DeveloperJob implements Job {
+    private String role = "Developer";
+    private long salary = 1000;
+
+    public String getRole() {
+        return role;
+    }
+    public void setRole(String role) {
+        this.role = role;
+    }
+    public long getSalary() {
+        return salary;
+    }
+    public void setSalary(long salary) {
+        this.salary = salary;
+    }
+}
+
+Finally we can use composition in the Person class:
+
+public class Person {
+    //composition - has-a relationship
+    private Job job;
+
+    public Person(){
+        this.job=new DeveloperJob();
+    }
+    public long getSalary() {
+        return job.getSalary();
+    }
+}
+
+The composed Job could easily be replaced by some other one, and the salary will be returned polymorphically.

Other_concepts.md

@@ -3,3 +3,5 @@ Data Abstraction - Data Abstraction is the process of providing only the essenti
 Encapsulation - The property of wrapping up data values and functions into a single unit, such that all of them are related to each other and serve a common functionality. It is implemented in OOP through class. Thus, class forms a blueprint and wraps up various related functions and data values.
 
 Polymorphism - The property of a function to exhibit different behaviour under different circumstances is called Polymorphism. It is usually implemented through function overloading. Suchh functions, having the same name, behave differently when different parameters are passed to it.
+
+Composition - The principle that classes should achieve polymorphic behavior and code reuse by their composition (by containing instances of other classes that implement the desired functionality) rather than inheritance from a base or parent class. To favor composition over inheritance is a design principle that gives the design higher flexibility - it is better to compose what an object can do (HAS-A) than extend what it is (IS-A).