Task - Design Patterns - Factory Method #60

akash-coded · 2022-03-22T08:20:46Z

akash-coded
Mar 22, 2022
Maintainer

Implement Factory Method Design Pattern

Declare an interface names MyWrapper as follows:

interface MyWrapper {
    void printType();
}

Implement the interface in the following concrete classes:

MyInteger
MyDouble
MyBoolean
MyCharacter

The concrete methods in these classes just print the name of the class with a message, e.g., "The value is of type: MyInteger".

Create a factory class called MyWrapperFactory with the method:

class MyWrapperFactory{
    public MyWrapper getMyWrapperInstance(String value) {
        // return the wrapper instance corresponding to the type of value
    }
}

The getMyWrapperInstance method returns an instance of one of the four concrete classes or null, depending on the type of the parameter value. Write custom logic and process the string to find out the type of value. If the value is of undefined/unknown type, throw IllegalArgumentException with the message "Value format not recognized".

String processing logic to Implement in the factory method:

If the value string contains only digits, without any other types of characters, return an instance of MyInteger.
If the value string contains either true or false in all lowercase, return an instance of MyBoolean.
If the value string contains only digits, and a dot(.) in any position other than at first or last, then return an instance of MyDouble.
If the value string contains only a single alphabet, then return an instance of MyCharacter.

Demonstrate the working in the driver class named CustomeWrapperDriver.

Sample Inputs

value = "50"
value = "false"
value = "3.142"
value = "a"

Sample Outputs

The value is of type: `MyInteger`
The value is of type: `MyBoolean`
The value is of type: `MyDouble`
The value is of type: `MyCharacter`

Hints

Some common ASCII ranges:

Uppercase alphabets [A-Z] = [65-90]
Lowecase alphabets [a-z] = [97-122]
Digits [0-9] = [48-57]
Space (' ') = 32

Sarfinaa · 2022-03-22T08:21:59Z

Sarfinaa
Mar 22, 2022

package week_6;

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {
    public void printType() {
        System.out.println("Integer");
    }
}

class MyDouble implements MyWrapper {
    public void printType() {
        System.out.println("Double");
    }
}

class MyCharacter implements MyWrapper {
    public void printType() {
        System.out.println("Character");
    }
}

class MyBoolean implements MyWrapper {
    public void printType() {
        System.out.println("Boolean");
    }
}

class MyWrapperFactory {
    private boolean checkInteger(String type) {
        return type.matches("^[+-]?[0-9]+");

    }

    private boolean checkCharacter(String type) {
        return type.matches("[a-zA-Z]");

    }

    private boolean checkDouble(String type) {
        return type.matches("^[+-]?[0-9]+.[0-9]+");

    }

    private boolean checkBoolean(String type) {
        return type.matches("true|false");

    }

    public MyWrapper createMyWrapper(String type) {
        MyWrapper wrapper = null;
        if (type == null || type.length() == 0)
            throw new IllegalArgumentException("String is empty!!!");
        if (checkCharacter(type))
            wrapper = new MyCharacter();
        else if (checkDouble(type))
            wrapper = new MyDouble();
        else if (checkBoolean(type))
            wrapper = new MyBoolean();
        else if (checkInteger(type))
            wrapper = new MyInteger();
        else
            throw new IllegalArgumentException("Invalid type");
        return wrapper;
    }
}

public class DesignPattern {
    public static void main(String[] args) {
        MyWrapperFactory myFactory = new MyWrapperFactory();
        try {
            myFactory.createMyWrapper("1").printType();
            myFactory.createMyWrapper("1.1").printType();
            myFactory.createMyWrapper("a").printType();
            myFactory.createMyWrapper("true").printType();
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }

    }
}

0 replies

SrideviYamala · 2022-03-22T08:22:22Z

SrideviYamala
Mar 22, 2022

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Integer");
    }
}

class MyDouble implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Double");
    }
}

class MyCharacter implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Character");
    }
}

class MyBoolean implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Boolean");
    }
}

class MyWrapperFactory {
    public MyWrapper createMyWrapper(String val){
        if(val == null || val.length() == 0)
            return null;
        else if(val.matches("\\d+"))
            return new MyInteger();
        else if(val.matches("\\d+[.]\\d+"))
            return new MyDouble();
        else if(val.matches("[a-zA-Z]"))
            return new MyCharacter();
        else if("true".equals(val) || "false".equals(val))
            return new MyBoolean();
        else
            throw new IllegalArgumentException("Invalid Type");
    }
}

public class FactoryDemo {
    public static void main(String[] args) {
        MyWrapperFactory myFactory = new MyWrapperFactory();
        MyWrapper myWrapper1 = myFactory.createMyWrapper("123");
        MyWrapper myWrapper2 = myFactory.createMyWrapper("12.34");
        MyWrapper myWrapper3 = myFactory.createMyWrapper("S");
        MyWrapper myWrapper4 = myFactory.createMyWrapper("false");
        myWrapper1.printType();
        myWrapper2.printType();
        myWrapper3.printType();
        myWrapper4.printType();
    }
}

0 replies

SabaMhabar · 2022-03-22T08:22:42Z

SabaMhabar
Mar 22, 2022

interface MyWrapper {
void printType();
}

class MyInteger implements MyWrapper {

@Override
public void printType() {
    System.out.println("Integer Type");
}

}

class MyDouble implements MyWrapper {

@Override
public void printType() {
    System.out.println("Double Type");
}

}

class MyCharacter implements MyWrapper {

@Override
public void printType() {
    System.out.println("Character Type");
}

}

class MyBoolean implements MyWrapper {

@Override
public void printType() {
    System.out.println("Boolean Type");
}

}

class MyWrapperFactory {
MyWrapper getMyWrapperInstance(String s) {
if (s == null || s.isEmpty())
return null;
else if (s.equals("true") || s.equals("false"))
return new MyBoolean();
else if (s.length() == 1 && s.matches("^[a-zA-Z]"))
return new MyCharacter();
else if (s.matches("^[0-9]"))
return new MyInteger();
else if (s.matches("[0-9](.[0-9]*)?"))
return new MyDouble();
else
throw new IllegalArgumentException("Invalid input");
}
}

