Task - Design Patterns - Chain of Responsibility

[akash-coded]

Implementation of Chain of Responsibility Pattern and parseInt()

Chained Number Handlers

Objective

The objective here is to take a custom number object and identify whether it is positive, negative, or zero. The identification will be done by the respective handlers which are chained together. There will be a handler at the end of the chain that will also handle the case of the MyNumber value not being an integer.

Methodology

Declare a class called MyNumber which will have a private String data member value. It will have constructor, getters, setters, and overrides toString().

Declare a class called RequestNumber which will act as a wrapper for MyNumber and initialize it via the constructor. It will also have a getNumber() function.

Declare a NumberHandler abstract class.

Create four concrete handler classes: NegativeNumberHandler, ZeroHandler, PositiveNumberHandler, and NotAnIntegerHandler. These handlers have parameterized constructors with Handler nextHandler parameter. They also have a handle(Request request) method which prints if the number is negative, positive, zero or throws a NumberFormatException if MyNumber value is not an integer.

The handlers are chained together using a Chain class.

Reference

Refer this program for a demo on Chain of Responsibility.

[Ashwesh09]

package designPatterns.BehavioralPattern;

class MyNumber{
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }
    
}


abstract class MyparseInt
{
    private MyparseInt nextHandler;
 
    MyparseInt(MyparseInt nextHandler){
        this.nextHandler = nextHandler;
    }
     
    public void handle(MyNumber request){
        if(nextHandler != null)
            nextHandler.handle(request);
    }
}

class NegativeNumberHandler extends MyparseInt{

    private boolean isNeagtive(String input){
        return input.matches("-[1-9][0-9]*");
    }
    NegativeNumberHandler(MyparseInt nextHandler) {
        super(nextHandler);
    }
     @Override
    public void handle(MyNumber request) {
        if(isNeagtive(request.getValue()))
            System.out.println(request.getValue() + " is Negative.");
        else
            super.handle(request);
    }

}

class ZeroNumberHandler extends MyparseInt{
    private boolean isZero(String input) {
        return input.equals("0");
    }
    ZeroNumberHandler(MyparseInt nextHandler) {
        super(nextHandler);
    }
     @Override
    public void handle(MyNumber request) {
        if(isZero(request.getValue()))
            System.out.println(request.getValue()+ " is Zero.");
        else
            super.handle(request);
    }

}
class PositiveNumberHandler extends MyparseInt{
    private boolean isPositive(String input){
        return input.matches("\\d+");
    }
    PositiveNumberHandler(MyparseInt nextHandler) {
        super(nextHandler);
    }
     @Override
    public void handle(MyNumber request) {
        if(isPositive(request.getValue()))
            System.out.println(request.getValue()+ " is Positive");
    }
}
class NotAnIntegerHandler extends MyparseInt{
    NotAnIntegerHandler(MyparseInt nextHandler) {
        super(nextHandler);
    }
    @Override
    public void handle(MyNumber request) {
        if(!request.getValue().matches("\\d+"))
            System.out.println(request.getValue()+ " is not a integer");
        else
            super.handle(request);
    }
}

class Chain{
    MyparseInt fristHandler;
 
    public Chain(){
        buildChain();
    }
 
    private void buildChain(){
            this.fristHandler = new NotAnIntegerHandler(
                                    new NegativeNumberHandler(
                                        new ZeroNumberHandler(
                                            new PositiveNumberHandler(null))));
    }
    public void verify(MyNumber request) {
        fristHandler.handle(request);
    }
}

public class BehavioralPatternDemo {
    public static void main(String[] args) {
        Chain chain = new Chain();
        chain.verify(new MyNumber("1"));
        chain.verify(new MyNumber("-1"));
        chain.verify(new MyNumber("0"));
        chain.verify(new MyNumber("abc"));
    }
}

[RohitNaikade1]

class MyNumber{
    private String value,type;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return "MyNumber [type=" + type + ", value=" + value + "]";
    }
    
}

class Request {
    private MyNumber number;

    Request(MyNumber number) {
        this.number = number;
    }

    public MyNumber getNumber() {
        return number;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class PositiveHandler extends Handler {
    PositiveHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        int data=Integer.parseInt(request.getNumber().getValue());
        if(data>=0){
            request.getNumber().setType("Positive");
        }
        
        super.handle(request);
    }
}

class NegativeHandler extends Handler {
    NegativeHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int data=Integer.parseInt(request.getNumber().getValue());
        if(data<0){
            request.getNumber().setType("Negative");
        }
        super.handle(request);
    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int data=Integer.parseInt(request.getNumber().getValue());
        if(data==0){
            request.getNumber().setType("Zero");
        }
        super.handle(request);
    }
}
class ExceptionHandler extends Handler {
    ExceptionHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try{
            int data=Integer.parseInt(request.getNumber().getValue());
        }catch(Exception e){
            request.getNumber().setType("Not a Number");
        }
 
