Scribd
Upload
3 views10 pages

Skill-1 Java

it has java program impoves skill in java

Uploaded by

Chinnu Jashuva
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
3 views10 pages

Skill-1 Java

it has java program impoves skill in java

Uploaded by

Chinnu Jashuva
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 10

1.

Behavioral patterns 21000319889 V SAI TARUN


2100032044 G jashuva

1. Expression Evaluation
Implement Interpreter Design pattern to solve postfix expression in Java.

Ans): package interpreterpattern;

public interface Expression


{
public int interpret();
}

package interpreterpattern;

public class Add implements Expression


{

private final Expression leftExpression;


private final Expression rightExpression;

public Add(Expression leftExpression,Expression rightExpression )


{
this.leftExpression = leftExpression;
this.rightExpression = rightExpression;
}

public int interpret()


{
return leftExpression.interpret() +
rightExpression.interpret();
}

Package interpreterpattern;

public class Product implements Expression


{

private final Expression leftExpression;


private final Expression rightExpression;
public Product(Expression leftExpression,Expression
rightExpression )
{
this.leftExpression = leftExpression;
this.rightExpression = rightExpression;
}
public int interpret()
{
return leftExpression.interpret() *
rightExpression.interpret();
}
}

package interpreterpattern;

public class Substract implements Expression


{

private final Expression leftExpression;


private final Expression rightExpression;

public Substract(Expression
leftExpression,Expression rightExpression )
{
this.leftExpression = leftExpression;
this.rightExpression = rightExpression;
}

public int interpret()


{
return leftExpression.interpret() -
rightExpression.interpret();
}

package interpreterpattern;

public class Number implements Expression


{

private final int n;

public Number(int n)
{
this.n = n;
}
public int interpret()
{
return n;
}

package interpreterpattern;

public class ExpressionUtils


{

public static boolean isOperator(String s)


{
if (s.equals("+") || s.equals("-") || s.equals("*"))
return true;
else
return false;
}

public static Expression getOperator(String s, Expression


left, Expression right)
{
switch (s)
{
case "+":
return new Add(left, right);
case "-":
return new Substract(left, right);
case "*":
return new Product(left, right);
}
return null;
}

}
package interpreterpattern;

import java.util.Stack;

public class TestInterpreterPattern


{
public static void main(String[] args)
{

String tokenString = "7 3 - 2 1 + *";


Stack<Expression> stack = new Stack<>();
String[] tokenArray = tokenString.split(" ");
for (String s : tokenArray)
{
if (ExpressionUtils.isOperator(s))
{
Expression rightExpression = stack.pop();
Expression leftExpression = stack.pop();
Expression operator = ExpressionUtils.getOperator(s,
leftExpression,rightExpression);
int result = operator.interpret();
stack.push(new Number(result));
}
else
{
Expression i = new Number(Integer.parseInt(s));
stack.push(i);
}
}
System.out.println("( "+tokenString+" ):
"+stack.pop().interpret());

Input:
73-21+*
Output:12
2. Assume you are going to buy some items from the Departmental store. You want to calculate the
Total cost of the items which you want to purchase from the store. Following items to be purchased:
• Parker pen
• Pilet pen
• One Notebook with more than 250 pages ( Ex: Price is Rs. 50)
• One Notebook with less than 250 pages ( If pages < 250, reduce the cost by Rs.5)
Find the Total cost by implementing Visitor pattern
Package visitorpattern;

interface Item

Public int accept (Visitor visitor);

interface Visitor

Int visit(Pen pen);

Int visit(Notebook notebook);

class Pen implements Item

Private int price;

private String model;

public Pen (int price, String model)

this.price = price;

this.model = model;

Public int getPrice()

return price;

public String getModel()

return model;

Public int accept (Visitor visitor)


{

return visitor.visit(this);

class Notebook implements Item

Private int price;

Private int numberOfPages;

Public Notebook (int price, int numberOfPages)

this.price = price;

this.numberOfPages = numberOfPages;

Public int getPrice()

return price;

Public int getNumberOfPages()

return numberOfPages;

Public int accept (Visitor visitor)

returnvisitor.visit(this);

Class VisitorImpl implements Visitor

Public int visit (Pen pen)

Int price = pen.getPrice();

System.out.println(pen.getModel() + " costs " + price);

return price;

Public int visit (Notebook notebook)

{
Int price = 0;

if(notebook.getNumberOfPages() > 250)

price = notebook.getPrice()-5;

else

price = notebook.getPrice();

System.out.println("Notebook costs " + price);

return price;

Public class Visitorpattren

Public static void main(String[] args)

// TODO Auto-generated method stub

Item[] items = new Item[]

new Pen(10, "Parker"), new Pen(5, "Pilet"), new Notebook(50, 150), new Notebook(75, 300);

inttotal = getTotalPrice(items);

System.out.println("Total price of items: " + total);

privatestaticintgetTotalPrice(Item[] items)

Visitor visitor = newVisitorImpl();

int result = 0;

for(Item item : items)

result = result + item.accept(visitor);

return result;

}
3. Implement BubbleSort sorting algorithm using Strategy pattern
Ans)
Public interface SortingStrategy
{
int[] sort( int[] inputArray );
}

public class BubbleSort implements SortingStrategy


{

public int[] sort( int[] inputArray )


{
int n = inputArray.length;
for( int i = 0; i < n; i++ )
{
for( int j = 1; j < (n - i); j++ )
{
if( inputArray[j - 1] > inputArray[j] )
{
swap(j - 1, j, inputArray);
}
}
}
System.out.println("Array is sorted using Bubble Sort Algorithm");
return inputArray;
}

private void swap( int k, int l, int[] inputArray )


{
int temp = inputArray[k];
inputArray[k] = inputArray[l];
inputArray[l] = temp;
}
}
import java.util.Scanner;

public class SortContext


{

private SortingStrategy sortingStrategy;

public void setSortingStrategy( SortingStrategy sortingStrategy )


{
this.sortingStrategy = sortingStrategy;
}

private void printArray( int[] inputArray )


{
for( int i = 0; i < inputArray.length; i++ )
{
System.out.print(inputArray[i] + ",");
}
System.out.println("\n");

private int[] readUserInput()


{
System.out.println("Enter array size : ");

Scanner scanner = new Scanner(System.in);


int n = scanner.nextInt();

System.out.println("Enter input array : ");


int[] inputArray = new int[n];
for( int i = 0; i < n; i++ )
{
inputArray[i] = scanner.nextInt();
}
return inputArray;
}

public void sort()


{
int[] inputArray = readUserInput();
inputArray = sortingStrategy.sort(inputArray);
printArray(inputArray);
}
}

import java.util.Scanner;

public class StrategyClient


{
public static void main( String[] args )
{
Scanner scanner = new Scanner(System.in);
String sortAlgorithm = scanner.next();
System.out.println("Sort Algorithm is : " + sortAlgorithm);

SortContext context = new SortContext();


context.setSortingStrategy(new BubbleSort());

context.sort();

}
}

Input: 34,12,67,10,7

Output: 7,10,12,34,67

You might also like