class PatternDriver {
public static void main(String[] args) {
MyWrapperFactory mwf = new MyWrapperFactory();
MyWrapper mw = mwf.getMyWrapperInstance("712.11");
mw.printType();

}

0 replies

Khyati-tripathi · 2022-03-22T08:22:55Z

Khyati-tripathi
Mar 22, 2022

import java.util.Scanner;

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {
    String str;

    public MyInteger(String str) {
        this.str = str;
    }

    public void printType() {
        System.out.println("The input is of type Integer and value is: " + str);
    }
}

class MyDouble implements MyWrapper {
    String str;

    public MyDouble(String str) {
        this.str = str;
    }

    public void printType() {
        System.out.println("The input is of type Double and value is: " + str);
    }
}

class MyCharacter implements MyWrapper {
    String str;

    public MyCharacter(String str) {
        this.str = str;
    }

    public void printType() {
        System.out.println("The input is of type Character and value is: " + str);
    }
}

class MyBoolean implements MyWrapper {
    String str;

    public MyBoolean(String str) {
        this.str = str;
    }

    public void printType() {
        System.out.println("The input is of type Boolean and value is: " + str);
    }
}

class MyWrapperFactory {
    public MyWrapper createMyWrapper(String input) {
        if (input == null || input.length() == 0)
            return null;
        else if (input.matches("\\d+"))
            return new MyInteger(input);
        else if (input.matches("[+-]?(\\d*[.])?\\d+"))
            return new MyDouble(input);
        else if (input.equals("true") || input.equals("false"))
            return new MyBoolean(input);
        else if (input.matches("[a-zA-Z]"))
            return new MyCharacter(input);
        else
            throw new IllegalArgumentException("Not a valid input type");
    }
}

public class CustomWrapperDriver {
    public static void main(String[] args) {
        MyWrapperFactory obj = new MyWrapperFactory();
        System.out.println("Enter a value: ");
        Scanner sc = new Scanner(System.in);
        String value = sc.nextLine();
        MyWrapper w = obj.createMyWrapper(value);
        if (w != null)
            w.printType();
        else
            System.out.println("Empty input");

    }

}

0 replies

shreiyarandive · 2022-03-22T08:22:57Z

shreiyarandive
Mar 22, 2022

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("I am an Integer");

    }
}

class MyDouble implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("I am a Double");

    }
}

class MyCharacter implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("I am a Character");

    }
}

class MyBoolean implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("I am a Boolean");

    }
}

class MyWrapperFactory {
    public MyWrapper getMyWrapperInstance(String channel) {
        if (channel == null || channel.isEmpty()) {
            return null;
        }
        System.out.println(channel);

        if (channel.matches("[a-zA-z]")) {
            return new MyCharacter();
        }

        if (channel.matches("\\d+")) {
            return new MyInteger();
        }

        if ("true".equals(channel) || "false".equals(channel)) {
            return new MyBoolean();
        }

        if (channel.matches("\\d+.\\d+")) {
            return new MyDouble();
        }

        throw new IllegalArgumentException("Unknown type of channel");
    }
}

public class FactoryMethod {
    public static void main(String[] args) {
        MyWrapperFactory myWrapperFactory = new MyWrapperFactory();

        MyWrapper obj1 = myWrapperFactory.getMyWrapperInstance("10");
        obj1.printType();
        MyWrapper obj2 = myWrapperFactory.getMyWrapperInstance("e");
        obj2.printType();
        MyWrapper obj3 = myWrapperFactory.getMyWrapperInstance("10.5");
        obj3.printType();
        MyWrapper obj4 = myWrapperFactory.getMyWrapperInstance("false");
        obj4.printType();
        MyWrapper obj5 = myWrapperFactory.getMyWrapperInstance("asfsaf");
        obj5.printType();
    }
}

0 replies

RohitNaikade1 · 2022-03-22T08:23:10Z

RohitNaikade1
Mar 22, 2022

package DesignPatterns;

interface MyWrapper{
    void printType();
}

class MyInteger implements MyWrapper{
    public void printType(){
        System.out.println("Integer type");
    }
}

class MyDouble implements MyWrapper{
    public void printType(){
        System.out.println("Double type");
    }
}

class MyCharacter implements MyWrapper{
    public void printType(){
        System.out.println("Character type");
    }
}

class MyBoolean implements MyWrapper{
    public void printType(){
        System.out.println("Boolean type");
    }
}


class MyWrapperFactory{

    public static boolean isInteger(String number){
        for(int i=0;i<number.length();i++){
            if(number.charAt(i)<48 && number.charAt(i)>57){
                return false;
            }
        }

        return true;
    }
    public static boolean isDouble(String number){
        int cnt=0;
        for(int i=0;i<number.length();i++){
            if(cnt>1 || number.charAt(i)<48 && number.charAt(i)>57){
                return false;
            }else if( number.charAt(i)=='.'){
                cnt++;
            }
        }

        return true;
    }

    public static boolean isBoolean(String number){
        if(number.toLowerCase().equals("true") || number.toLowerCase().equals("false")){
            return true;
        }
        return false;
    }
    public MyWrapper createMyWrapper(String number){

        if(isBoolean(number)){
            return new MyBoolean();
        }else if(isCharacter(number)){
            return new MyCharacter();
        }else if(isDouble(number)){
            return new MyDouble();
        }else if(isInteger(number)){
            return new MyInteger();
        }else{
            throw new IllegalArgumentException("Invalid Input"+number);
        }
    }
    private boolean isCharacter(String number) {

        if(number.length()==1 && !(number.charAt(0)>=48 && number.charAt(0)<=57)){
            return true;
        }
        return false;
    }
}
public class FactoryPattern{
    public static void main(String[] args) {
        MyWrapperFactory factory=new MyWrapperFactory();

        try{
            MyWrapper b= factory.createMyWrapper("34.67");
            b.printType();
        }catch(Exception e){
            System.out.println(e);
        }

    }
}

0 replies

preeti-max · 2022-03-22T08:23:42Z

preeti-max
Mar 22, 2022

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Integer type");

    }

}

class MyDouble implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Double type");

    }

}

class MyCharacter implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Character type");

    }

}

class MyBoolean implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Boolean type");

    }

}