        super.handle(request);
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new PositiveHandler(new NegativeHandler(new ZeroHandler(new ExceptionHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ParseIntChaining{
    public static void main(String[] args) {
        MyNumber number = new MyNumber();
        number.setValue("tete");
        Request request = new Request(number);

        Chain numberBuildingChain = new Chain();
        numberBuildingChain.initiateChain(request);

        System.out.println(request.getNumber());
    }
}

[preeti-max]

class MyNumber {
    String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }

}

class Request {
    private MyNumber number;

    Request(MyNumber number) {
        this.number = number;
    }

    public MyNumber getNumber() {
        return number;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (request.getNumber().getValue().matches("-[1-9][0-9]*")) {
            System.out.println("Negative Number");

        } else {
            super.handle(request);
        }

    }
}

class NotAnIntegerHandler extends Handler {
    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (!request.getNumber().getValue().matches("//d+")) {
            throw new NumberFormatException("Invalid number");

        } else {
            super.handle(request);
        }

    }
}

class PositiveNumberHandler extends Handler {
    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (request.getNumber().getValue().matches("[1-9][0-9]*")) {
            System.out.println("Positive Number");

        } else {
            super.handle(request);
        }

    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (request.getNumber().getValue().equals("0")) {
            System.out.println("Zero Number");

        } else {
            super.handle(request);
        }

    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new PositiveNumberHandler(
                new NegativeNumberHandler(new ZeroHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        MyNumber number = new MyNumber("-8");
        Request request = new Request(number);

        Chain carBuildingChain = new Chain();
        carBuildingChain.initiateChain(request);

        System.out.println(request.getNumber());
    }
}

[Gaurav-Joshi-31]

import java.util.Random;

class MyNumber {
    private String num;

    public MyNumber(String num) {
        this.num = num;
    }

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return "MyNumber [num=" + num + "]";
    }

}

class Request {
    private MyNumber myNumber;

    public Request(MyNumber myNumber) {
        this.myNumber = myNumber;
    }

    public MyNumber getMyNumber() {
        return myNumber;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeHandler extends Handler {
    boolean isNegative(String num) {
        if (num.charAt(0) != '-') {
            return false;
        }
        for (int i = 1; i < num.length(); i++) {
            if (!Character.isDigit(num.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    public NegativeHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (isNegative(request.getMyNumber().getNum())) {

            System.out.println("This is a negative number");
        } else {
            super.handle(request);
        }

    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    boolean isZero(String num) {
        for (int i = 0; i < num.length(); i++) {
            if (num.charAt(i) != '0')
                return false;
        }
        return true;
    }

    @Override
    public void handle(Request request) {
        if (isZero(request.getMyNumber().getNum())) {
            System.out.println("This is a zero number");
        } else {
            super.handle(request);
        }

    }
}

class PositiveHandler extends Handler {
    boolean isPositive(String num) {
        for (int i = 0; i < num.length(); i++) {
            if (!Character.isDigit(num.charAt(i)))
                return false;
        }
        return true;
    }

    PositiveHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (isPositive(request.getMyNumber().getNum())) {
            System.out.println("This is a positive number");
        } else {
            super.handle(request);
        }
    }
}

class NotAnIntegerHandler extends Handler {

    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        System.out.println("This is not a integer");
        super.handle(request);
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NegativeHandler(new ZeroHandler(new PositiveHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        MyNumber num = new MyNumber("gaurav");
        Request request = new Request(num);

        Chain parseChain = new Chain();
        parseChain.initiateChain(request);

    }
}

[Mrafe]

package designPatterns.chain;

class MyNumber {
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }

}

class Request {
    MyNumber number;

    public Request(MyNumber number) {
        this.number = number;
    }

    MyNumber getNumber() {
        return this.number;
    }

}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {

    public NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int a = Integer.parseInt(request.getNumber().getValue());
            if (a < 0) {
                System.out.println("Its a negative number");
            } else {
                super.handle(request);
            }
        } catch (Exception e) {
            super.handle(request);
        }

    }
}

class PositiveNumberHandler extends Handler {

    public PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int a = Integer.parseInt(request.getNumber().getValue());
            if (a > 0) {
                System.out.println("Its a positive number");
            } else {
                super.handle(request);
            }
        } catch (Exception e) {
            super.handle(request);
        }

    }
}

class ZeroHandler extends Handler {

    public ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int a = Integer.parseInt(request.getNumber().getValue());
            if (a == 0) {
                System.out.println("Its Zero");
            } else {
                super.handle(request);
            }
        } catch (Exception e) {
            super.handle(request);
        }

    }
}

class NotAnIntegerHandler extends Handler {

