When it comes to solving common issues occurring in software development,

like redundant functions, reusable patterns, repetitive code, etc., design

patterns are used effectively. These are reusable template solutions that are
much similar to customizable blueprints.

The concept of design patterns was first mentioned by Christopher

Alexander. Later, it was picked up by four authors - Richard Helm, Ralph
Johnson, John Vlissides, and Enrich Gamma - known as the Gang of Four.

With design patterns, you get to easily solve commonly recurring issues
without investing a lot of time and effort into the same. So, if your job entails
this process and you have an interview in tow, this post covers the latest
design patterns interview questions that you can refer to for preparation.

We have categorized Design Patterns Interview Questions - 2023 (Updated)

into 2 levels they are:

 Freshers

 Experienced

Top 10 Frequently Asked Design Patterns Interview Questions

1. Define Design Patterns.

2. Define the design patterns in Java.

3. What do you mean by SOLID principles?

4. What is the difference between design patterns and design

principles?

5. Define Bridge Design Pattern.

6. What do you mean by inversion of control?

7. Define a Factory Design Pattern.

8. What is the Adapter Design Pattern?

9. What do you mean by Decorator Design Pattern?

10. What problems does the Builder Pattern solve?

Do you want to enhance your skills and build your career in this Core Java domain? Then e
 " Core Java Training " this course will help you to achieve excellence in this domain.

Design Patterns Interview Questions and Answers For Freshers

If you are just starting out in this domain, these design patterns interview questions
for freshers will be helpful in your preparation.

1. Define Design Patterns.

Design patterns are known as reusable solutions that help solve commonly
recurring issues of software development. Some of these issues are
redundant logic and functions, repetitive code, and more. These patterns
help save a significant amount of time and effort needed when developing
software. Also, these patterns are used commonly in object-oriented software
products.

2. Can you list some benefits of design patterns?

As mentioned above, these design patterns are flexible enough to identify

unwanted repetitive code. With this, the software’s architecture can be
customized accordingly. Thus, some of the benefits of design patterns
include:

 Reusable and can be used in varying projects

  Well-tested and effective methods of developing significant solutions
 Offer template solutions to define system architecture
 Provide utmost transparency to software design

3. How can a design pattern be described?

To describe a design pattern, the below-mentioned things are generally

followed:

 Define the name of the pattern and the classification of the design
pattern under which it will fall
 Define an issue and the corresponding solution
 Finding the variations and language-dependent alternatives for the
issue that has to be addressed
 Defining the real-time use cases along with the software’s efficiency.

4. Define the design patterns in Java.

In Java, there are three varying types of design patterns, such as:

 Creational Patterns: They offer freedom of choice between the

creation of objects by concealing the logic. The constructed objects are

 decoupled from the implemented system. Some of the examples of this

type include abstract factory design, singleton design, prototype

design, builder design, and factory design pattern.

 Behavioral Patterns: These patterns help define how the objects

should be communicating and interacting with each other. Strategy

pattern, observer patterns, iterator pattern, and command pattern are

some examples of behavioral patterns.

 Structural Patterns: These patterns assist in defining how the

structures of objects and classes should look like for defining the

composition between objects, interfaces, and classes. Some examples

are proxy design, decorator design, facade design, adaptor design, and

more.

Check out Core Java Interview Questions and Answers that help you grab high-p
jobs.

5. What do you mean by Gang of Four (GOF) in design patterns?

Gang of Four (GOF) is used for four authors who invented the concept of
design patterns. They are John Vlissides, Richard Hel, Ralph Johnson, and
Erich Gamma. They documented the design patterns in the book named
“Design Patterns: Elements of Reusable Object-Oriented Software”, which
was published in 1995.

6. What do you mean by SOLID principles?

Introduced by Robert C. Martin in 2000 in his paperwork called “Design
Principles and Design Patterns”, SOLID principles are the object-oriented
principles. The SOLID acronym goes:

 S stands for Single Responsibility Principle (SRP): This