class MyWrapperFactory {
    public static MyWrapper getMyWrapperInstance(String s) {
        if (s == null || s.isEmpty())
            return null;
        if (s.matches("-?\\d+")) {
            return new MyInteger();

        }
        if (s.matches("-?\\d+(\\.\\d+)?"))
            return new MyDouble();
        if (s.matches("[a-zA-Z]"))
            return new MyCharacter();
        if (s.equals("true") || s.equals("false"))
            return new MyBoolean();
        else
            throw new IllegalArgumentException("Invalid input");

    }
}

public class FactoryMethodDemo {
    public static void main(String[] args) {
            
        MyWrapperFactory.getMyWrapperInstance("-1234").printType();
        MyWrapperFactory.getMyWrapperInstance("890000.34").printType();
        MyWrapperFactory.getMyWrapperInstance("true").printType();
        MyWrapperFactory.getMyWrapperInstance("c").printType();
        MyWrapperFactory.getMyWrapperInstance("@").printType();

    }

}

0 replies

sruthi-15-sketch · 2022-03-22T08:23:44Z

sruthi-15-sketch
Mar 22, 2022


interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("The value is MyInteger type");
    }
}

class MyDouble implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("The value is MyDouble type");
    }
}

class MyCharacter implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("The value is MyCharacter type");
    }
}

class MyBoolean implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("The value is MyBoolean type");
    }
}

class MyWrapperFactory {
    public MyWrapper getMyWrapperInstance(String channel) {
        if (channel == null || channel.isEmpty())
            return null;
        if (channel.matches("\\d+"))
            return new MyInteger();
        else if (channel.matches("[0-9]{1,13}(\\.[0-9]*)?"))
            return new MyDouble();
        else if (channel.matches("[a-z][A-Z]"))
            return new MyCharacter();
        else if (channel.matches("true") || channel.matches("false"))
            return new MyBoolean();
        else
            throw new IllegalArgumentException("Unknown channel " + channel);
    }
}

public class FactoryDemo {
    public static void main(String[] args) {
        MyWrapperFactory factory = new MyWrapperFactory();
        MyWrapper wrapper = factory.getMyWrapperInstance("567");
        wrapper.printType();
    }
}

0 replies

Ashwesh09 · 2022-03-22T08:23:54Z

Ashwesh09
Mar 22, 2022

interface MyWrapper{
    void printType();
}
class MyInteger implements MyWrapper{
    @Override
    public void printType(){
        System.out.println("Integer");
    }
}

class MyDouble implements MyWrapper{
    @Override
    public void printType(){
        System.out.println("Double");
    }
}
class MyCharacter implements MyWrapper{
    @Override
    public void printType(){
        System.out.println("Character");
    }
}
class MyBoolean implements MyWrapper{
    @Override
    public void printType(){
        System.out.println("Boolean");
    }
}

class MyWrapperFactory{
    MyWrapper createMyWrapper(String input){
        if(input == null || input.isEmpty())
            return null;
        else if(input.matches("\\d+"))
            return new MyInteger();
        else if(input.matches("([0-9]*)\\.([0-9]*)"))
            return new MyDouble();
        else if(input.length() == 1)
            return new MyCharacter();
        else if(input.equals("true") || input.equals("false"))
            return new MyBoolean();
        else
            throw new IllegalArgumentException("Invalid input : " + input);
        }
    }

public class FactoryMethodsDemo {
    public static void main(String[] args) {
        MyWrapperFactory myWrapperFactory = new MyWrapperFactory();
        MyWrapper myWrapper = myWrapperFactory.createMyWrapper("9.6");
        myWrapper.printType();
    }
}

0 replies

KaminiJha · 2022-03-22T08:23:58Z

KaminiJha
Mar 22, 2022

package DesignPattern;

interface MyWrapper{
    void printType();
}

class MyInteger implements MyWrapper{
@Override
public void printType()
{
    System.out.println("It is of integer type");
}
}
class MyDouble implements MyWrapper{
    @Override
public void printType()
{
    System.out.println("It is of double type");
}
}
class MyCharacter implements MyWrapper{
    @Override
    public void printType()
    {
        System.out.println("It is of character type");
    }
}
class MyBoolean implements MyWrapper{
    @Override
    public void printType()
    {
        System.out.println("It is of boolean type");
    }
}

class MyWrapperFactory{
    public MyWrapper createMyWrapper(String param) 
    {
        boolean isCharacter=false;
        boolean isBoolean=false;
        //check for boolean
        if(param.equals("false")|| param.equals("true"))
        {
            isBoolean=true;
        }
        //check for charcter
        if(param.length()==1 && !Character.isDigit(param.charAt(0)))
        {
            isCharacter=true;
        }
    
        //cases
        if(isBoolean)
        {
            return new MyBoolean();
        }
        else if(isCharacter)
        {
            return new MyCharacter();
        }
        else if (param.matches("\\d+"))
        {
            return new MyInteger();
        }
        else if(param.matches("[0-9]{1,13}(\\.[0-9]*)?"))
        {
            return new MyDouble();
        }
        else
        {
            throw new IllegalArgumentException("Invalid data type");
        }
    }
}

public class FactoryPattern{
    public static void main(String[] args){
        MyWrapperFactory obj=new MyWrapperFactory();
        MyWrapper myWrapperObj=obj.createMyWrapper("123.4");
        myWrapperObj.printType();
    }
}

0 replies

Mrafe · 2022-03-22T08:24:58Z

Mrafe
Mar 22, 2022

import java.util.Scanner;

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("It is an Integer");

    }

}

class MyDouble implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("It is a Double");

    }

}

class MyCharacter implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("It is a Character");

    }
}

class MyBoolean implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("It is a Boolean");

    }

}

class MyWrapperFactory {
    public MyWrapper getMyWrapperInstance(String s) {
        if (s == null || s.isEmpty()) {
            return null;
        }
        if (s.equalsIgnoreCase("TRUE") || s.equalsIgnoreCase("FALSE")) {
            return new MyBoolean();
        } else if (s.length() == 1
                && ((s.charAt(0) <= 90 && s.charAt(0) >= 65) || (s.charAt(0) <= 122 && s.charAt(0) >= 97))) {
            return new MyCharacter();
        } else if (s.matches("^[+-]?[0-9]+.[0-9]+")) {
            return new MyDouble();
        } else if (s.matches("^[+-]?[0-9]+")) {
            return new MyInteger();
        } else {
            throw new IllegalArgumentException("invalid string input : " + s);
        }
    }

}

