Open Closed and Interface Segregation

Question

I am writing a code which basically reads a text file (Tabular format) and check if the file contains expected data type or not. For that I have write following class.

The sample file would be something like this.

name    age
abc     20
xyz     vf
aaa     22

And I have JSON file which says, which conlumn should contains what?

{
    filename:"test.txt",
    cols:{
            name:string,
            age: int
    }

}

A JSON file contains the DataType for each row, so I know what to expect?

Following code working without any issue. However, it seems that this code Violates the open closed and interface segregation principle.

public class DataValidation {

    public boolean isInt(String value) {
        try {
            Integer.parseInt(value);
            return true;
        } catch (NumberFormatException ne) {
            return false;
        }
    }


    public boolean isFloat(String value) {
        try {
            Float.parseFloat(value);
            return true;
        } catch (NumberFormatException ne) {
            return false;
        }
    }

}

And so I am thinking to Refector the code as mentioned below. However, would like to know what advantage I will get and is there any better approach?

public interface DataValidation {

    boolean validate(String value);
}

public class IntValidator implements DataValidation {
    public boolean validate(String value) {
        try{
            Integer.parseInt(value);
            return true;
        }catch (NumberFormatException ne){
            return false;
        }
    }
}

Answer 1

Basic Definition of Open-Close Principle (OCP): (Meyer 1988)
the open/closed principle states "software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification"; that is, such an entity can allow its behavior to be extended without modifying its source code. see Reference

BUT: On the other hand Uncle Bob in this reference provide some clarifications about the meaning of OCP. (that I used them in the following)

First of all: In my idea, your class (DataValidation) did not conflict Open-Close Principle.

Your class JUST check the primitive data types. (as you answered to my question in comment). There are just 8 primitive data types in Java. This number will not change in the future. So if you put all the 8 methods in one class, you don't have any extensions or modifications on data types in the future.
In the other hand, OCP is about adding new source codes without any changes in old codes. So event if Java adds new data type, you can add the method easily without modifications in other parts of code.

Therefore, I think that your class is not BIG enough to violate Open-Close Principle.

Secondly: To use Interface Segregation Principle (ISP)
To use ISP, we need some prerequisites. We should have some dependencies between part of our system (or class). we should need for Dependency Management to manage some parts of system and we consciously decide what each part of the system can depend on. please read this reference in-depth

I think that your class is just a Checker class and does not have any states (Attributes or Fields). So there is not any reason to use ISP.

To sum up: Using all Object Oriented principles and heuristics (like SOLID), should help us to reduce COMPLEXITY. In your project, there is no need to use them.

To offer a solution for your problem
You can use an enum DataTypes {boolean, char, _etc_} for Primitive Data Types and use only one method like DataType getDataType(String S) to get the type of given String as enum. But your approach (DataValidation class) is good enough too.