principle makes sure that every module or class should be responsible

for one functionality. And, there should be only one reason to change

any class.

 O stands for Open-Closed Principle (OCP): It says that every

class is open for extension and closed for modification. Here, you can

extend the behavior of entities by not altering anything available in the

existing source code.

 L stands for Liskov Substitution Principle (LSP): The LSP

principle talks about objects that can be replaced by subtype instances

without impacting the program’s correctness.

  I stands for Interface Segregation Principle (ISP): This one

concentrates on the use of as many interfaces specific to the

requirements of the client as possible rather than creating a general

interface. Herein, clients should not be compelled to integrate the

functionalities that they don’t need.

 D stands for Dependency Inversion Principle: Under this

principle, the high-level modules shouldn’t be dependent on the

concrete implementations or the lower level modules. Rather, they

should stay dependent on the abstractions.

7. Define some design patterns used in the JDK library of Java.

Some of the design patterns used in the JDK library of Java are:

 Decorator pattern used by the Wrapper classes

 Observer pattern used to handle event frameworks, like swing, AWT,
etc.
 Singleton pattern used in classes, like runtime and calendar
 Factory pattern used for methods, like Integer.valueOf methods, etc.

8. What is the difference between design patterns and design principles?

Design patterns are known as the reusable template solutions used for
common issues that can be customized as per the requirements. These can
be implemented efficiently, are safe to use and can be tested properly.

On the other hand, design principles are followed when designing software
systems for any sort of platform by using a programming language. The
SOLID principles are the design principles that are followed as guidelines to
develop extensive, scalable, and robust software systems. These principles
can be applied to every aspect of programming.

Related Article: Low level Design Interview Questions

9. What is the difference between design patterns and algorithms?

Design patterns and algorithms are used to describe typical solutions to a

problem. However, the primary difference between these two is that a design
pattern offers a high-level description of solutions, and algorithms outline a
set of actions to achieve a goal.
10. Define Bridge Design Pattern.

The bridge pattern is a structural design pattern type that allows you to split
closely related classes or large classes into two hierarchies - implementation
and abstraction. These two are independent of one another and can be used
whenever you wish to decouple an abstraction from implementation.

This is known as a bridge pattern as it acts as a bridge between the

implementation class and an abstract class. In this pattern, these classes can
be modified or altered independently without impacting one another.

There are four primary elements of bridge pattern, such as:

 Abstraction: This is the code and defines the crux of the pattern. It

comprises a reference to the implementer.

 Refined Abstraction: This is an extension to the abstraction and

takes details of the requirements while hiding them from the

implementers.
  Implementer: This is referred to as the implementation classes’

interface.

 Concrete Implementation: This one is the concrete implementation

class that integrates the interface of the implementer.

Design Patterns Interview Questions and Answers For Experienced

If you are a professional and have spent years working in this domain, these
design patterns interview questions for professionals will help you prepare
thoroughly.

11. What do you mean by inversion of control?

Inversion of Control (IoC) is one such pattern that is used to decouple the
dependencies between the system’s components and layers. The
Dependency-Injection (DI) pattern is one such example of this IoC pattern
that assists in eradicating the dependencies in the entire code.

Let’s dive deeper with an example. Suppose we have a class Y that uses class
Z as:

public class Y{
private Z z;
public Y ( ) {
this.z = new Z ( ) ;
}
}

Here, we get a dependency between the Y and Z classes. If the IoC pattern
was implemented, the new operator wouldn’t have been used to assign value
to the dependent variable. And then, it would have been:

public class Y {
private IocZ z;
public Y (IocZ z) {
 this.z = z;
}
}

The control of managing the dependency of instantiating the object of class Z

to the IoC class IocZ has been inverted.

12. Define a Factory Design Pattern.

Factory design pattern comes under the Creational Design Patterns category.
Herein, the objects get created without exposing the creation logic to the
client. The objects are referred to the common interface.