public class DataType {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        MyWrapperFactory obj = new MyWrapperFactory();
        MyWrapper t = obj.getMyWrapperInstance(s);
        t.printType();
    }
}

0 replies

Batchusatyasri · 2022-03-22T08:28:11Z

Batchusatyasri
Mar 22, 2022

interface Mywrapper {
    void printType();
}

class Myinteger implements Mywrapper {
    @Override
    public void printType() {
        System.out.println("I am of type Integer");
    }
}

class Mydouble implements Mywrapper {
    @Override
    public void printType() {
        System.out.println("I am of type floating point");
    }
}

class Mycharacter implements Mywrapper {
    @Override
    public void printType() {
        System.out.println("I am of type character");
    }
}

class Myboolean implements Mywrapper {
    @Override
    public void printType() {
        System.out.println("I am of type boolean");
    }
}

class MyWrapperFactory {
    public Mywrapper createmyWrapper(String param) throws IllegalArgumentException {
        if (param == null || param.isEmpty()) {
            return null;
        } else if (param.matches("[0-9]")) {
            return new Myinteger();
        } else if (param.matches("[+-]?([0-9]*[.])?[0-9]+")) {
            return new Mydouble();
        } else if (param.equals("true") || param.equals("false")) {
            return new Myboolean();
        } else if (param.length() == 1 && (param.charAt(0) > 0 && param.charAt(0) < 127)) {
            return new Mycharacter();
        } else
            throw new IllegalArgumentException("Invalid Type");
    }

}

public class Factorymethod {
    public static void main(String[] args) {
        MyWrapperFactory obj = new MyWrapperFactory();
        obj.createmyWrapper("true").printType();

    }
}

0 replies

hemanth409 · 2022-03-22T08:28:29Z

hemanth409
Mar 22, 2022

interface MyWrapper {
void printType();
}

class MyInteger implements MyWrapper {

@Override
public void printType() {
    System.out.println("Integer type");

}

}

class MyDouble implements MyWrapper {

@Override
public void printType() {
    System.out.println("Double type");

}

}

class MyCharacter implements MyWrapper {

@Override
public void printType() {
    System.out.println("Character type");

}

}

class MyBoolean implements MyWrapper {

@Override
public void printType() {
    System.out.println("Boolean type");

}

}

class MyWrapperFactory {
public static MyWrapper getMyWrapperInstance(String s) {
if (s == null || s.isEmpty())
return null;
if (s.matches("-?\d+")) {
return new MyInteger();

    }
    if (s.matches("-?\\d+(\\.\\d+)?"))
        return new MyDouble();
    if (s.matches("[a-zA-Z]"))
        return new MyCharacter();
    if (s.equals("true") || s.equals("false"))
        return new MyBoolean();
    else
        throw new IllegalArgumentException("Invalid input");

}

}

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

    MyWrapperFactory.getMyWrapperInstance("409").printType();
    MyWrapperFactory.getMyWrapperInstance("409.09").printType();
    MyWrapperFactory.getMyWrapperInstance("TRUE").printType();
    MyWrapperFactory.getMyWrapperInstance("K").printType();
    MyWrapperFactory.getMyWrapperInstance("#").printType();

}

}

0 replies

Shubhi27 · 2022-03-22T08:28:42Z

Shubhi27
Mar 22, 2022

package FactoryMethod;

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("This is Integer");
    }
}

class MyDouble implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("This is Double");
    }
}

class MyCharacter implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("This is Character");
    }
}

class MyBoolean implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("This is Boolean");
    }
}

class MyWrapperFactoryInstance {
    public MyWrapper createMyWrapper(String val) throws IllegalArgumentException {
        if (val == null || val.length() == 0)
            return null;
        else if (val.matches("\\d+"))
            return new MyInteger();
        else if (val.matches("\\d+[.]\\d+"))
            return new MyDouble();
        else if (val.matches("[a-zA-Z]"))
            return new MyCharacter();
        else if ("true".equals(val) || "false".equals(val))
            return new MyBoolean();
        else
            throw new IllegalArgumentException("Invalid Type");
    }
}

public class Factory {
    public static void main(String[] args) {
        MyWrapperFactoryInstance obj = new MyWrapperFactoryInstance();
        MyWrapper wrapper1 = obj.createMyWrapper("54");
        wrapper1.printType();
        MyWrapper wrapper2 = obj.createMyWrapper("45.6");
        wrapper2.printType();
        MyWrapper wrapper3 = obj.createMyWrapper("c");
        wrapper3.printType();

    }
}

0 replies

mkaifahmed · 2022-03-22T08:30:46Z

mkaifahmed
Mar 22, 2022

package DSA.core;

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Integer");
    }
}

class MyDouble implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Double");
    }
}

class MyCharacter implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Character");
    }
}

class MyBoolean implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Boolean");
    }
}

class MyString implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("String");
    }
}

class MyWrapperFactory {
    public MyWrapper createMyWrapper(String data) {
        if (data == null || data.isEmpty()) {
            return null;
        }

        if (data == "true" || data == "false") {

            return new MyBoolean();
        }

        if (data.length() == 1 && (Character.isDigit(data.charAt(0)) == false)) {

            return new MyCharacter();
        }
        if (data.matches("-?\\d+")) {
            return new MyInteger();

        }
        if (data.matches("-?\\d+(\\.\\d+)?")) {
            return new MyDouble();
        } else {
            throw new IllegalArgumentException("Invalid inpur");
        }

    }

}

public class FactoryDemo {
    public static void main(String[] args) {
        MyWrapperFactory myWrapperFactory = new MyWrapperFactory();
        MyWrapper printType1 = myWrapperFactory.createMyWrapper("41.5");
        MyWrapper printType2 = myWrapperFactory.createMyWrapper("true");
        MyWrapper printType3 = myWrapperFactory.createMyWrapper("41");
        MyWrapper printType4 = myWrapperFactory.createMyWrapper("c");
        MyWrapper printType5 = myWrapperFactory.createMyWrapper("hello");

        printType1.printType();
        printType2.printType();
        printType3.printType();
        printType4.printType();
        printType5.printType();

    }
}