    public NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int a = Integer.parseInt(request.getNumber().getValue());
        } catch (Exception e) {
            System.out.println("Not an integer");
        }

    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new PositiveNumberHandler(
                new NegativeNumberHandler(new ZeroHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class NumberChain {
    public static void main(String[] args) {
        MyNumber number = new MyNumber("44");
        Request request = new Request(number);

        Chain carBuildingChain = new Chain();
        carBuildingChain.initiateChain(request);

        System.out.println(request.getNumber());
    }
}

[VigneshVishwa]

class MyNumber{
    private String value,type;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return "MyNumber [type=" + type + ", value=" + value + "]";
    }
    
}

class Request {
    private MyNumber number;

    Request(MyNumber number) {
        this.number = number;
    }

    public MyNumber getNumber() {
        return number;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class PositiveHandler extends Handler {
    PositiveHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        int data=Integer.parseInt(request.getNumber().getValue());
        if(data>=0){
            request.getNumber().setType("Positive");
        }
        
        super.handle(request);
    }
}

class NegativeHandler extends Handler {
    NegativeHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int data=Integer.parseInt(request.getNumber().getValue());
        if(data<0){
            request.getNumber().setType("Negative");
        }
        super.handle(request);
    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int data=Integer.parseInt(request.getNumber().getValue());
        if(data==0){
            request.getNumber().setType("Zero");
        }
        super.handle(request);
    }
}
class ExceptionHandler extends Handler {
    ExceptionHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try{
            int data=Integer.parseInt(request.getNumber().getValue());
        }catch(Exception e){
            request.getNumber().setType("Not a Number");
        }
 
        super.handle(request);
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new PositiveHandler(new NegativeHandler(new ZeroHandler(new ExceptionHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainedNUmberHandlers {
    public static void main(String[] args) {
        MyNumber number = new MyNumber();
        number.setValue("tete");
        Request request = new Request(number);

        Chain numberBuildingChain = new Chain();
        numberBuildingChain.initiateChain(request);

        System.out.println(request.getNumber());
    }
}

[Ashritha-sd]

class MyNumber {
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }
}

class Request {
    private MyNumber myNumber;

    Request(MyNumber myNumber) {
        this.myNumber = myNumber;
    }

    public MyNumber getNumber() {
        return myNumber;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class MyParseInt
{
    static int checkNumber(String val)
    {
        if(val.matches("^-[1-9][0-9]*"))
            return -1;
        if(val.matches("^[+]?[1-9][0-9]*"))
            return 1;
        if(val.matches("0"))
            return 0;
        return 2;
    }
}
class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int res=MyParseInt.checkNumber(request.getNumber().getValue());
        if(res==-1)
        {
            System.out.println("Negative number ");
        }
        else
        super.handle(request);

    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int res=MyParseInt.checkNumber(request.getNumber().getValue());
        if(res==0)
        {
            System.out.println(" number is zero ");
        }
        else
        super.handle(request);
    }
}

class PositiveNumberHandler extends Handler {

    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int res=MyParseInt.checkNumber(request.getNumber().getValue());
        if(res==1)
        {
            System.out.println("Positive number ");
        }
        else
        super.handle(request);
    }
}

class NotAnIntegerHandler extends Handler {
    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        System.out.println("not an integer");
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NegativeNumberHandler(new ZeroHandler(new PositiveNumberHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

class ChainedNumberHandler {
    public static void main(String[] args) {
        MyNumber myNumber = new MyNumber();
        Request request = new Request(myNumber);
        myNumber.setValue("-3");

        Chain numberChain = new Chain();
        numberChain.initiateChain(request);

        System.out.println(request.getNumber());
    }
}

[rakeshGit419]

class MyNumber{
    private String value;

    public MyNumber() {
    }

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }
}

class Request{
    private MyNumber myNumber;

    Request(MyNumber myNumber) {
        this.myNumber = myNumber;
    }

    public MyNumber getNumber() {
        return myNumber;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        String n = request.getNumber().getValue();
        if(n.matches("^[-]\\d+")) System.out.println("negative");
        super.handle(request);
    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        String n = request.getNumber().getValue();
        if(n.equals("0")) System.out.println("Zero");
        super.handle(request);
    }
}

class PositiveNumberHandler extends Handler {
    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        String n = request.getNumber().getValue();
        if(!(n.equals("0")) && n.matches("\\d+")) System.out.println("positive");
        super.handle(request);
    }
}

class NotAnIntegerHandler extends Handler {
    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        String n = request.getNumber().getValue();
        if((!(n.equals("0"))) && (!n.matches("\\d+")) &&(!n.matches("^[-]\\d+")))
            throw new NumberFormatException("Invalid Number");
        super.handle(request);
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NegativeNumberHandler(new ZeroHandler(new PositiveNumberHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

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

        MyNumber myNumber = new MyNumber("0a");
        Request request = new Request(myNumber);
        try{
        Chain myNumberBuildingChain = new Chain();
        myNumberBuildingChain.initiateChain(request);

        System.out.println(request.getNumber());
        }catch(NumberFormatException e){
            System.out.println(e);
        }
    }
}

[SrideviYamala]

package patterns;

class MyNumber {
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }

}

class Request {
    private MyNumber myNumber;

    Request(MyNumber myNumber) {
        this.myNumber = myNumber;
    }

    public MyNumber getNumber() {
        return myNumber;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {

    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int num = Integer.parseInt(request.getNumber().getValue());
        if (num < 0) {
            System.out.println("NegativeNumber : " + num);
        } else {
            super.handle(request);
        }
    }
}

class ZeroHandler extends Handler {

    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int num = Integer.parseInt(request.getNumber().getValue());

        if (num == 0) {
            System.out.println("ZeroNumber : " + num);
        } else {
            super.handle(request);
        }
    }

}

class PositiveNumberHandler extends Handler {

    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int num = Integer.parseInt((request).getNumber().getValue());

        if (num > 0) {
            System.out.println("PostiveNumber : " + num);
        } else {
            super.handle(request);
        }
    }

}

class NotAnIntegerHandler extends Handler {

    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int num = Integer.parseInt(request.getNumber().getValue());
        } catch (Exception e) {
            System.out.printf("%s is not a valid number",request.getNumber().getValue());
        }
        super.handle(request);
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NegativeNumberHandler(
                new ZeroHandler(new PositiveNumberHandler(
                new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainOfResponsibility {
    public static void main(String[] args) {
        MyNumber myNumber = new MyNumber("10.23");
        Request request = new Request(myNumber);

        try {
            Chain numberBuilder = new Chain();
            numberBuilder.initiateChain(request);
        } catch (Exception e) {
            System.out.println(request.getNumber());
        }
    }
}

[Sarfinaa]

package week_6;

class MyNumber {
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }

}

class Request {
    private MyNumber number;

    Request(MyNumber number) {
        this.number = number;
    }

    public MyNumber getNumber() {
        return this.number;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) throws NumberFormatException {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }

}

class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) throws NumberFormatException {
        if (request.getNumber().getValue().matches("^-[1-9][0-9]*")) {
            System.out.println("Negative  Number");
        } else {
            super.handle(request);
        }
    }
}

class PositiveNumberHandler extends Handler {
    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) throws NumberFormatException {
        if (request.getNumber().getValue().matches("^[+]?[1-9][0-9]*")) {
            System.out.println("Positive  Number");
        } else {
            super.handle(request);
        }
    }
}

class ZeroNumberHandler extends Handler {
    ZeroNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) throws NumberFormatException {
        if (request.getNumber().getValue().equals("0")) {
            System.out.println("Zero Number");
        } else {
            super.handle(request);
        }
    }
}

class NotAnIntegerHandler extends Handler {
    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) throws NumberFormatException {
        if (!request.getNumber().getValue().matches("^[+-]?[0-9]+")) {
            throw new NumberFormatException("Not a number");

        } else {
            System.out.println("4");

            super.handle(request);
        }
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NotAnIntegerHandler(
                new NegativeNumberHandler(new PositiveNumberHandler(new ZeroNumberHandler(null))));
    }

    public void initiateChain(Request request) throws NumberFormatException {
        firstHandler.handle(request);
    }
}

public class ChainOfResponsibility {
    public static void main(String[] args) {
        MyNumber number = new MyNumber();
        number.setValue("abc");
        try {
            Request request = new Request(number);
            Chain carBuildingChain = new Chain();
            carBuildingChain.initiateChain(request);
            System.out.println(request.getNumber());
        } catch (NumberFormatException e) {
            System.out.println(e);
        }
    }
}

[shreiyarandive]

class MyNumber {
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }
}

class Request {
    private MyNumber number;

    public Request(MyNumber number) {
        this.number = number;
    }

    public MyNumber getNumber() {
        return number;
    }

}

abstract class Handler {
    protected Handler nextHandler;

    public Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {

    public NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (request.getNumber().getValue().matches("-[1-9][0-9]*")) {
            System.out.println("Number is Negative");
        } else {
            super.handle(request);
        }
    }

}

class ZeroHandler extends Handler {

    public ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (request.getNumber().getValue().equals("0")) {
            System.out.println("Number is zero");
        } else {
            super.handle(request);
        }
    }

}

class PositiveNumberHandler extends Handler {

    public PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (request.getNumber().getValue().matches("[1-9][0-9]*")) {
            System.out.println("Number is Positive");
        } else {
            super.handle(request);
        }
    }

}

class NotAnIntegerHandler extends Handler {

    public NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (!request.getNumber().getValue().matches("//d+")) {
            throw new NumberFormatException("Not an Integer");
        } else {
            super.handle(request);
        }

    }

}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NegativeNumberHandler(
                new PositiveNumberHandler(new ZeroHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainOfResponsibility {
    public static void main(String[] args) {
        MyNumber number = new MyNumber("-5");
        Request request = new Request(number);

        Chain numberChain = new Chain();
        numberChain.initiateChain(request);

        System.out.println(request.getNumber());

    }
}

[Samyuktha26]

package March24;

class MyNumber {
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return super.toString();
    }

}

class Request {
    private MyNumber myNumber;

    Request(MyNumber myNumber) {
        this.myNumber = myNumber;
    }

    public MyNumber getNumber() {
        return myNumber;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int data = Integer.parseInt(request.getNumber().getValue());
        if (data < 0) {
            System.out.println("Negative");
        }
        super.handle(request);

    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int data = Integer.parseInt(request.getNumber().getValue());
        if (data == 0) {
            System.out.println("Zero");
        }

        super.handle(request);
    }
}

class PositiveNumberHandler extends Handler {
    // private Random rand = new Random();

    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int data = Integer.parseInt(request.getNumber().getValue());
        if (data > 0) {
            System.out.println("Positive");
        }
        super.handle(request);
    }
}