To understand better, let’s consider an example:

Suppose there are three classes - Square, Rectangle, and Triangle. Let’s use
factory patterns to create objects of these classes without bringing forth the
creation logic by using the ShapeFactory class. Now, the Driver class will be
used to pass the information to get the required object.

To integrate the factory design pattern, let’s follow these steps:

 Step 1: Creating "Shape" Interface

//Shape.java
public interface Shape {
void draw();
}

 Step 2: Creating Concrete Classes Rectangle, Square, Triangle to

Implement the Shape Interface
//Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw ( ) {
System.out.printIn (“Rectangle Drawn”);
}
}
//Square.java
public class Square implements Shape {
@Override
public void draw ( ) {
System.out.printIn (“Square Drawn”);
}
}
//Triangle.java
public class Triangle implements Shape {
@Override
public void draw ( ) {
System.out.printIn (“Triangle Drawn”);
}
}

 Step 3: Creating ''ShapeFactory" Class and a getShapeInstance()

Method to Generate Objects of the Concrete Classes

//ShapeFactory.java
public class ShapeFactory {
//the method will be used to get object of required shape
public shape getShapeInstance (String type) {
if (type == null) {
return null;
}
if (type.equalsIgnoreCase (“TRIANGLE”) ) {
return new Triangle ( ) ;
} else if (type.equalsIgnoreCase (“SQUARE”) ) {
return new Square ( ) ;
} else if (type.equalsIgnoreCase (“RECTANGLE”) ) {
return new Rectangle ( ) ;
}
return null;
}
}

 Step 4: Implementation of the Drive Class and Using the Factory Class
to Get the Required Object

//Driver.java
public class Driver {
public static void main (String [ ] args) {
ShapeFactory shapeFactory = new ShapeFactory ( ) ;
//get Triangle object and call draw ( )
Shape triangle = shapeFactory.getShape (“Triangle”) ;
triangle.draw ( ) ;
//get Rectangle object and call draw ( )
Shape rectangle = shapeFactory.getShape (“Rectangle”) ;
rectangle.draw ( ) ;
//get Square object and call draw ( )
Shape square = shapeFactory.getShape (“Square”) ;
square.draw ( ) ;
}
}

 Step 5: Validating the Output

Now, the output of the implementation will be:

Triangle Drawn
Rectangle Drawn
Square Drawn

13. What is the Adapter Design Pattern?

The adapter design pattern comes under the structural design pattern’s
category that allows incompatible objects to collaborate. This one acts as a
wrapper between two varying objects. The adapter gets a hold on the call for
one object and transforms it to be recognized by the second object.

Let’s consider the example of a USB to Ethernet adapter to understand it

better. When you have an ethernet interface at one end and the USB
interface on the other, you use USB to Ethernet. Since the ethernet and USB
are not compatible with each other, you have to use an adapter.

This adapter class comes with a client class and an adaptee class. While the
former expects an object type, the latter provides the same feature by
exposing a distinct interface. Now, to establish communication between the
two, there is an adapter class.

The client uses the target interface to request the adapter. And then, the
adapter class translates the request through the adaptee interface. The
client, then, receives the results without having any idea of the role of an
adapter.

To get deeper into this concept, let’s consider another example. Suppose you
have a MediaPlayer Interface that is implemented by the AudioPlayer class.
The AudioPlayer can play the format of mp3 by default. Let’s consider
another interface, which is AdvancedPlayer, implemented by the MP4Player
class that plays the mp4 formats. And then, there is a WAVPlayer that plays
wav formats.

If you want the AudioPlayer class to play different formats, you will have to
use the MediaAdapter class that implements the MediaPlayer interface and
makes use of the AdvancedPlayer objects to play the needed format.

The code implementation of this situation will be:

//MediaPlayer.java
public interface MediaPlayer {
public void play (String format, String file) ;
}
//AdvancedPlayer.java
public interface AdvancedPlayer {
public void playMP4 (String file) ;
public void playWav (String file) ;
}
//MP4Player.java
public class Mp4Player implements AdvancedPlayer{
@Override
public void playMp4 (String file) {
System.out.printIn (“MP4 File “ + file + “ Playing….”) ;
}
 @Override
public void playWav (String file) {
//do nothing
}
}
//WAVPlayer.java
public class WAVPlayer implements AdvancedPlayer{
@Override
public void playMP4 (String file) {
//do nothing
}
@Override
public void playWav (String fille) {
System.out.printIn (“WAV File “ + file + “ Playing….”) ;
}
}
//MediaAdapter.java
public class MediaAdapter implements MediaPlayer {
AdvancedPlayer advancedPlayer;
public MediaAdapter(String format){
if(format.equalsIgnoreCase("mp4") ){
advancedPlayer = new Mp4Player();
}else if(format.equalsIgnoreCase("wav") ){
advancedPlayer = new WAVPlayer();
}
}
@Override
public void play(String format, String file) {

if(format.equalsIgnoreCase("mp4")){
advancedPlayer.playMp4(file);
}
else if(format.equalsIgnoreCase("wav")){
advancedPlayer.playWav(file);
}
}
}
//AudioPlayer.java
public class AudioPlayer implements MediaPlayer {
 MediaAdapter mediaAdapter;
@Override
public void play(String format, String file) {
//inbuilt support to play mp3 music files
if(format.equalsIgnoreCase("mp3")){
System.out.println("MP3 file " + file +" Playing...");
}
//Make use of Adapter to support different formats
else if(format.equalsIgnoreCase("wav") ||
format.equalsIgnoreCase("mp4")){
mediaAdapter = new MediaAdapter(format);
mediaAdapter.play(format, file);
}
else{
System.out.println("Format not supported");
}
}
}
//Driver.java
public class Driver {
public static void main(String[] args) {
AudioPlayer audioPlayer = new AudioPlayer();
audioPlayer.play("mp3", "music1.mp3");
audioPlayer.play("wav", "music2.wav");
audioPlayer.play("mp4", "music3.mp4");
audioPlayer.play("avi", "music4.avi");
}
}

The output of the code will be:

MP3 file music1.mp3 Playing...

WAV File music2.wav Playing...
MP4 File music3.mp4 Playing...
Format not supported

14. What do you mean by Decorator Design Pattern?

Decorator design patterns come under the structural pattern category that
allows you to add new features to existing objects without altering the
structure. This pattern creates a decorator class that works as a wrapper to
the existing class by retaining the class methods’ signatures intact.

This pattern uses abstract classes as well as interfaces with composition to

implement the wrapper. Mostly, they are used to apply the Single
Responsibility Principle (SRP) as the functionalities are divided into classes
with distinct concerns. In terms of structure, this pattern is similar to the
chain of responsibility pattern.

Here are the steps to implement the decorator design pattern:

 Creating an interface and concrete classes to implement the interface

 Creating an abstract decorator class to implement the above interface

 Creating a concrete decorator class to extend the above abstract class

 Using the concrete decorator class to decorate the objects’ interface

and verifying the output.

To understand better, let’s take an example. Let’s create a shape interface

and concrete classes, Rectangle and Triangle, to implement the shape
interface.

 Step 1: Creating Shape Interface

// Shape.java
public interface Shape {
 void draw ( ) ;
}

 Step 2: Creating Concrete Classes Rectangle.java and

Triangle.java to Implement Shape Interface

// Rectangle.java
public class Rectangle implements Shape {
// Overriding the draw method
@Override public void draw ( )
{
System.out.printIn (“Rectangle Drawn…”) ;
}
}
// Triangle.java
public class Triangle implements Shape {
// Overriding the draw method
@Override public void draw ( )
{
System.out.printIn (“Triangle Drawn…”) ;
}
}

 Step 3: Creating ShapeDecorator Abstract Class to

Implement the Shape Interface