0 replies

Harshita-Joshi · 2022-03-22T08:44:00Z

Harshita-Joshi
Mar 22, 2022

import java.util.Scanner;
import java.lang.*;

interface MyWrapper{
    void printType();
}

class MyInteger implements MyWrapper{

    @Override
    public void printType(){
        System.out.println("This input is of type MyInteger");
    }

}

class MyDouble implements MyWrapper{

    @Override
    public void printType(){
        System.out.println("This input is of type MyDouble");
    }

}

class MyCharacter implements MyWrapper{

    @Override
    public void printType(){
        System.out.println("This input is of type MyCharacter");
    }

}

class MyBoolean implements MyWrapper{

    @Override
    public void printType(){
        System.out.println("This input is of type MyBoolean");
    }

}


class MyWrapperFactory{

    Boolean testInt(String str){

        int flag=0;
        for(int i=0; i<str.length(); i++){
            if(str.charAt(i)>='0' && str.charAt(i)<='9')
                flag = 1;
            else
                flag = 0;
        }

        if(str.contains(".") || (flag==0))
            return false;
        return true;

    }

    Boolean testDouble(String str){

        int pointCnt = 0;
        for(int i=0; i<str.length(); i++){
            if(str.charAt(i)<='0' && str.charAt(i)>='9' && str.charAt(i)!='.')
                return false;
            if(str.charAt(i)=='.')
            pointCnt++;
        }

        return (pointCnt==1);
    }

    Boolean testChar(String str){

        if(str.length()==1){
            str = str.toLowerCase();
            if(str.charAt(0)>='a' && str.charAt(0)<='z')
                return true;
        }
        return false;

    }


    Boolean testBool(String str){

        return (str.equals("true") || str.equals("false"));

    }

    public MyWrapper createMyWrapper(String str) throws IllegalArgumentException{

        if(str.equals(null))
        return null;

        if(testInt(str)==true)
        return new MyInteger();

        if(testDouble(str)==true)
        return new MyDouble();

        if(testChar(str)==true)
        return new MyCharacter();

        if(testBool(str)==true)
        return new MyBoolean();

        throw new IllegalArgumentException("Non-identifiable type");

    }

}


public class CustomerWrapperDriver {
    public static void main(String[] args) {
        
        Scanner scn = new Scanner(System.in);
        String str = scn.next();
        MyWrapperFactory factory = new MyWrapperFactory();

        try{
            MyWrapper myWrapClass = factory.createMyWrapper(str);
            myWrapClass.printType();
        }catch(IllegalArgumentException e){
            System.out.println(e.getMessage());
        }
         

    }
}

0 replies

amruth2211 · 2022-03-22T08:44:32Z

amruth2211
Mar 22, 2022

package DesignPatterns.creationalPatterns;

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("The value is MyInteger type");
    }
}

class MyDouble implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("The value is MyDouble type");
    }
}

class MyCharacter implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("The value is MyCharacter type");
    }
}

class MyBoolean implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("The value is MyBoolean type");
    }
}

class MyWrapperFactory {
    public MyWrapper getMyWrapperInstance(String channel) {
        if (channel == null || channel.isEmpty())
            return null;
        if (channel.matches("\\d+"))
            return new MyInteger();
        else if (channel.matches("[0-9]{1,13}(\\.[0-9]*)?"))
            return new MyDouble();
        else if (channel.matches("[a-z][A-Z]"))
            return new MyCharacter();
        else if (channel.matches("true") || channel.matches("false"))
            return new MyBoolean();
        else
            throw new IllegalArgumentException("Unknown channel " + channel);
    }
}

public class FactoryPattern {
    public static void main(String[] args) {
        MyWrapperFactory factory = new MyWrapperFactory();
        MyWrapper wrapper = factory.getMyWrapperInstance("5.4");
        wrapper.printType();
    }
}

0 replies

DivikaAgrawal · 2022-03-22T08:56:11Z

DivikaAgrawal
Mar 22, 2022

interface MyWrapper{
    void printType();
}

class MyInteger implements MyWrapper{

    @Override
    public void printType(){
        System.out.println("Intger type");
    }
}
class MyDouble implements MyWrapper{

    @Override
    public void printType(){
        System.out.println("Double type");
    }
}

class MyCharacter implements MyWrapper{

    @Override
    public void printType(){
        System.out.println("Character type");
    }
}

class MyBoolean implements MyWrapper{

    @Override
    public void printType(){
        System.out.println("Boolean type");
    }
}



 class MyWrapperFactory {
    public MyWrapper getMyWrapperInstance(String input){
        if(input==null || input.isEmpty()){
        return null;
    }
    System.out.println(input);

    if(input.matches("\\d+")){
        return new MyInteger();
    }
    if(input.matches("[a-zA-Z]")){
        return new MyCharacter();
    }
    if(input.matches("\\d+.\\d+")){
        return new MyDouble();
    }
    if(input.toLowerCase().equals("true") || input.toLowerCase().equals("false")){
        return new MyBoolean();
    }

    throw new IllegalArgumentException("unknow type of input");
    }  
}
public class FactoryMethod{
    public static void main(String args[]){
        MyWrapperFactory myWrapperFactory = new MyWrapperFactory();

        MyWrapper ob1 = myWrapperFactory.getMyWrapperInstance("5");
        ob1.printType();
        MyWrapper ob2 = myWrapperFactory.getMyWrapperInstance("d");
        ob2.printType();
        MyWrapper ob3 = myWrapperFactory.getMyWrapperInstance("2.0");
        ob3.printType();
        MyWrapper ob4 = myWrapperFactory.getMyWrapperInstance("true");
        ob4.printType();
        MyWrapper ob5 = myWrapperFactory.getMyWrapperInstance("yglkm");
        ob5.printType();
    }
}

0 replies

Prem-3 · 2022-03-22T09:19:40Z

Prem-3
Mar 22, 2022

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Integer type");
    }
}

class MyDouble implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Double type");
    }
}

class MyCharacter implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Character type");
    }
}

class MyBoolean implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Boolean type");
    }
}

