SADP
Q1. Single Tone Pattern
public class Singleton {
private static volatile Singleton uniqueInstance;
private Singleton() {
}
public static Singleton getInstance() {
if(uniqueInstance == null) {
synchronized (Singleton.class) {
if(uniqueInstance == null) {
uniqueInstance = new Singleton();
}
}
}
return uniqueInstance;
}
public void doSomething() {
System.out.println("Singleton is doing something.");
}
public static void main(String[] args) {
Singleton instance1 = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println("Are instance equal? " + (instance1 == instance2));
}
}
Q2. Test Ciling Fan
interface Command {
void execute();
void undo();
}
class CeilingFan {
private boolean isOn;
private int speed;
public void turnOn() {
System.out.println("Ceiling Fan is ON");
isOn = true;
speed = 1;
}
public void turnOff() {
System.out.println("Ceiling Fan is OFF");
isOn = false;
speed = 0;
}
public void increaseSpeed() {
if (isOn && speed < 3) {
System.out.println("Increasing Ceiling Fan speed");
speed++;
}
}
public void decreaseSpeed() {
if (isOn && speed > 0) {
System.out.println("Decreasing Ceiling Fan speed");
speed--;
}
}
}
class FanCommand implements Command {
private final CeilingFan ceilingFan;
public FanCommand(CeilingFan ceilingFan) {
this.ceilingFan = ceilingFan;
}
@Override
public void execute() {
ceilingFan.turnOn();
ceilingFan.increaseSpeed();
}
@Override
public void undo() {
ceilingFan.turnOff();
}
}
class RemoteControl {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void pressButton() {
command.execute();
}
public void pressUndoButton() {
command.undo();
}
}
public class CeilingFanTest {
public static void main(String[] args) {
CeilingFan ceilingFan = new CeilingFan();
RemoteControl remote = new RemoteControl();
Command fanCommand = new FanCommand(ceilingFan);
remote.setCommand(fanCommand);
remote.pressButton();
remote.pressUndoButton();
}
}
_________________________________________________________________________________-
Q3. Break Fast, Lunch and Dinner
class MenuItem {
private String name;
private String description;
private double price;
public MenuItem(String name, String description, double price) {
this.name = name;
this.description = description;
this.price = price;
}
public String getName() {
return name;
}
public String getDescription() {
return description;
}
public double getPrice() {
return price;
}
@Override
public String toString() {
return name + " - " + description + ", $" + price;
}
}
// Menu interface defining methods to create an iterator
interface Menu {
Iterator<MenuItem> createIterator();
}
// Concrete Breakfast Menu class
class BreakfastMenu implements Menu {
private MenuItem[] items;
private int size;
public BreakfastMenu() {
items = new MenuItem[3];
addItem("Pancakes", "Fluffy pancakes with syrup", 5.99);
addItem("Omelette", "Three-egg omelette with cheese", 6.99);
addItem("Toast", "Buttered toast", 2.49);
}
private void addItem(String name, String description, double price) {
if (size < items.length) {
items[size++] = new MenuItem(name, description, price);
}
}
@Override
public Iterator<MenuItem> createIterator() {
return new ArrayIterator(items);
}
}
// Concrete Lunch Menu class
class LunchMenu implements Menu {
private MenuItem[] items;
private int size;
public LunchMenu() {
items = new MenuItem[3];
addItem("Chicken Salad", "Grilled chicken with mixed greens", 8.99);
addItem("Burger", "Classic beef burger with fries", 7.49);
addItem("Vegetarian Wrap", "Wrap with veggies and hummus", 6.99);
}
private void addItem(String name, String description, double price) {
if (size < items.length) {
items[size++] = new MenuItem(name, description, price);
}
}
@Override
public Iterator<MenuItem> createIterator() {
return new ArrayIterator(items);
}
}
// Iterator interface for iterating over menu items
interface Iterator<T> {
boolean hasNext();
T next();
}
// Concrete Iterator class for iterating over an array of menu items
class ArrayIterator implements Iterator<MenuItem> {
private MenuItem[] items;
private int position = 0;
public ArrayIterator(MenuItem[] items) {
this.items = items;
}
@Override
public boolean hasNext() {
return position < items.length && items[position] != null;
}
@Override
public MenuItem next() {
return items[position++];
}
}
// Client code to test the Iterator Pattern
public class MenuTest {
public static void main(String[] args) {
Menu breakfastMenu = new BreakfastMenu();
Menu lunchMenu = new LunchMenu();
System.out.println("Breakfast Menu:");
printMenu(breakfastMenu.createIterator());
System.out.println("\nLunch Menu:");
printMenu(lunchMenu.createIterator());
}
private static void printMenu(Iterator<MenuItem> iterator) {
while (iterator.hasNext()) {
MenuItem menuItem = iterator.next();
System.out.println(menuItem);
}
}
}
____________________________________________________________________--
Q4. Temprature, humidity pressure
import java.util.Observable;
import java.util.Observer;
@SuppressWarnings("deprecation")
class WeatherStationDemo extends Observable {
private float temperature;
private float humidity;
private float pressure;
public void setMeasurement(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
// Notify observers of the change in weather measurements
setChanged();
notifyObservers();
}
public float getTemperature() {
return temperature;
}
public float getHumidity() {
return humidity;
}
public float getPressure() {
return pressure;
}
}
class Display implements Observer {
@Override
public void update(Observable o, Object arg) {
WeatherStationDemo station = (WeatherStationDemo) o;
float temperature = station.getTemperature();
float humidity = station.getHumidity();
float pressure = station.getPressure();
System.out.println("Weather update:");
System.out.println("Temperature: " + temperature);
System.out.println("Humidity: " + humidity);
System.out.println("Pressure: " + pressure);
}
}
public class WeatherStation {
public static void main(String[] args) {
// Create a weather station
WeatherStationDemo station = new WeatherStationDemo();
// Create a display to observe the weather station
Display display = new Display();
station.addObserver(display);
// Simulate sensor readings and notify observers
station.setMeasurement(25.5f, 70.0f, 1013.25f);
}
}
Q5. Pizza Store
abstract class Pizza {
public abstract void prepare();
public abstract void bake();
public abstract void cut();
public abstract void box();
}
class NYStyleCheesePizza extends Pizza {
@Override
public void prepare() {
System.out.println("Preparing NY style cheese pizza...");
}
@Override
public void bake() {
System.out.println("Baking NY style cheese pizza...");
}
@Override
public void cut() {
System.out.println("Cutting NY style cheese pizza...");
}
@Override
public void box() {
System.out.println("Boxing NY style cheese pizza...");
}
}
class ChicagoStyleCheesePizza extends Pizza {
@Override
public void prepare() {
System.out.println("Preparing Chicago style cheese pizza...");
}
@Override
public void bake() {
System.out.println("Baking Chicago style cheese pizza...");
}
@Override
public void cut() {
System.out.println("Cutting Chicago style cheese pizza...");
}
@Override
public void box() {
System.out.println("Boxing Chicago style cheese pizza...");
}
}
class PizzaStore {
public Pizza createPizza(String pizzaType) {
if (pizzaType.equals("NYStyleCheesePizza")) {
return new NYStyleCheesePizza();
} else if (pizzaType.equals("ChicagoStyleCheesePizza")) {
return new ChicagoStyleCheesePizza();
} else {
throw new IllegalArgumentException("Invalid pizza type: " + pizzaType);
}
}
public Pizza orderPizza(String pizzaType) {
Pizza pizza = createPizza(pizzaType);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
public class Main {
public static void main(String[] args) {
PizzaStore pizzaStore = new PizzaStore();
Pizza pizza = pizzaStore.orderPizza("NYStyleCheesePizza");
pizza = pizzaStore.orderPizza("ChicagoStyleCheesePizza");
}
}
Q6. Adapte Pattern
package Slip4;
import java.util.Vector;
interface MyEnumeration<E> {
boolean hasMoreElements();
E nextElement();
}
interface MyIterator<E> {
boolean hasNext();
E next();
}
class EnumerationAdapter<E> implements MyIterator<E> {
private final MyEnumeration<E> enumeration;
public EnumerationAdapter(MyEnumeration<E> enumeration) {
this.enumeration = enumeration;
}
@Override
public boolean hasNext() {
return enumeration.hasMoreElements();
}
@Override
public E next() {
return enumeration.nextElement();
}
}
public class Main {
public static void main(String[] args) {
Vector<String> vector = new Vector<>();
vector.add("Apple");
vector.add("Banana");
vector.add("Orange");
MyEnumeration<String> enumeration = new MyEnumeration<String>() {
private int index = 0;
@Override
public boolean hasMoreElements() {
return index < vector.size();
}
@Override
public String nextElement() {
if (hasMoreElements()) {
return vector.get(index++);
}
throw new java.util.NoSuchElementException("No more elements");
}
};
MyIterator<String> iterator = new EnumerationAdapter<>(enumeration);
// Iterate over the collection using the Iterator
while (iterator.hasNext()) {
String fruit = iterator.next();
System.out.println(fruit);
}
}
}
Q7. Upper CAse Letter to Lower Case Latter
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
class LowerCaseInput extends FilterInputStream {
public LowerCaseInput(InputStream in) {
super(in);
}
@Override
public int read() throws IOException {
int c = in.read();
if (c != -1) {
c = Character.toLowerCase(c);
}
return c;
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
int n = in.read(b, off, len);
if (n != -1) {
for (int i = off; i < off + n; i++) {
b[i] = (byte) Character.toLowerCase(b[i]);
}
}
return n;
}
}
public class Main {
public static void main(String[] args) throws IOException {
InputStream in = Main.class.getClassLoader().getResourceAsStream("input.txt");
LowerCaseInput lower = new LowerCaseInput(in);
int c;
while ((c = lower.read()) != -1) {
System.out.print((char) c);
}
lower.close();
}
}