// ShapeDecorator.java
public abstract class ShapeDecorator implements Shape {
protected Shape shapeDecorated;
public ShapeDecorator (Shape shapeDecorated)
{
this.shapeDecorated = shapeDecorated;
}
public void draw ( ) {
shapeDecorated.draw ( ) ;
}
}

 Step 4: Creating the RedColorDecorator.java Class to Extend

the ShapeDecorator Class

public class RedColorDecorator extends ShapeDecorator {

public RedColorDecorator (Shape shapeDecorated)
 {
super (shapeDecorated) ‘
}
@Override
public void draw ( )
{
shapeDecorated.draw ( ) ;
setRedBorder (shapeDecorated) ;
}
private void setRedBorder (Shape shapeDecorated)
{
System.out.printIn (“Red color border added….”) ;
}
}

 Step 5: Implementation Of the Driver Class to Demo the

Decorator Class

// Driver.java
public class Driver {
// Main driver method
public static void main (String [ ] argos)
{
Shape triangle = new Triangle ( ) ;
Shape redTriangle
= new RedColorDecorator (new Triangle ( ) ) ;
Shape redRectangle = new RedColorDecorator (new
Rectangle ( ) ) ;
// Draw normal triangle
triangle.draw ( ) ;
System.out.printIn (“.........”) ;
// make the triangle red
redTriangle.draw ( ) ;
System.out.printIn (“.........”) ;
// make the rectangle red
redRectangle.draw ( ) ;
System.out.printIn (“..........”) ;
}
}

 Step 6: Validating the Output

The output of the above-mentioned code will be:

Triangle Drawn...
.........
Triangle Drawn...
Red color border added...
.........
Rectangle Drawn...
Red color border added...
.........

Check out String Handling in Java

15. Define a Command Pattern.

The command pattern is the type of behavioral design pattern that helps
transform a request into a stand-alone object that comprises all of the details
about that request. This one is a data-driven pattern as we use the
information regarding the request by wrapping the same as an object, which
is then passed to the invoker object in the form of a command.

The invoker object looks for the object that can manage the command and
passes it to the object for the command execution. There is a client that calls
the invoker to run the command. There is a command interface that acts as
an abstraction to the concrete classes.

Let’s understand it with an example of remote control that only has one
button. Through this button, you can control the behavior of two objects -
tubelight and a radio. Thus, the command design pattern will be used to
command the handling of objects.

 Step 1: Creating Command Interface

// Command Interface
interface Command
{
public void execute ( ) ;
}

 Step 2: Creating Tubelight Class and the Command Classes

to Extend the Above Interface to Control the Tubelight

// Tubelight class
class TubeLight
{
public void lightOn ( ) {
System.out.printIn (“TubeLight on…”) ;
}
public void lightOff ( ) {
System.out.printIn (“TubeLight off…”) ;
}
}
// Command class to turn on the tubelight
class TubeLightOnCommand implements Command
{
TubeLight tubeLight ;
// The constructor is passed the light it
// is going to control.
public TubeLightOnCommand (Tubelight tubeLight) {
this.tubeLight = tubeLight ;
}
public void execute ( ) {
 tubeLight.lightOn ( ) ;
}
}
// Command class to turn off the tubelight
class TubeLightOffCommand implements Command
{
TubeLight tubeLight ;
public TubeLightOffCommand (TubeLight tubeLight) {
this.tubeLight = tubeLight ;
}
public void execute ( ) {
tubeLight.lightOff ( ) ;
}
}

 Step 3: Creating a Radio Class and its Command Class to

Extend the Above Interface to Control the Radio