class NotAnIntegerHandler extends Handler {
    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        int data = Integer.parseInt(request.getNumber().getValue());
        if (!(data >= 48 && data <= 57)) {
            System.out.println("Not a Number");
        }

        super.handle(request);
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NegativeNumberHandler(new ZeroHandler(new PositiveNumberHandler(null)));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainedNumberHandlers {
    public static void main(String[] args) {
        MyNumber myNumber = new MyNumber("-4");
        Request request = new Request(myNumber);

        Chain carBuildingChain = new Chain();
        carBuildingChain.initiateChain(request);

        System.out.println(request.getNumber());
    }
}

[Samyuktha26]

Not sure about NotAnIntegerHandler class sir .....thought of checking the value with ascii value

[deepak775035]

class MyNumber{
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }
    
}


class Request{

    MyNumber myNumber;
    public Request(MyNumber myNumber) {
        this.myNumber=myNumber;
    }

    MyNumber getNumber(){
        return myNumber;
    }
    
}

abstract class Handler{
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler{

    public NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (request.getNumber().getValue().matches("^-[0-9]+")) {
            System.out.println("Negative  Number");
        } else
            super.handle(request);
    }
    
    
}

class ZeroHandler extends Handler{

    public ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }
    
    @Override
    public void handle(Request request) {
        if (
           // request.getNumber().getValue().equals("0")
            
            request.getNumber().getValue().matches("[^1-9]+")
        ) {
            System.out.println("Zero Number");
        } else
            super.handle(request);
    }
}

class PositiveNumberHandler extends Handler{

    public PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }
    
    @Override
    public void handle(Request request) {
        if (request.getNumber().getValue().matches("^[+]?[1-9]+")) {
            System.out.println("Positive  Number");
        } else
            super.handle(request);
    }
}


class NotAnIntegerHandler extends Handler{

    public NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }
    
    @Override
    public void handle(Request request) {
        if (!request.getNumber().getValue().matches("^[+-]?[0-9]+")) {
            System.out.println("Not a Number");

        } else
            super.handle(request);
    }
}


class Chain{
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NotAnIntegerHandler(new PositiveNumberHandler(new ZeroHandler(new NegativeNumberHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}


public class ChainOfResponsibilityDriver {
    public static void main(String[] args) {
        MyNumber myNumber = new MyNumber("00sdgs0000");
        Request request = new Request(myNumber);

        Chain numberCheckingChain = new Chain();
        numberCheckingChain.initiateChain(request);

        System.out.println(request.getNumber().getValue());


    }
}

[ratnadeepikavuddagiri]

package BehavioralPattern;

class MyNumber {
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }
}

class Request {
    private MyNumber myNumber;
    
    public Request(MyNumber myNumber) {
        this.myNumber = myNumber;
    }

    public MyNumber getNumber() {
        return this.myNumber;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if(request.getNumber().getValue().equals("0"))
            System.out.println("Zero");
        else 
                super.handle(request);
    }
}

class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if(request.getNumber().getValue().matches("-[1-9][0-9]*"))
                System.out.println("Negative Number");
        else 
            super.handle(request);
    }
}

class PositiveNumberHandler extends Handler {

    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if(request.getNumber().getValue().matches("\\d+"))
            System.out.println("Positive Number");
        else 
            super.handle(request);
    }
}

class NotAnIntegerHandler extends Handler {

    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
            System.out.println("Not an Integer");
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new ZeroHandler(new NegativeNumberHandler(new PositiveNumberHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        String str = "1";
        MyNumber myNumber = new MyNumber(str);
        Request request = new Request(myNumber);

        Chain myNumberBuildingChain = new Chain();
        myNumberBuildingChain.initiateChain(request);

        System.out.println(request.getNumber());
    }
}

[Batchusatyasri]

class MyNumber {
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }
}

class Request {
    private MyNumber num;

    Request(MyNumber num) {
        this.num = num;
    }

    public MyNumber getNumber() {
        return num;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int k = Integer.parseInt(request.getNumber().getValue());
            if (k < 0)
                System.out.println("Negative number : " + k);
            else
                super.handle(request);
        } catch (NumberFormatException e) {
            System.out.println(e);
        }
    }
}

class PositiveNumberHandler extends Handler {
    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int h = Integer.parseInt(request.getNumber().getValue());
            if (h > 0) {
                System.out.println("Positive number :" + h);
            } else {
                super.handle(request);
            }
        } catch (NumberFormatException e) {
            System.out.println(e);
        }
    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int m = Integer.parseInt(request.getNumber().getValue());
            if (m == 0) {
                System.out.println("Its Zero value :" + m);
            } else
                super.handle(request);
        } catch (NumberFormatException e) {
            System.out.println(e);
        }
    }
}

class NotanInteger extends Handler {
    NotanInteger(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        System.out.println("This is not a integer");
        super.handle(request);
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NegativeNumberHandler(
                new ZeroHandler(new PositiveNumberHandler(new NotanInteger(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        Chain chain = new Chain();
        chain.initiateChain(new Request(new MyNumber("3")));
        chain.initiateChain(new Request(new MyNumber("-3")));
        chain.initiateChain(new Request(new MyNumber("0")));
        chain.initiateChain(new Request(new MyNumber("sri")));

    }
}

[abhiraj2k]

package design_patterns.behavioural;

import java.util.regex.Pattern;

class MyNumber {
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }

}

class Request {
    MyNumber number;

    public Request(MyNumber number) {
        this.number = number;
    }

    public MyNumber getMyNumber() {
        return this.number;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    String handle(Request request) {
        if (this.nextHandler != null) {
            return nextHandler.handle(request);
        } else {
            return "Not an Integer";
        }
    }
}

class NegativeNumberHandler extends Handler {

    public NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public String handle(Request request) {
        if (Pattern.compile("-[1-9]+\\d*").matcher(request.getMyNumber().getValue()).matches()) {
            return "Negative";
        } else {
            return super.handle(request);
        }
    }
}

class PositiveNumberHandler extends Handler {

    public PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public String handle(Request request) {
        if (Pattern.compile("[1-9]+\\d*").matcher(request.getMyNumber().getValue()).matches()) {
            return "Positive";
        } else {
            return super.handle(request);
        }
    }
}

class ZeroNumberHandler extends Handler {

    public ZeroNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public String handle(Request request) {
        if (request.getMyNumber().getValue().equals("0")) {
            return "Zero";
        } else {
            return super.handle(request);

        }
    }
}

class Chain {
    Handler firstHandler;

    public Chain() {
        this.buildChain();
    }

    public void buildChain() {
        firstHandler = new NegativeNumberHandler(
                new ZeroNumberHandler(new PositiveNumberHandler(null)));
    }

    public String initiateChain(Request request) {
        return firstHandler.handle(request);
    }
}

public class ChainOfResponsibilityEg {
    public static void main(String[] args) {
        MyNumber number = new MyNumber("01032151");
        Chain chain = new Chain();
        System.out.println(chain.initiateChain(new Request(number)));
    }
}

[ShraddhaPenshanwar]

    private String value;

    public Mynumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Mynumber [value=" + value + "]";
    }

}

class Request {
    private Mynumber myNumber;

    Request(Mynumber myNumber) {
        this.myNumber = myNumber;
    }

    public MyNumber getMyNumber() {
        return myNumber;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        MyNumber num = request.getMyNumber();
        if (num.getValue().matches("-?[1-9]+")) {
            System.out.println("Negative Number");
        } else {
            super.handle(request);
        }

    }
}

class PositiveNumberHandler extends Handler {
    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        MyNumber num = request.getMyNumber();
        if (num.getValue().matches("//d+")) {
            System.out.println("Positive Number");
        } else {
            super.handle(request);
        }

    }
}

class NotANumberNumberHandler extends Handler {
    NotANumberNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        MyNumber num = request.getMyNumber();
        if (!num.getValue().matches("//d+")) {
            throw new NumberFormatException("Invalid number");
        } else {
            super.handle(request);
        }

    }
}

