In this post, We will talk and learn about the FlyweightDesign Pattern in Java. Key Points About Flyweight Design Pattern : Flyweight Design Pattern is mainly used to reduce the number of objects created and to decrease memory footprint and increase the performance of the application. This design pattern falls under structural pattern as you… Read More »
In this post, We will talk and learn about the Composite Design Pattern in Java. Key Points About Composite Design Pattern : When we want to create a structure in a way that the objects in the structure have to be treated the same way then we can apply a composite design pattern. We can… Read More »
In this post, We will talk and learn about the Proxy Design Pattern in Java. Key Points About Proxy Design Pattern : The Proxy pattern helps us to create an intermediary that acts as an interface to another resource and also hiding the underlying complexity of the application. Proxy means ‘in place of’, representing’ or ‘on… Read More »
In this post, We will talk and learn about the Facade Design Pattern in Java. Facade design pattern is used to help the client applications; it doesn’t hide subsystem interfaces from the client. Whether to use Facade or not is completely dependent on the client application. We can apply Facade design pattern at any point… Read More »
In this post, We will talk and learn about the Decorator Design Pattern in Java. Decorator design pattern comes under structural design patterns. Decorator design pattern is used to modify the functionality of an object at runtime. At the same time, other instances of the same class will not be affected by this, so individual object gets… Read More »
In this post, We will talk and learn about the Adapter Design Pattern in Java. The Adapter design pattern falls one under structural design pattern It is used so that two unrelated interfaces can work together. The object that joins these unrelated interfaces is called an Adapter. Adapter Design Pattern Example in JDK : java.io.InputStreamReader(InputStream) java.io.OutputStreamWriter(OutputStream) javax.xml.bind.annotation.adapters.XmlAdapter#marshal() and #unmarshal()… Read More »
In this post, We will talk and learn about the Builder Pattern in Java. There are mainly three major problems with Factory and Abstract Factory design patterns when the Object contains a lot of attributes. We have to pass too many arguments from the client program to the Factory class that can be error-prone because most… Read More »
In this post, We will talk and learn about the Abstract Factory Pattern in Java. Abstract Factory pattern is almost similar to Factory Pattern except for the fact that it’s more like a factory of factories. Abstract factory pattern we can consider as another layer of abstraction over factory pattern. Whenever you need another level of abstraction over a group of… Read More »
In this post, We will talk and learn about the Factory design pattern in java. Factory pattern comes under a creational design pattern. It is one of the most used design patterns in Java. Using this design pattern we can create an object without exposing the object creation logic to the client and refer to the… Read More »
In this post, We will talk and learn about Prototype Pattern in Java. Prototype comes under a creational design pattern that makes use of cloning objects if object creation complex and time-consuming. Below is the complete source code: Student.java Model class
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
package com.kkjavatutorials.prototype; /** * * @author KK JavaTutorials *Model class */ public class Student { private Integer id; private String name; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "Student [Student id=" + id + ", Student name=" + name + "]"; } } |
StudentDAO.java creates Cloned Object that makes use of Prototype Pattern:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
package com.kkjavatutorials.prototype; import java.util.ArrayList; import java.util.List; /** * @author KK JavaTutorials * Dummy Student DAO implementation * In Real Scenario Object can be constructed by calling database. */ public class StudentDAO implements Cloneable{ private static List<Student> studentList; static { studentList = new ArrayList<>(); Student student1 = new Student(); student1.setId(10); student1.setName("PK"); Student student2 = new Student(); student2.setId(20); student2.setName("MK"); studentList.add(student1); studentList.add(student2); } /** * In Real Scenario Object can be constructed by calling database. * @return Student List */ public List<Student> getAllStudents(){ return studentList; } /** * Creating Clone of an Existing object */ @Override public List<Student> clone() throws CloneNotSupportedException { List<Student> dummyStudentList = new ArrayList<>(); for (Student student : studentList) { dummyStudentList.add(student); } return dummyStudentList; } } |
Test.java Client Program:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
package com.kkjavatutorials.prototype.client; import java.util.List; import com.kkjavatutorials.prototype.Student; import com.kkjavatutorials.prototype.StudentDAO; /** * @author KK JavaTutorials *Client Program which uses cloned object */ public class Test { public static void main(String[] args) throws CloneNotSupportedException { StudentDAO studentDAO = new StudentDAO(); //Getting Original copy of student list List<Student> allStudents = studentDAO.getAllStudents(); //Getting clone copy of student list List<Student> updatedStudentList = studentDAO.clone(); Student student = new Student(); student.setId(30); student.setName("SK"); //Doing manipulation on cloned copy updatedStudentList.add(student); System.out.println("Original Student List::"); allStudents.forEach(System.out::println); System.out.println("Updated Student List::"); updatedStudentList.forEach(System.out::println); } } |
Output… Read More »