// Radio class
class Radio
{
public void radioOn ( )
{
System.out.printIn (“Radio on…”) ;
}
public void radioOff ( )
{
System.out.prinIn (“Radio off…”) ;
}
public void setVolume (int volumeLevel)
{
// code to set the volume
System.out.printIn (“Radio volume set to “ +
volumeLevel) ;
}
}
// Command class to turn on the radio
class RadioOnCommand implements Command
{
Radio radio;
public RadioOnCommand (Radio radio)
 {
this.radio = radio;
}
public void execute ( )
{
radio.radioOn ( ) ;
}
}
// Command class to set the volume of the radio
class RadioVolumeCommand implements Command
{
Radio radio;
int volumeLevel;
public RadioVolumeCommand (Radio radio, int volumeLevel)
{
this.radio = radio;
this.volumeLevel = volumeLevel;
}
public void execute ( )
{
radio.setVolume (volumeLevel) ;
}
}

 Step 4: Creating a Remote Control Class with One Button

that Executes the Command Functionality Upon Clicking

// remote control with one button

class RemoteControl {
Command button; // only one button
public RemoteControl ( ) { }
public void setCommand (Command command) {
// set the command the remote will
// execute
button = command;
}
public void pressButton ( ) {
// execute the command on click (call) of the button
button.execute ( ) ;
}
}
  Step 5: Creating a Driver Class to Integrate the Pattern

Here, we will be turning on the tubelight on the button’s first click. And, on
the next click, the radio will get turned on. Next, the radio’s volume will be
set to 4 and then the tubelight will get turned off.

// Driver class
public class Driver
{
public static void main (String [ ] args)
{
RemoteControl remote = new RemoteControl ( ) ;
TubeLight tubeLight = new TubeLight ( ) ;
Radio radio = new Radio ( ) ;
// Turn on Tubelight
remote.setCommand (new
TubeLightOnCommand (tubeLight) ) ;
remote.pressButton ( ) ;
// Turn on Radio
remote.setCommand (new RadioOnCommand
(radio) ) ;
remote.pressButton ( ) ;
// Turn off Radio
remote.setCommand (new
RadioVolumeCommand (radio, 4) ) ;
remote.pressButton ( ) ;
// Turn off Tubelight
remorse.setCommand (new
TubeLightOffCommand (tubeLight) ) ;
remote.pressButton ( ) ;
}
}

 Step 6: Validating the Result

TubeLight on...
Radio on ...
Radio volume set to 4
TubeLight off…

16. What problems does the Builder Pattern solve?

A builder pattern is a kind of creational design pattern that allows you to
step-by-step construct complicated objects. The pattern allows you to
produce varying representations of an object through the same logic of
construction.

It assists in creating immutable classes with a large set of attributes. In the

Factory as well as Abstract Factory Design Patterns, you come across these
problems if the object has several attributes:

 When there are too many arguments, the program will get prone to

error when passing to the Factory Class from the client in a certain

order. It becomes difficult to maintain the order of these arguments

when the types are the same.

 When the creation of an object turns complex because of heavy

attributes, the complexity of this class will turn confusing.

 There may be optional attributes of the object. And, despite that, you

might be compelled to send all of the optional attributes and

parameters as Null.

These issues can be solved through constructors of needed parameters.

However, this creates a problem when new parameters will be added as parts
of new requirements. This will result in inconsistency. That is where Builder is
used.

This pattern helps solve the problem of a massive number of optional

attributes and the inconsistent situation by offering a method to develop an
object in a step-by-step methodology and return the final object through
another method.

The following steps can help implement the builder pattern:

 Creating a static nested class, copy all arguments from the

outer class: This nested class will be called the builder class.

Adequate naming convention must be followed when naming the

builder class. For instance, if the class’s name is MindMajix, the

builder’s name will be MindMajixBuilder.

  The builder class must have a public constructor with all of the

attributes sent as parameters.

 The builder class should also have methods to set optional parameters

and return the builder object after setting the values.

 Finally, the build() method should be there inside the builder class to

return the object required by the client.

Let’s understand better with an example. Here, we have a user class and will
build a UserBuilder class to develop objects of the user class.