class MyWrapperFactory {
    MyWrapper createMyWrapper(String input) {
        if (input == null || input.isEmpty()) {
            return null;
        }
        if (input.matches("\\d+"))
            return new MyInteger();
        else if (input.matches("([0-9]*)\\.([0-9]*)"))
            return new MyDouble();
        else if (input.length() == 1)
            return new MyCharacter();
        else if (input.equals("true") || input.equals("false"))
            return new MyBoolean();
        else
            throw new IllegalArgumentException("Invalid input : " + input);
    }

}

public class FactorymethodDemo {
    public static void main(String[] args) {
        MyWrapperFactory factory = new MyWrapperFactory();
        MyWrapper obj = factory.createMyWrapper("3.3");
        obj.printType();
        MyWrapper obj1 = factory.createMyWrapper("3");
        obj1.printType();
        MyWrapper obj2 = factory.createMyWrapper("Prem");
        obj2.printType();
    }
}

0 replies

ratnadeepikavuddagiri · 2022-03-22T09:21:02Z

ratnadeepikavuddagiri
Mar 22, 2022

import java.util.Scanner;

interface MyWrapper{
    void printType();
}
class MyInteger implements MyWrapper{

    @Override
    public void printType() {
        System.out.println("Integer");

    }
    
}
class MyDouble implements MyWrapper{

    @Override
    public void printType() {
        System.out.println("Double");
        
    }
    
}
class MyCharacter implements MyWrapper{

    @Override
    public void printType() {
        System.out.println("Character");   
    }
    
}
class MyBoolean implements MyWrapper{

    @Override
    public void printType() {
        System.out.println("Boolean");        
    }
    
}

class MyWrapperFactory {
    public MyWrapper getMyWrapperInstance(String value){
        if(value == null || value.length() == 0)
            return null;
        else if(value.matches("\\d+"))
            return new MyInteger();
        else if(value.matches("\\d+[.]\\d+"))
            return new MyDouble();
        else if(value.matches("[a-zA-Z]"))
            return new MyCharacter();
        else if(value.equals("true") || value.equals("false"))
            return new MyBoolean();
        else
            throw new IllegalArgumentException("Invalid Type");
    }
}

public class FactoryDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        MyWrapperFactory myWrapperFactory = new MyWrapperFactory();
        MyWrapper myWrapper = myWrapperFactory.getMyWrapperInstance(s);
        myWrapper.printType();
    }
}

0 replies

abhiraj2k · 2022-03-22T09:33:03Z

abhiraj2k
Mar 22, 2022

package design_patterns.creational;

import java.util.regex.Pattern;

interface MyWrapper {
    void printType();

}

public class FactoryPatternEg {

    class MyInteger implements MyWrapper {
        @Override
        public void printType() {
            System.out.println("Integer");
        }
    }

    class MyDouble implements MyWrapper {
        @Override
        public void printType() {
            System.out.println("Double");
        }
    }

    class MyCharacter implements MyWrapper {
        @Override
        public void printType() {
            System.out.println("Character");
        }
    }

    class MyBoolean implements MyWrapper {
        @Override
        public void printType() {
            System.out.println("Boolean");
        }
    }

    class MyString implements MyWrapper {
        @Override
        public void printType() {
            System.out.println("String");
        }
    }

    public MyWrapper createMyWrapper(String str) {
        // String[] strAr = str.split("\\.");
        if (isInt(str)) {
            return new MyInteger();
        }
        if (isDouble(str)) {
            return new MyDouble();
        }
        if (str.equals("true") || str.equals("false")) {
            return new MyBoolean();
        }
        if (str.length() == 1) {
            return new MyCharacter();
        }
        return new MyString(); // default
    }

    private boolean isInt(String str) {
        return Pattern.compile("-?\\d+").matcher(str).matches();
    }

    private boolean isDouble(String str) {
        return Pattern.compile("-?\\d+(\\.\\d+)?").matcher(str).matches();
    }

    public static void main(String[] args) {
        FactoryPatternEg myFactory = new FactoryPatternEg();
        MyWrapper myWrapper = myFactory.createMyWrapper("");
        myWrapper.printType();
    }
}

0 replies

vysh675 · 2022-03-22T09:39:14Z

vysh675
Mar 22, 2022

interface MyWrapper {
void printType();
}

class MyInteger implements MyWrapper {
@OverRide
public void printType() {
System.out.println("I am an Integer");
}
}
class MyDouble implements MyWrapper {
@OverRide
public void printType() {
System.out.println("I am a Double");
}
}

class MyCharacter implements MyWrapper {
@OverRide
public void printType() {
System.out.println("I am a Character");
}
}
class MyBoolean implements MyWrapper {
@OverRide
public void printType() {
System.out.println("I am a Boolean");
}
}
class MyWrapperFactory {
public MyWrapper getMyWrapperInstance(String s) {
if (s == null || s.isEmpty()) {
return null;
}
if ( s.equals("true")|| s.equals("false") ) {
return new MyBoolean();
}
if (s.matches("[a-zA-z]")) {
return new MyCharacter();
}
if (s.matches("-?\d+")) {
return new MyInteger();
}
if (s.matches("-?\d+(\.\d+)?")) {
return new MyDouble();
}
throw new IllegalArgumentException("Unknown type of value");
}
}

public class CustomeWrapperDriver {
public static void main(String[] args) {
MyWrapperFactory Factory = new MyWrapperFactory();
MyWrapper obj1 = Factory.getMyWrapperInstance("10");
obj1.printType();
MyWrapper obj2 = Factory.getMyWrapperInstance("23.55");
obj2.printType();
MyWrapper obj3 = Factory.getMyWrapperInstance("s");
obj3.printType();
MyWrapper obj4 = Factory.getMyWrapperInstance("false");
obj4.printType();
MyWrapper obj5 = Factory.getMyWrapperInstance("%");
obj5.printType();
}
}

0 replies

ShraddhaPenshanwar · 2022-03-22T09:51:29Z

ShraddhaPenshanwar
Mar 22, 2022

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Integer type");

    }

}

class MyDouble implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Double type");

    }

}

class MyCharacter implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Character type");

    }

}

class MyBoolean implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Boolean type");

    }

}