class PositiveNumberHandler extends Handler {
    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        MyNumber num = request.getMyNumber();
        if (num.getValue().equals("0")) {
            System.out.println("Zero");
        } else {
            super.handle(request);
        }

    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new PositiveNumberHandler(
                new NegativeNumberHandler(new ZeroHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ParseIntImplementation {
    public static void main(String[] args) {
        MyNumber num = new MyNumber("32");
        Request request = new Request(num);
        Chain myNumberChain = new Chain();
        myNumberChain.initiateChain(request);
        System.out.println(request.getMyNumber());
    }
}```

[aish955]

class MyNumber {
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }

}

class Request {
    private MyNumber mynumber;

    public Request(MyNumber mynumber) {
        this.mynumber = mynumber;
    }

    public MyNumber getNumber() {
        return mynumber;
    }
}

abstract class Handler {
    protected Handler handler;

    Handler(Handler handler) {
        this.handler = handler;
    }

    public void handle(Request request) {
        if (handler != null)
            handler.handle(request);
    }

}

class NegativeNumberHandler extends Handler {

    NegativeNumberHandler(Handler handler) {
        super(handler);
    }

    @Override
    public void handle(Request request) {
        int n = Integer.parseInt(request.getNumber().getValue());
        if (n < 0)
            System.out.println(n + " is Negative");
        super.handle(request);
    }

}

class ZeroHandler extends Handler {

    ZeroHandler(Handler handler) {
        super(handler);
    }

    @Override
    public void handle(Request request) {
        int n = Integer.parseInt(request.getNumber().getValue());
        if (n == 0)
            System.out.println(n + " is Zero");
        super.handle(request);
    }

}

class PositiveNumberHandler extends Handler {

    PositiveNumberHandler(Handler handler) {
        super(handler);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void handle(Request request) {
        int n = Integer.parseInt(request.getNumber().getValue());
        if (n > 0)
            System.out.println(n + " is Positive");
        super.handle(request);
    }

}

class NotAnIntegerHandler extends Handler {

    NotAnIntegerHandler(Handler handler) {
        super(handler);

    }

    @Override
    public void handle(Request request) {
        try {
            int n = Integer.parseInt(request.getNumber().getValue());
        } catch (Exception e) {
            System.out.println("Not an integer");

        }
        super.handle(request);
    }

}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new PositiveNumberHandler(new ZeroHandler(new NegativeNumberHandler(null)));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class PardeIntChainOfResponsibility {
    public static void main(String[] args) {
        MyNumber mynumber = new MyNumber("-13");

        Request request = new Request(mynumber);
        Chain parsing = new Chain();
        parsing.initiateChain(request);

    }
}

[Amrit-Raj22]

class MyNumber {
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }

}

class Request {
    MyNumber myNumber;

    public Request(MyNumber myNumber) {
        this.myNumber = myNumber;
    }

    public MyNumber getMyNumber() {
        return myNumber;
    }

}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request req) {
        if (nextHandler != null) {
            nextHandler.handle(req);
        }
    }
}

class NegativeHandler extends Handler {
    NegativeHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        if (Integer.parseInt(request.getMyNumber().getValue()) < 0) {
            System.out.println("Negative");
        } else {
            super.handle(request);
        }
    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        if (request.getMyNumber().getValue().matches("0")) {
            System.out.println("zero");
        } else {
            super.handle(request);
        }
    }
}

class PositiveHandler extends Handler {
    PositiveHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        if (Integer.parseInt(request.getMyNumber().getValue()) > 0) {
            System.out.println("POSITIVE");
        } else {
            super.handle(request);
        }
    }
}

class NotNum extends Handler {
    NotNum(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        if (!request.getMyNumber().getValue().matches("//d+")) {
            throw new IllegalArgumentException("NOT NUM");

        } else {
            super.handle(request);
        }
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NegativeHandler(new PositiveHandler(new ZeroHandler(new NotNum(null))));
    }

    public void makeChain(Request request) {
        firstHandler.handle(request);
    }
}

public class MatchedNumberChain {
    public static void main(String[] args) {
        MyNumber number1 = new MyNumber("0");
        MyNumber number2 = new MyNumber("22");
        Request request1 = new Request(number1);
        Request request2 = new Request(number2);
        Chain chain = new Chain();
        chain.makeChain(request1);
        chain.makeChain(request2);

    }
}

[sruthi-15-sketch]

package DESIGNPATTERNS.BehavioralPatterns;

class MyNumber {
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }
}

class Request {
    private MyNumber v;

    Request(MyNumber v) {
        this.v = v;
    }

    public MyNumber getV() {
        return v;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }

    public int ConvertStringToInt(String s) throws NumberFormatException {
        int num = 0;
        for (int i = 0; i < s.length(); i++) {
            if (((int) s.charAt(i) >= 48) && ((int) s.charAt(i) <= 57)) {
                num = num * 10 + ((int) s.charAt(i) - 48);
            } else {
                throw new NumberFormatException();
            }

        }
        return num;
    }

}

class PositiveNumberHandler extends Handler {
    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int data = ConvertStringToInt(request.getV().getValue());
            if (data > 0) {
                System.out.println("Positive Number");
            } else
                super.handle(request);
        } catch (Exception e) {
            super.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int data = Integer.parseInt(request.getV().getValue());
            if (data < 0) {
                System.out.println("Negative Number");
            } else
                super.handle(request);
        } catch (Exception e) {
            super.handle(request);
        }
    }
}

class ZeroNumberHandler extends Handler {
    ZeroNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int data = ConvertStringToInt(request.getV().getValue());
            if (data == 0) {
                System.out.println("Zero Number");
            } else
                super.handle(request);
        } catch (Exception e) {
            super.handle(request);
        }
    }
}

class NotAnIntegerHandler extends Handler {
    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int data = ConvertStringToInt(request.getV().getValue());

        } catch (Exception e) {
            System.out.println(request.getV() + " is not an integer");
        }
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new PositiveNumberHandler(
                new NegativeNumberHandler(new ZeroNumberHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        MyNumber number = new MyNumber();
        number.setValue("hi");
        Request request = new Request(number);
        Chain myNumberChain = new Chain();
        myNumberChain.initiateChain(request);
        System.out.println(request.getV());
    }
}

[vysh675]

class MyNumber
{
    private String value;
    MyNumber(String value)
    {
        this.value=value;
    }
    void setvalue(String value)
    {
        this.value=value;
    }
    String getvalue()
    {
        return value;
    }
    public String toString()
    {
        return "value="+value;
    }
}
class Request {
    private MyNumber mynumber;

    Request(MyNumber mynumber) {
        this.mynumber =mynumber ;
    }

    public MyNumber getNumber() {
        return mynumber;
    }
}
abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
         if (request.getNumber().getvalue().equals("0")) {
            System.out.println("zero");

        } else {
            super.handle(request);
        }
    }
}

class PositiveNumberHandler extends Handler {
   PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (request.getNumber().getvalue().matches("[\\d+]")) {
            System.out.println("Positive Number");

        } else {
            super.handle(request);
        }
    }
}

class NotAnIntegerHandler extends Handler {

    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
         if (!request.getNumber().getvalue().matches("//d+")) {
            throw new NumberFormatException("Invalid number");

        } else {
            super.handle(request);
        }
    }
}
class NegativeNumberHandler extends Handler {

    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
         if (request.getNumber().getvalue().matches("-?[1-9]+")) {
            System.out.println("negative Number");

        } else {
            super.handle(request);
        }
    }
}
class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
     this.firstHandler = new PositiveNumberHandler(
                new NegativeNumberHandler(new ZeroHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}
public class chaindemo
{
	public static void main(String[] args) {
		 MyNumber number = new MyNumber("6");
        Request request = new Request(number);

        Chain chain = new Chain();
        chain.initiateChain(request);

        System.out.println(request.getNumber());
    }
}

[Prem-3]

class MyNumber {
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }

}

class Request {
    private MyNumber number;

    Request(MyNumber number) {
        this.number = number;
    }

    public MyNumber getNumber() {
        return number;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}
class NegativeNumberHandler extends Handler{
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);


    }
}
class PositiveNumberHandler extends Handler{
    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);


    }
}
class ZeroHandler extends Handler{
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);


    }
}
class NotAnIntegerHandler extends Handler{
    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);


    }
}
class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();

        
    }
}

[amruth2211]

package DesignPatterns;

class MyNumber {
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }
}

class Request {
    private MyNumber v;

    Request(MyNumber v) {
        this.v = v;
    }

    public MyNumber getV() {
        return v;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }

    public int stringToInt(String s) throws NumberFormatException {
        int num = 0;
        for (int i = 0; i < s.length(); i++) {
            int a = s.charAt(i);
            if ((a >= 48) && (a <= 57)) {
                num = num * 10 + (a - 48);
            } else {
                throw new NumberFormatException();
            }

        }
        return num;
    }

}

class PositiveNumberHandler extends Handler {
    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int data = stringToInt(request.getV().getValue());
            if (data > 0) {
                System.out.println("Positive Number");
            } else
                super.handle(request);
        } catch (Exception e) {
            super.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int data = Integer.parseInt(request.getV().getValue());
            if (data < 0) {
                System.out.println("Negative Number");
            } else
                super.handle(request);
        } catch (Exception e) {
            super.handle(request);
        }
    }
}

class ZeroNumberHandler extends Handler {
    ZeroNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int data = stringToInt(request.getV().getValue());
            if (data == 0) {
                System.out.println("Zero Number");
            } else
                super.handle(request);
        } catch (Exception e) {
            super.handle(request);
        }
    }
}

class NotAnIntegerHandler extends Handler {
    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        try {
            int data = stringToInt(request.getV().getValue());

        } catch (Exception e) {
            System.out.println(request.getV() + " is not an integer");
        }
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new PositiveNumberHandler(
                new NegativeNumberHandler(new ZeroNumberHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainOfresponsibility {
    public static void main(String[] args) {
        MyNumber number = new MyNumber();
        number.setValue("-1");
        Request request = new Request(number);

        Chain myNumberChain = new Chain();
        myNumberChain.initiateChain(request);

        System.out.println(request.getV());
    }
}

[DivikaAgrawal]

import java.util.*;

class Mynumber {
    private String value;

    public Mynumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Mynumber [value=" + value + "]";
    }

}

class Request {
    private Mynumber mynumber;

    Request(Mynumber mynumber) {
        this.mynumber = mynumber;
    }

    public Mynumber getMyNumber() {
        return mynumber;
    }

}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {

    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        int num = Integer.parseInt(request.getMyNumber().getValue());
        if (num < 0) {
            System.out.println("Number is negative");
        } else {
            super.handle(request);
        }
    }
}

class ZeroHandler extends Handler {

    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        int num = Integer.parseInt(request.getMyNumber().getValue());
        if (num == 0) {
            System.out.println("Number is zero");
        } else {
            super.handle(request);
        }
    }
}

class PositiveNumberHandler extends Handler {

    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        int num = Integer.parseInt(request.getMyNumber().getValue());
        if (num > 0) {
            System.out.println("Number is positive");
        } else {
            super.handle(request);
        }
    }
}

class NotAnIntegerHandler extends Handler {

    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {

        if (!request.getMyNumber().getValue().matches("//d+")) {
            System.out.println("Number is non Integer");
        } else {
            super.handle(request);
        }
    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NegativeNumberHandler(
                new PositiveNumberHandler(new ZeroHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

class ChainofResponsibility {
    public static void main(String[] args) {
        Mynumber mynumber = new Mynumber("5");
        Request request = new Request(mynumber);
        Chain numberChain = new Chain();
        numberChain.initiateChain(request);
        System.out.println(request.getMyNumber());

    }
}

[Harshita-Joshi]

class MyNumber{
    private String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return super.toString();
    }
    
}


class Request{
    private MyNumber myNumber;

    public Request(MyNumber myNumber) {
        this.myNumber = myNumber;
    }

    public MyNumber getNumber() {
        return myNumber;
    }

}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler{

    public NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public void handle(Request request){

        if(isNegative(request.getNumber().getValue())){
            System.out.println("The number entered is negative!!");
        }else{
            super.handle(request);
        }
       
    }

    boolean isNegative(String num){
        
       if(num.charAt(0)!='-')
        return false;
        
        for(int i=1; i<num.length(); i++){
            if(num.charAt(i)<='0' || num.charAt(i)>='9')
                return false; 
        }

        return true; 

    }

}

class ZeroHandler extends Handler{

    public ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public void handle(Request request){
        
        if(isZero(request.getNumber().getValue())){
            System.out.println("The number entered is zero!!");
        }else{
            super.handle(request);
        }

    }

    boolean isZero(String num){
        
        return (num.length()==1 && num.charAt(0)=='0'); 
    }

}

class PositiveNumberHandler extends Handler{

    public PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public void handle(Request request){

        if(isPositive(request.getNumber().getValue())){
            System.out.println("The number entered is positive!!");
        }else{
            super.handle(request);
        }

    }

    boolean isPositive(String num){
        
        for(int i=0; i<num.length(); i++){
            if(num.charAt(i)<='0' || num.charAt(i) >= '9')
                return false;
        }

          return true;
    }


}

class NotAnIntegerHandler extends Handler{

    public NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public void handle(Request request){
        
        throw new NumberFormatException("Not an integer!!");

    }

}

class HandlingInAction{
    Handler firstHandler;
 
    HandlingInAction(){
        buildChain();
    }
 
    private void buildChain(){
            this.firstHandler = new NegativeNumberHandler(new ZeroHandler(new PositiveNumberHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}


public class ChainOfResponsibility {
 public static void main(String[] args) {
     
        Request request = new Request(new MyNumber("1234"));

        HandlingInAction chain = new HandlingInAction();
        chain.initiateChain(request);

        System.out.println(request.getNumber().getValue());


        Request request2 = new Request(new MyNumber("-1234"));
        HandlingInAction chain2 = new HandlingInAction();
        chain2.initiateChain(request2);
        System.out.println(request2.getNumber().getValue());


        Request request3 = new Request(new MyNumber("0"));
        HandlingInAction chain3 = new HandlingInAction();
        chain3.initiateChain(request3);
        System.out.println(request3.getNumber().getValue());

        Request request4 = new Request(new MyNumber("123abc"));
        HandlingInAction chain4 = new HandlingInAction();
        chain4.initiateChain(request4);
        System.out.println(request4.getNumber().getValue());

 }   
}

[nikhil95301]

class MyNumber {
private String value;

public MyNumber(String value) {
    this.value = value;
}

public String getValue() {
    return value;
}

public void setValue(String value) {
    this.value = value;
}

@Override
public String toString() {
    return "MyNumber [value=" + value + "]";
}

}

class Request {
private MyNumber myNumber;

public Request(MyNumber myNumber) {
    this.myNumber = myNumber;
}

public MyNumber getMyNumber() {
    return myNumber;
}

}

abstract class Handler {
protected Handler nextHandler;

Handler(Handler nextHandler) {
    this.nextHandler = nextHandler;
}

public void handle(Request request) {
    if (nextHandler != null) {
        nextHandler.handle(request);
    }
}

}

class NegativeNumberHandler extends Handler {
NegativeNumberHandler(Handler nextHandler) {
super(nextHandler);
}

@Override
public void handle(Request request) {
    try {
        int data = Integer.parseInt(request.getMyNumber().getValue());
        if (data < 0)
            System.out.println("Negative Number");
        else
            super.handle(request);
    } catch (NumberFormatException e) {
        System.out.println(e);
    }

}

}

class ZeroHandler extends Handler {
ZeroHandler(Handler nextHandler) {
super(nextHandler);
}

@Override
public void handle(Request request) {
    try {
        int data = Integer.parseInt(request.getMyNumber().getValue());
        if (data == 0)
            System.out.println("Zero Number");
        else
            super.handle(request);
    } catch (NumberFormatException e) {
        System.out.println(e);
    }
}

}

class PositiveNumberHandler extends Handler {
PositiveNumberHandler(Handler nextHandler) {
super(nextHandler);
}

@Override
public void handle(Request request) {
    try {
        int data = Integer.parseInt(request.getMyNumber().getValue());
        if (data > 0)
            System.out.println("Positive Number");
        else
            super.handle(request);
    } catch (NumberFormatException e) {
        System.out.println(e);
    }

}

}

class NotAnIntegerHandler extends Handler {
NotAnIntegerHandler(Handler nextHandler) {
super(nextHandler);
}

@Override
public void handle(Request request) throws NumberFormatException {
    try {
        int data = Integer.parseInt(request.getMyNumber().getValue());
        super.handle(request);

    } catch (NumberFormatException e) {
        System.out.println("This is not a Number");
    }

}

}

class Chain {
Handler firstHandler;

public Chain() {
    buildChain();
}

private void buildChain() {
    this.firstHandler = new NotAnIntegerHandler(
            new ZeroHandler(new PositiveNumberHandler(new NegativeNumberHandler(null))));
}

public void verify(Request request) {
    firstHandler.handle(request);
}

}

class ChainOfResponsibility {
public static void main(String[] args) {
MyNumber number = new MyNumber("Hello");
Request request = new Request(number);

    Chain numbercheck = new Chain();
    numbercheck.verify(request);

}

}

[RohitN09]

package design_patterns.behavioural_patterns;

class MyNumber {
    private String value;

    MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }
}

class RequestNumber {
    private MyNumber myNumber;

    RequestNumber(MyNumber myNumber) {
        this.myNumber = myNumber;
    }

    public MyNumber getMyNumber() {
        return myNumber;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(RequestNumber request) {
        if (nextHandler != null)
            nextHandler.handle(request);
    }
}

class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(RequestNumber request) {
        if (request.getMyNumber().getValue().matches("-\\d+"))
            System.out.println("Negative Number");
        else
            super.handle(request);
    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(RequestNumber request) {
        if (request.getMyNumber().getValue().matches("0+"))
            System.out.println("Zero");
        else
            super.handle(request);
    }
}

class PositiveNumberHandler extends Handler {
    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(RequestNumber request) {
        if (request.getMyNumber().getValue().matches("[1-9]\\d+"))
            System.out.println("Positive Number");
        else
            super.handle(request);
    }
}

class NotAnIntegerHandler extends Handler {
    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(RequestNumber request) {
        throw new NumberFormatException("Value is not an integer!!");
    }
}

class ChainNumber {
    Handler firstHandler;

    ChainNumber() {
        buildChain();
    }

    public void buildChain() {
        this.firstHandler = new NegativeNumberHandler(
                new ZeroHandler(new PositiveNumberHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(RequestNumber request) {
        firstHandler.handle(request);
    }
}

public class MyParseInt {
    public static void main(String[] args) {
        MyNumber myNumber = new MyNumber("20");
        RequestNumber request = new RequestNumber(myNumber);

        ChainNumber myNumberChain = new ChainNumber();
        myNumberChain.initiateChain(request);

    }
}

[PavanArvapally]

package Design_Pattern.Behavioral_pattern;

class MyNumber{
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }
}

class Request{
    private MyNumber number;

    Request(MyNumber number) {
        this.number = number;
    }

    public MyNumber getNumber() {
        return number;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler{

    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public void handle(Request request){
            System.out.println("Negative number");
    }

}

class ZeroHandler extends Handler{

    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public void handle(Request request){
        int number = Integer.parseInt(request.getNumber().getValue());
        if(number == 0){
            System.out.println("The number is Zero");
        }
        else{
            super.handle(request);
        }
    }

}

class PositiveNumberHandler extends Handler
{

    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public void handle(Request request){
        int number = Integer.parseInt(request.getNumber().getValue());
        if(number>0){
            System.out.println("Positive number");
        }
        else{
            super.handle(request);
        }
    }

}

class NotAnIntegerHandler extends Handler{

    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    public void handle(Request request){
        try {
            int number = Integer.parseInt(request.getNumber().getValue());
            super.handle(request);
        } catch (NumberFormatException e) {
            System.out.println("Not an integer");
        }
    }

}

class Chain{
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new NotAnIntegerHandler(new ZeroHandler(new PositiveNumberHandler(new NegativeNumberHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainOfResponsibility {
    public static void main(String[] args) {
        MyNumber number = new MyNumber();
        Request request = new Request(number);
        number.setValue("68");

        Chain chain = new Chain();
        chain.initiateChain(request);

        System.out.println(request.getNumber());
    }
}

[hemanth409]

class MyNumber{
private String value;

public MyNumber() {
}

public MyNumber(String value) {
    this.value = value;
}

public String getValue() {
    return value;
}

public void setValue(String value) {
    this.value = value;
}

@Override
public String toString() {
    return "MyNumber [value=" + value + "]";
}

}

class Request{
private MyNumber myNumber;

Request(MyNumber myNumber) {
    this.myNumber = myNumber;
}

public MyNumber getNumber() {
    return myNumber;
}

}

abstract class Handler {
protected Handler nextHandler;

Handler(Handler nextHandler) {
    this.nextHandler = nextHandler;
}

public void handle(Request request) {
    if (nextHandler != null) {
        nextHandler.handle(request);
    }
}

}

class NegativeNumberHandler extends Handler {
NegativeNumberHandler(Handler nextHandler) {
super(nextHandler);
}

@Override
public void handle(Request request) {
    String n = request.getNumber().getValue();
    if(n.matches("^[-]\\d+")) System.out.println("negative");
    super.handle(request);
}

}

class ZeroHandler extends Handler {
ZeroHandler(Handler nextHandler) {
super(nextHandler);
}

@Override
public void handle(Request request) {
    String n = request.getNumber().getValue();
    if(n.equals("0")) System.out.println("Zero");
    super.handle(request);
}

}

class PositiveNumberHandler extends Handler {
PositiveNumberHandler(Handler nextHandler) {
super(nextHandler);
}

@Override
public void handle(Request request) {
    String n = request.getNumber().getValue();
    if(n.matches("\\d+")) System.out.println("positive");
    super.handle(request);
}

}

class NotAnIntegerHandler extends Handler {
NotAnIntegerHandler(Handler nextHandler) {
super(nextHandler);
}

@Override
public void handle(Request request) {
    String n = request.getNumber().getValue();
    if((!(n.equals("0"))) && (!n.matches("\\d+")) &&(!n.matches("^[-]\\d+")))
        throw new NumberFormatException("Invalid Number");
    super.handle(request);
}

}

class Chain {
Handler firstHandler;

Chain() {
    buildChain();
}

private void buildChain() {
    this.firstHandler = new NegativeNumberHandler(new ZeroHandler(new PositiveNumberHandler(new NotAnIntegerHandler(null))));
}

public void initiateChain(Request request) {
    firstHandler.handle(request);
}

}

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

    MyNumber myNumber = new MyNumber("409");
    Request request = new Request(myNumber);
    try{
    Chain myNumberBuildingChain = new Chain();
    myNumberBuildingChain.initiateChain(request);

    System.out.println(request.getNumber());
    }catch(NumberFormatException e){
        System.out.println("Invalid Number");
    }
}

}

[ujjwal18bit1167]

class MyNumber {
    String value;

    public MyNumber(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyNumber [value=" + value + "]";
    }

}

class Request {
    private MyNumber number;

    Request(MyNumber number) {
        this.number = number;
    }

    public MyNumber getNumber() {
        return number;
    }
}

abstract class Handler {
    protected Handler nextHandler;

    Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle(Request request) {
        if (nextHandler != null) {
            nextHandler.handle(request);
        }
    }
}

class NegativeNumberHandler extends Handler {
    NegativeNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (request.getNumber().getValue().matches("-[1-9][0-9]*")) {
            System.out.println("Negative Number");

        } else {
            super.handle(request);
        }

    }
}

class NotAnIntegerHandler extends Handler {
    NotAnIntegerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (!request.getNumber().getValue().matches("//d+")) {
            throw new NumberFormatException("Invalid number");

        } else {
            super.handle(request);
        }

    }
}

class PositiveNumberHandler extends Handler {
    PositiveNumberHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (request.getNumber().getValue().matches("[1-9][0-9]*")) {
            System.out.println("Positive Number");

        } else {
            super.handle(request);
        }

    }
}

class ZeroHandler extends Handler {
    ZeroHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handle(Request request) {
        if (request.getNumber().getValue().equals("0")) {
            System.out.println("Zero Number");

        } else {
            super.handle(request);
        }

    }
}

class Chain {
    Handler firstHandler;

    Chain() {
        buildChain();
    }

    private void buildChain() {
        this.firstHandler = new PositiveNumberHandler(
                new NegativeNumberHandler(new ZeroHandler(new NotAnIntegerHandler(null))));
    }

    public void initiateChain(Request request) {
        firstHandler.handle(request);
    }
}

public class ChainOfResponsibilityDesignPatternDemo {
    public static void main(String[] args) {
        MyNumber number = new MyNumber("-8");
        Request request = new Request(number);

        Chain carBuildingChain = new Chain();
        carBuildingChain.initiateChain(request);

        System.out.println(request.getNumber());
    }
}