class User
{
//All final attributes
private final String firstName; // required
private final String lastName; // required
private final int age; // required
private final String phoneNbr; // optional
private final String address; // optional
private final String nationality; //optional

private User(UserBuilder builder) {

this.firstName = builder.firstName;
this.lastName = builder.lastName;
this.age = builder.age;
this.phoneNbr = builder.phoneNbr;
this.address = builder.address;
this.nationality = builder.nationality;
}

//Setters are not provided to make it immutable

public String getFirstName() {
return firstName;
}
 public String getLastName() {
return lastName;
}
public int getAge() {
return age;
}
public String getPhoneNbr() {
return phoneNbr;
}
public String getAddress() {
return address;
}
public String getNationality() {
return nationality;
}

@Override
public String toString() {
return "User: "+this.firstName+" "+this.lastName+", "+this.age+",
"+this.nationality", "+this.phoneNbr+", "+this.address;
}

public static class UserBuilder

{
private final String firstName;
private final String lastName;
private int age;
private String phoneNbr;
private String address;
private String nationality;

public UserBuilder(String firstName, String lastName) {

this.firstName = firstName;
this.lastName = lastName;
}
public UserBuilder age(int age) {
this.age = age;
return this;
}
public UserBuilder phoneNbr(String phoneNbr) {
 this.phoneNbr = phoneNbr;
return this;
}
public UserBuilder address(String address) {
this.address = address;
return this;
}
public UserBuilder nationality(String nationality) {
this.nationality = nationality;
return this;
}
// method to return the constructed object
public User build() {
User user = new User(this);
validateUserObject(user);
return user;
}
private void validateUserObject(User user) {
//Validate of the object does not break anything
}
}
}
public class Driver{
public static void main(String[] args) {
User firstUser = new User.UserBuilder("Harry", "Potter")
.age(30)
.phoneNbr("1234567")
.address("221B Baker Street - London")
.build();

System.out.println(firstUser);

User secondUser = new User.UserBuilder("Ron", "Weasley")

.age(32)
.phoneNbr("5655")
//no address
.build();

System.out.println(secondUser);
 User thirdUser = new User.UserBuilder("Hermoine",
"Granger").age(20).nationality("English")
//No age
//No phone
//no address
.build();

System.out.println(thirdUser);
}
}

The output of this code will be:

User: Harry Potter, 30, null, 1234567, 221B Baker Street - London
User: Ron Weasley, 32, null, 5655, null
User: Hermoine Granger, 20, English, null, null

17. What is the method to accomplish thread-safe Singleton Patterns in Java?

A thread-safe singleton class is created to help object initialization in the

presence of several threads. It can be done in several ways:

 Method 1: Using Enums

Enums are the easiest ways to create a thread-safe singleton class in Java as
the synchronization support is internally done by Java. By default, Enums are
finalized and help in averting several initializations during serialization.

public enum ThreadSafeSingleton{

SINGLETON_INSTANCE;
public void display(){
System.out.println("Thread-safe singleton Display");
}
}
// The Singleton class methods can be invoked as below
ThreadSafeSingleton.SINGLETON_INSTANCE.show();

 Method 2: Using Static Field Initialization

They can also be created by developing the instance at the time of class
loading. This can be achieved by using static fields as the Classloader
guarantees the initialization of instances during class loading. Also, the
instance is not visible until it has been created completely.

public class ThreadSafeSingleton{

 private static final ThreadSafeSingleton INSTANCE = new
ThreadSafeSingleton();
private ThreadSafeSingleton(){ }
public static ThreadSafeSingleton getInstance(){
return INSTANCE;
}
public void display(){
System.out.println("Thread-safe Singleon");
}
}
ThreadSafeSingleton.getInstance().display();

 Method 3: Using Synchronized Keyword

We can use the synchronized keyword upon the getInstance method as:

In this method, you can achieve lazy initialization and the object initialization
is thread-safe because of the use of synchronized keywords.

The only issue is that the performance gets affected in the presence
of multiple threads because the entire method is synchronized.

public class ThreadSafeSingleton