class MyWrapperFactory {
    public static MyWrapper getMyWrapperInstance(String s) {
        if (s == null || s.isEmpty())
            return null;
        if (s.matches("-?\\d+")) {
            return new MyInteger();

        }
        if (s.matches("-?\\d+(\\.\\d+)?"))
            return new MyDouble();
        if (s.matches("[a-zA-Z]"))
            return new MyCharacter();
        if (s.equals("true") || s.equals("false"))
            return new MyBoolean();
        else
            throw new IllegalArgumentException("Invalid input");

    }
}

public class FactoryMethodDemo {
    public static void main(String[] args) {
            
        MyWrapperFactory.getMyWrapperInstance("-1234").printType();
        MyWrapperFactory.getMyWrapperInstance("890000.34").printType();
        MyWrapperFactory.getMyWrapperInstance("true").printType();
        MyWrapperFactory.getMyWrapperInstance("c").printType();
        MyWrapperFactory.getMyWrapperInstance("@").printType();

    }

}```

0 replies

VigneshVishwa · 2022-03-22T09:51:55Z

VigneshVishwa
Mar 22, 2022

import java.util.Scanner;

interface MyWrapper{
    void printType();
}
class MyInteger implements MyWrapper{

    @Override
    public void printType() {
        System.out.println("Integer");

    }
    
}
class MyDouble implements MyWrapper{

    @Override
    public void printType() {
        System.out.println("Double");
        
    }
    
}
class MyCharacter implements MyWrapper{

    @Override
    public void printType() {
        System.out.println("Character");   
    }
    
}
class MyBoolean implements MyWrapper{

    @Override
    public void printType() {
        System.out.println("Boolean");        
    }
    
}

class MyWrapperFactory {
    public MyWrapper getMyWrapperInstance(String value){
        if(value == null || value.length() == 0)
            return null;
        else if(value.matches("\\d+"))
            return new MyInteger();
        else if(value.matches("\\d+[.]\\d+"))
            return new MyDouble();
        else if(value.matches("[a-zA-Z]"))
            return new MyCharacter();
        else if(value.equals("true") || value.equals("false"))
            return new MyBoolean();
        else
            throw new IllegalArgumentException("Invalid Type");
    }
}

public class FactoryDesign {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        MyWrapperFactory myWrapperFactory = new MyWrapperFactory();
        MyWrapper myWrapper = myWrapperFactory.getMyWrapperInstance(s);
        myWrapper.printType();
    }
}

0 replies

RohitN09 · 2022-03-22T09:54:12Z

RohitN09
Mar 22, 2022

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Integer Type");
    }
}

class MyDouble implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Double Type");
    }
}

class MyCharacter implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Character Type");
    }
}

class MyBoolean implements MyWrapper {

    @Override
    public void printType() {
        System.out.println("Boolean Type");
    }
}

class WrapperFactory {
    public MyWrapper checkType(String str) {
        if (str == null)
            throw new IllegalArgumentException("null");
        else if (str.length() == 0)
            throw new IllegalArgumentException("Empty String!!");
        else if (str.matches("-?\\d+"))
            return new MyInteger();
        else if (str.length() == 1 && str.matches("[a-zA-Z]"))
            return new MyCharacter();
        else if (str.equals("true") || str.equals("false"))
            return new MyBoolean();
        else if (str.matches("-?\\d+\\.\\d+"))
            return new MyDouble();
        else
            throw new IllegalArgumentException("Unknown Type!");
    }
}

public class MyWrapperFactory {
    public static void main(String[] args) {
        WrapperFactory fac = new WrapperFactory();
        MyWrapper myFactory = fac.checkType("g");
        myFactory.printType();
    }
}

0 replies

charani712 · 2022-03-22T10:05:13Z

charani712
Mar 22, 2022

interface MyWrapper {
void printType();
}

class MyInteger implements MyWrapper {
@OverRide
public void printType() {
System.out.println("Integer");
}
}

class MyDouble implements MyWrapper {
@OverRide
public void printType() {
System.out.println("Double");
}
}

class MyCharacter implements MyWrapper {
@OverRide
public void printType() {
System.out.println("Character");
}
}

class MyBoolean implements MyWrapper {
@OverRide
public void printType() {
System.out.println("Boolean");
}
}

class WrapperFactory {
public MyWrapper createMyWrapper(String input){
if(input == null || input.length() == 0)
return null;
else if(input.matches("\d+"))
return new MyInteger();
else if(input.matches("\d+[.]\d+"))
return new MyDouble();
else if(input.matches("[a-zA-Z]"))
return new MyCharacter();
else if("true".equals(input) || "false".equals(input))
return new MyBoolean();
else
throw new IllegalArgumentException("Invalid Type");
}
}

public class FactoryDemo {
public static void main(String[] args) {
MyWrapperFactory myFactory = new MyWrapperFactory();
MyWrapper myWrapper1 = myFactory.createMyWrapper("10");
myWrapper1.printType();
MyWrapper myWrapper2 = myFactory.createMyWrapper("10.5");
myWrapper2.printType();
MyWrapper myWrapper3 = myFactory.createMyWrapper("Charani");
myWrapper3.printType();
MyWrapper myWrapper4 = myFactory.createMyWrapper("false");
myWrapper4.printType();

}

0 replies

PavanArvapally · 2022-03-22T10:37:22Z

PavanArvapally
Mar 22, 2022

package Tasks.Design_Pattern;

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {

    @Override
    public void printType() {
        // TODO Auto-generated method stub
        System.out.println("Integer");
    }

}

class MyDouble implements MyWrapper {

    @Override
    public void printType() {
        // TODO Auto-generated method stub
        System.out.println("Double");
    }

}

class MyBoolean implements MyWrapper {

    @Override
    public void printType() {
        // TODO Auto-generated method stub
        System.out.println("Boolean");
    }

}

class MyCharacter implements MyWrapper {

    @Override
    public void printType() {
        // TODO Auto-generated method stub
        System.out.println("Character");
    }

}

class MyWrapperFactory {
    public MyWrapper getMyWrapperInstance(String value) {
        // return the wrapper instance corresponding to the type of value
        if (value == null || value.isEmpty())
            return null;
        else if(value.equals("true") || value.equals("false"))
            return new MyBoolean();
        else if(value.matches("\\d+"))
            return new MyInteger();
        else if(value.matches("[+-]?(\\d*[.])?\\d+"))
            return new MyDouble();
        else if(value.matches("[a-zA-z]"))
            return new MyCharacter();
        else
            throw new IllegalArgumentException("Not a valid input type");
    }
}

public class CustomeWrapperDriver {
    public static void main(String[] args) {
        MyWrapperFactory myWrapperFactory = new MyWrapperFactory();
        myWrapperFactory.getMyWrapperInstance("1").printType();
        myWrapperFactory.getMyWrapperInstance("1.5").printType();
        myWrapperFactory.getMyWrapperInstance("true").printType();
        myWrapperFactory.getMyWrapperInstance("a").printType();
    }
}

0 replies

rakeshGit419 · 2022-03-22T17:48:58Z

rakeshGit419
Mar 22, 2022

interface MyWrapper{
    void printType();
}

class MyInteger implements MyWrapper{
    @Override
    public void printType() {System.out.println("Integer");}
}
class MyDouble implements MyWrapper{
    @Override
    public void printType() {System.out.println("Double");}
}
class MyBoolean implements MyWrapper{
    @Override
    public void printType() {System.out.println("Boolean");}
}
class MyCharacter implements MyWrapper{
    @Override
    public void printType() {System.out.println("Character");}
}

class MyWrapperFactory{
    public MyWrapper getMyWrapperInstance(String value) {
        if(value == null) return null;
        else if(value.matches("\\d+")) return new MyInteger();
        else if(value.matches("\\d+.\\d+")) return new MyDouble();
        else if(value.matches("true|false")) return new MyBoolean();
        else if(value.matches("[a-zA-Z]")) return new MyCharacter();
        else throw new IllegalArgumentException("Unknown Type");
    }
}

public class CustomeWrapperDriver {
    public static void main(String[] args) {
        
        MyWrapperFactory myFact = new MyWrapperFactory();
        MyWrapper myWrapper1 = myFact.getMyWrapperInstance("143");
        myWrapper1.printType();
        MyWrapper myWrapper2 = myFact.getMyWrapperInstance("3.14");
        myWrapper2.printType();
        MyWrapper myWrapper3 = myFact.getMyWrapperInstance("true");
        myWrapper3.printType();
        MyWrapper myWrapper4 = myFact.getMyWrapperInstance("R");
        myWrapper4.printType();
    }
}

0 replies

ujjwal18bit1167 · 2022-04-17T06:22:46Z

ujjwal18bit1167
Apr 17, 2022

interface MyWrapper {
    void printType();
}

class MyInteger implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Integer");
    }
}

class MyDouble implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Double");
    }
}

class MyCharacter implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Character");
    }
}

class MyBoolean implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("Boolean");
    }
}

class MyWrapperFactory {
    public MyWrapper createMyWrapper(String val){
        if(val == null || val.length() == 0)
            return null;
        else if(val.matches("\\d+"))
            return new MyInteger();
        else if(val.matches("\\d+[.]\\d+"))
            return new MyDouble();
        else if(val.matches("[a-zA-Z]"))
            return new MyCharacter();
        else if("true".equals(val) || "false".equals(val))
            return new MyBoolean();
        else
            throw new IllegalArgumentException("Invalid Type");
    }
}

public class FactoryDemo {
    public static void main(String[] args) {
        MyWrapperFactory myFactory = new MyWrapperFactory();
        MyWrapper myWrapper1 = myFactory.createMyWrapper("123");
        MyWrapper myWrapper2 = myFactory.createMyWrapper("12.34");
        MyWrapper myWrapper3 = myFactory.createMyWrapper("S");
        MyWrapper myWrapper4 = myFactory.createMyWrapper("false");
        myWrapper1.printType();
        myWrapper2.printType();
        myWrapper3.printType();
        myWrapper4.printType();
    }
}

0 replies

Herbert05 · 2022-05-08T15:25:31Z

Herbert05
May 8, 2022

package designPatternTypeQuiz;

public interface MyWrapper {
    void printType();
}

package designPatternTypeQuiz;

public class MyBoolean implements MyWrapper{
    @Override
    public void printType() {
        System.out.println("The value is type of MyBoolean");
    }
}
package designPatternTypeQuiz;

public class MyCharacter implements MyWrapper{
    @Override
    public void printType() {
        System.out.println("The value is type of MyCharacter");
    }
}
package designPatternTypeQuiz;

public class MyDouble implements MyWrapper{
    @Override
    public void printType() {
        System.out.println("The value is type of MyDouble");
    }
}
package designPatternTypeQuiz;

public class MyInteger implements MyWrapper {
    @Override
    public void printType() {
        System.out.println("The value is type of MyInteger");
    }
}
package designPatternTypeQuiz;

import java.util.Locale;

public class MyWrapperFactory {
    public MyWrapper getMyWrapperInstance(String value) throws Exception {
        if(value.toLowerCase(Locale.ROOT).matches("^true$|^false$"))
            return new MyBoolean();
        else if(value.matches("[a-zA-Z]+"))
            return new MyCharacter();
        else if(value.matches("\\d+"))
            return new MyInteger();
        else if(value.matches("\\d+\\.\\d+"))
            return new MyDouble();
        else
            throw new Exception("Unsupported type provided");
    }
}
package designPatternTypeQuiz;

public class TestWrapper {
    public static void main(String... args){
        MyWrapperFactory factory = new MyWrapperFactory();
        try{
            MyWrapper instance1 = factory.getMyWrapperInstance("false");
            instance1.printType();
            MyWrapper instance2 = factory.getMyWrapperInstance("true");
            instance2.printType();
            MyWrapper instance3 = factory.getMyWrapperInstance("190");
            instance3.printType();
            MyWrapper instance4 = factory.getMyWrapperInstance("9.67");
            instance4.printType();
            MyWrapper instance5 = factory.getMyWrapperInstance("Juma");
            instance5.printType();
        }catch (Exception ex){
            System.out.println(String.format("Error: %s", ex.getMessage()));
        }
    }
}

0 replies

Task - Design Patterns - Factory Method #60

Uh oh!

Uh oh!

akash-coded Mar 22, 2022 Maintainer

Implement Factory Method Design Pattern

Sample Inputs

Sample Outputs

Hints

Some common ASCII ranges:

Replies: 31 comments

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

akash-coded
Mar 22, 2022
Maintainer