{
// Creating private instance to make it accessible only by
getInstance() method
private static ThreadSafeSingleton instance;
private ThreadSafeSingleton()
{
// Making constructor private so that objects cant be initialized
outside the class
}
//synchronized getInstance method
synchronized public static ThreadSafeSingleton getInstance(){
if (this.instance == null)
{
// if instance is null, initialize
this.instance = new ThreadSafeSingleton();
}
return this.instance;
}
}

 Method 4: Double-Check Locking

Here, a synchronized block of codes will be used within the getInstance
method rather than making the entire method synchronized. This makes sure
that just a handful of threads will have to wait for the first time; thus, it
doesn’t affect the performance.

public class ThreadSafeSingleton {

// Creating private instance to make it accessible only by
getInstance() method
private static ThreadSafeSingleton instance;
private ThreadSafeSingleton(){
// Making constructor private so that objects cant be initialized
outside the class
}
public static ThreadSafeSingleton getInstance(){
if (instance == null){
//synchronized block of code
synchronized (ThreadSafeSingleton.class){
if(instance==null)
{
// initialize only if instance is null
instance = new ThreadSafeSingleton();
}
}
}
return instance;
}
}

18. Can you write a Java program to showcase the following pyramid design?
*
* *
* * *
* * * *
* * * * *

This design can be achieved through nested loops and calculatingly adding
stars and spaces as shown below:

public class MindMajixPyramid{

public static void printPyramid(int n) {
for (int i=0; i<n; i++){ // for number of rows
for (int j=n-i; j>1; j--) {
System.out.print(" "); //print space
 }
//for number of columns
for (int j=0; j<=i; j++ ) {
System.out.print("* "); // print star
}
//end-line after every row
System.out.println();
}
}

public static void main(String args[]){

printPyramid(5); //Print Pyramid stars of 5 rows
}
}

The output of this code will be:

*
* *
* * *
* * * *
* * * * *

19. Can you write a Java program to showcase the left triangle star pattern on
the system console?

This can be accomplished through nested loops and calculatingly adding

spaces and stars as shown below:

public class MindMajixPyramid{

public static void printLeftTriangleStars(int n) {
int j;
for(int i=0; i<n; i++){ // outer loop for number of rows(n)
for(j=2*(n-i); j>=0; j--){ // for spaces
System.out.print(" "); // to print space
}
for(j=0; j<=i; j++){ // for columns
System.out.print("* "); // Print star and give space
}
System.out.println(); // Go to next line after every row
}
}
public static void main(String args[]){
 printLeftTriangleStars(5); //print stars of 5 rows in left triangle
fashion
}
}

The output will be:

*
* *
* * *
* * * *
* * * * *

20. Can you write a Java program that can print diamond number patterns?
public class MindMajixDiamondNumber{
public static void diamondNumberDisplay(int maxNum){
for (int i = 1; i <= maxNum; i++){
int n = maxNum;
for (int j = 1; j<= n - i; j++) {
System.out.print(" ");
}
for (int k = i; k >= 1; k--) {
System.out.print(k);
}
for (int l = 2; l <= i; l++) {
System.out.print(l);
}
System.out.println();
}
for (int i = maxNum-1; i >= 1; i--){
int n = maxNum-1;
for (int j = 0; j<= n - i; j++) {
System.out.print(" ");
}
for (int k = i; k >= 1; k--){
System.out.print(k);
}
for (int l = 2; l <= i; l++){
System.out.print(l);
}
System.out.println();
 }
}
public static void main(String[] args) {
int n = 5;
diamondNumberDisplay(n);

}
}

The output will be:

1
212
32123
4321234
543212345
4321234
32123
212
1

Conclusion

Design patterns make sure that the reusable solutions are tested adequately
and implemented in a right manner to enhance the code flexibility and make
a way to develop extendible and smart solutions that solve issues with ease.
Now that you are finally preparing to appear for the interview, refer to these
design patterns interview questions and get that well-deserving job.