diff --git a/CHANGELOG.md b/CHANGELOG.md
index 613f4c7cab5..84125fd9337 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,9 @@ Currently the versioning policy of this project follows [Semantic Versioning v2.
 - Do not report BC_UNCONFIRMED_CAST for Java 21's type switches when the switch instruction is TABLESWITCH ([#2782](https://github.com/spotbugs/spotbugs/issues/2782))
 - Do not throw exception when inspecting empty switch statements ([#2995](https://github.com/spotbugs/spotbugs/issues/2995))
 - Adjust priority since relaxed mode reports even `IGNORED_PRIORITY` ([#2994]https://github.com/spotbugs/spotbugs/issues/2994)
+- 
+### Added
+- New detector `FindHiddenMethod` for bug type `HSM_HIDING_METHOD`. This bug is reported whenever a subclass method hides the static method of super class. (See [SEI CERT MET07-J] (https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface)).
 
 ## 4.8.5 - 2024-05-03
 ### Fixed
diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java
new file mode 100644
index 00000000000..ea0e693a41a
--- /dev/null
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindHiddenMethodTest.java
@@ -0,0 +1,177 @@
+package edu.umd.cs.findbugs.detect;
+
+import static edu.umd.cs.findbugs.test.CountMatcher.containsExactly;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasItem;
+
+import org.junit.jupiter.api.Test;
+import edu.umd.cs.findbugs.AbstractIntegrationTest;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
+
+class FindHiddenMethodTest extends AbstractIntegrationTest {
+    private final String BUG_TYPE = "HSM_HIDING_METHOD";
+
+    @Test
+    void testBadFindHiddenMethodTest() {
+        performAnalysis("findhiddenmethodtest/GrantAccessStatic.class",
+                "findhiddenmethodtest/BadFindHiddenMethodTest.class");
+        assertHSBCBug("displayAccountStatus", 15);
+    }
+
+    @Test
+    void testBadFindHiddenMethodTest2() {
+        performAnalysis("findhiddenmethodtest/BadSuperClass.class",
+                "findhiddenmethodtest/BadHidingVsOverriding.class");
+        assertHSBCBug("methodHiding", 19);
+    }
+
+
+    @Test
+    void testBadFindHiddenMethodTest3() {
+        performAnalysis("findhiddenmethodtest/SuperBadInEqualMultipleMethod.class",
+                "findhiddenmethodtest/BadInEqualMultipleStaticMethod.class");
+        assertHSBCBug("display", 25);
+        assertHSBCBug("display2", 29);
+    }
+
+    @Test
+    void testBadFindHiddenMethodTest4() {
+        performAnalysis("findhiddenmethodtest/BadMainMethodCheck.class",
+                "findhiddenmethodtest/BadSuperClassWithMain.class");
+        assertHSBCBug("main", 18);
+    }
+
+    @Test
+    void testBadFindHiddenMethodTest5() {
+        performAnalysis("findhiddenmethodtest/BadGrandClass.class",
+                "findhiddenmethodtest/BadParentClass.class",
+                "findhiddenmethodtest/BadMultiLevelInheritance.class");
+        assertHSBCBug("display", 20);
+    }
+
+    @Test
+    void testBadFindHiddenMethodTest6() {
+        performAnalysis("findhiddenmethodtest/SuperBadMultipleMethods.class",
+                "findhiddenmethodtest/BadMultipleStaticMethods.class");
+        assertHSBCBug("display", 19);
+        assertHSBCBug("display2", 23);
+    }
+
+    @Test
+    void testBadFindHiddenMethodTest7() {
+        performAnalysis("findhiddenmethodtest/SuperBadNonOrderedMultipleStaticMethods.class",
+                "findhiddenmethodtest/BadNonOrderedMultipleStaticMethods.class");
+        assertHSBCBug("display", 24);
+        assertHSBCBug("display2", 28);
+    }
+
+    @Test
+    void testBadFindHiddenMethodTest8() {
+        performAnalysis("findhiddenmethodtest/BadOuterInnerClass.class",
+                "findhiddenmethodtest/BadOuterInnerClass$BadInner.class");
+        assertHSBCBug("badMethod", 15);
+    }
+
+    @Test
+    void testBadFindHiddenMethodTest9() {
+        performAnalysis("findhiddenmethodtest/SuperBadProtected.class",
+                "findhiddenmethodtest/BadProtected.class");
+        assertHSBCBug("display", 15);
+    }
+
+    @Test
+    void testGoodFindHiddenMethodTest() {
+        performAnalysis("findhiddenmethodtest/GrantAccess.class",
+                "findhiddenmethodtest/GoodFindHiddenMethodTest.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    void testGoodFindHiddenMethodTest2() {
+        performAnalysis("findhiddenmethodtest/SuperGoodInEqualMultipleMethod.class",
+                "findhiddenmethodtest/GoodInEqualNonStaticMethods.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    void testGoodFindHiddenMethodTest3() {
+        performAnalysis("findhiddenmethodtest/GoodSuperClassWithMain.class",
+                "findhiddenmethodtest/GoodMainMethodCheck.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    void testGoodFindHiddenMethodTest4() {
+        performAnalysis("findhiddenmethodtest/GoodGrandNonStatic.class",
+                "findhiddenmethodtest/GoodParentNonStatic.class",
+                "findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    void testGoodFindHiddenMethodTest5() {
+        performAnalysis("findhiddenmethodtest/GoodGrandClassPrivate.class",
+                "findhiddenmethodtest/GoodParentClassPrivate.class",
+                "findhiddenmethodtest/GoodMultiLevelInheritancePrivate.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    void testGoodFindHiddenMethodTest6() {
+        performAnalysis("findhiddenmethodtest/SuperMultipleNonStatic.class",
+                "findhiddenmethodtest/GoodMultipleNonStaticMethods.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    void testGoodFindHiddenMethodTest7() {
+        performAnalysis("findhiddenmethodtest/SuperGoodMultipleStaticMethod.class",
+                "findhiddenmethodtest/GoodMultipleStaticMethod.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    void testGoodFindHiddenMethodTest8() {
+        performAnalysis("findhiddenmethodtest/SuperGoodNonOrderedMultipleStaticMethods.class",
+                "findhiddenmethodtest/GoodNonOrderedMultipleNonStaticMethods.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    void testGoodFindHiddenMethodTest9() {
+        performAnalysis("findhiddenmethodtest/GoodOuterInnerClassNonStatic.class",
+                "findhiddenmethodtest/GoodOuterInnerClassNonStatic$GoodInnerNonStaticGood.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    void testGoodFindHiddenMethodTest10() {
+        performAnalysis("findhiddenmethodtest/GoodOuterInnerClassPrivate.class",
+                "findhiddenmethodtest/GoodOuterInnerClassPrivate$GoodInnerClassPrivate.class");
+        assertNoHSBCBug();
+    }
+
+    @Test
+    void testGoodFindHiddenMethodTest11() {
+        performAnalysis("findhiddenmethodtest/SuperGoodProtected.class",
+                "findhiddenmethodtest/GoodProtected.class");
+        assertNoHSBCBug();
+    }
+
+    private void assertNoHSBCBug() {
+        final BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .bugType(BUG_TYPE)
+                .build();
+        assertThat(getBugCollection(), containsExactly(0, bugTypeMatcher));
+    }
+
+    private void assertHSBCBug(String methodName, int lineNumber) {
+        final BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .bugType(BUG_TYPE)
+                .inMethod(methodName)
+                .atLine(lineNumber)
+                .build();
+        assertThat(getBugCollection(), hasItem(bugTypeMatcher));
+    }
+}
diff --git a/spotbugs/etc/findbugs.xml b/spotbugs/etc/findbugs.xml
index b261aa0a959..c4b0e6dea6e 100644
--- a/spotbugs/etc/findbugs.xml
+++ b/spotbugs/etc/findbugs.xml
@@ -686,7 +686,10 @@
                     reports="ENV_USE_PROPERTY_INSTEAD_OF_ENV"/>
           <Detector class="edu.umd.cs.findbugs.detect.MultipleInstantiationsOfSingletons" speed="fast"
                     reports="SING_SINGLETON_IMPLEMENTS_CLONEABLE,SING_SINGLETON_INDIRECTLY_IMPLEMENTS_CLONEABLE,SING_SINGLETON_IMPLEMENTS_CLONE_METHOD,SING_SINGLETON_HAS_NONPRIVATE_CONSTRUCTOR,SING_SINGLETON_IMPLEMENTS_SERIALIZABLE,SING_SINGLETON_GETTER_NOT_SYNCHRONIZED" />
-    <!-- Bug Categories -->
+          <Detector class="edu.umd.cs.findbugs.detect.FindHiddenMethod" speed="fast"
+                    reports="HSM_HIDING_METHOD"/>
+
+          <!-- Bug Categories -->
           <BugCategory category="NOISE" hidden="true"/>
 
           <!-- Bug Codes -->
@@ -718,6 +721,7 @@
           <BugCode abbrev="ASE"/>
           <BugCode abbrev="VSC"/>
           <BugCode abbrev="DA"/>
+          <BugCode abbrev="HSM"/>
           <!-- Bug patterns -->
           <BugPattern abbrev="JUA" type="JUA_DONT_ASSERT_INSTANCEOF_IN_TESTS" category="BAD_PRACTICE" experimental="true" />
           <BugPattern abbrev="AA" type="AA_ASSERTION_OF_ARGUMENTS" category="BAD_PRACTICE" />
@@ -1331,4 +1335,5 @@
           <BugPattern abbrev="SING" type="SING_SINGLETON_IMPLEMENTS_SERIALIZABLE" category="CORRECTNESS" />
           <BugPattern abbrev="SING" type="SING_SINGLETON_GETTER_NOT_SYNCHRONIZED" category="CORRECTNESS" />
           <BugPattern abbrev="ENV" type="ENV_USE_PROPERTY_INSTEAD_OF_ENV" category="BAD_PRACTICE" />
+          <BugPattern abbrev="HSM" type="HSM_HIDING_METHOD" category="CORRECTNESS"/>
 </FindbugsPlugin>
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 6600aa50981..59648c081c8 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1839,6 +1839,17 @@ factory pattern to create these objects.</p>
       ]]>
     </Details>
   </Detector>
+  <Detector class="edu.umd.cs.findbugs.detect.FindHiddenMethod">
+    <Details>
+      <![CDATA[
+            <p>
+              Looks for hiding of static, non-private methods by the subclass.
+              It has exceptions for main method, constructor, inner classes, and auto generated methods.
+            </p>
+      ]]>
+    </Details>
+  </Detector>
+
   <!--
   **********************************************************************
   BugPatterns
@@ -9126,6 +9137,25 @@ Using floating-point variables should not be used as loop counters, as they are
         ]]>
     </Details>
   </BugPattern>
+  <BugPattern type="HSM_HIDING_METHOD">
+    <ShortDescription>Method hiding should be avoided.</ShortDescription>
+    <LongDescription>The method '{1}' in class '{2}' hides a method in class '{3}'. Declare the respective methods non-static or private to eradicate the problem.</LongDescription>
+    <Details>
+      <![CDATA[
+        Hiding happens when a sub class defines a static method
+        with same header (signature plus return type) as in any of the super classes.
+        In the event of method hiding the invoked method is determined based on the specific qualified name or
+        method invocation expression used at the calling site.
+        The results are often unexpected, although the Java language provides unambiguous rules for method invocation for method hiding.
+        Moreover, method hiding and method overriding is often confused by programmers.
+        Consequently, programmers should avoid the method hiding.
+        Programmer should declare the respective method non-static or restrict it as private to eradicate the problem.
+        <p>
+        See SEI CERT rule <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">MET07-J. Never declare a class method that hides a method declared in a superclass or superinterface</a>.
+        </p>
+        ]]>
+    </Details>
+  </BugPattern>
   <BugPattern type="PI_DO_NOT_REUSE_PUBLIC_IDENTIFIERS_CLASS_NAMES">
         <ShortDescription>Do not reuse public identifiers from JSL as class name</ShortDescription>
         <LongDescription>The name of the class {0} shadows the publicly available identifier from the Java Standard Library.</LongDescription>
@@ -9430,4 +9460,5 @@ Using floating-point variables should not be used as loop counters, as they are
   <BugCode abbrev="AA">Misuse of assertions for checking arguments of public methods</BugCode>
   <BugCode abbrev="PI">Do not reuse public identifiers from Java Standard Library</BugCode>
   <BugCode abbrev="ENV">Environment variable is used instead of the corresponding Java property</BugCode>
+  <BugCode abbrev="HSM">Avoid method hiding</BugCode>
 </MessageCollection>
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
new file mode 100644
index 00000000000..4d5f10cc5e4
--- /dev/null
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindHiddenMethod.java
@@ -0,0 +1,143 @@
+/*
+ * SpotBugs - Find bugs in Java programs
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+package edu.umd.cs.findbugs.detect;
+
+import edu.umd.cs.findbugs.BugInstance;
+import edu.umd.cs.findbugs.Detector;
+import edu.umd.cs.findbugs.SourceLineAnnotation;
+import edu.umd.cs.findbugs.ba.ClassContext;
+import org.apache.bcel.generic.BasicType;
+import edu.umd.cs.findbugs.BugReporter;
+import edu.umd.cs.findbugs.ba.AnalysisContext;
+import org.apache.bcel.classfile.JavaClass;
+import org.apache.bcel.classfile.Method;
+import org.apache.bcel.Const;
+import org.apache.bcel.generic.Type;
+
+import java.util.Arrays;
+
+/**
+ * This detector finds all the methods of a subclass which are hiding the static methods of the superclass.
+ * Please see @see <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">SEI CERT MET07-J</a>
+ * @author Nazir, Muhammad Zafar Iqbal
+ */
+public class FindHiddenMethod implements Detector {
+    private final BugReporter bugReporter;
+
+    public FindHiddenMethod(BugReporter bugReporter) {
+        this.bugReporter = bugReporter;
+    }
+
+    /*
+     * Only the super classes are analyzed, not the super interfaces
+     * Reason: when I looked in detail of the super interfaces,
+     * I found there is no point to analyze as whenever we have method hiding due to super interfaces,
+     * We can call the method by fully qualified name only (as Interface can't be instantiated).
+     * Calling a hidden method by fully qualified name is a compliant test.
+     * See @see <a href="https://wiki.sei.cmu.edu/confluence/display/java/MET07-J.+Never+declare+a+class+method+that+hides+a+method+declared+in+a+superclass+or+superinterface">SEI CERT MET07-J</a>
+     * Thereof, it is useless to analyze super interfaces in the detector.
+     */
+    @Override
+    public void visitClassContext(ClassContext classContext) {
+        //First, I get the subclass and superclasses in variables.
+        //This is the current class. Named it subClass to better depict the idea of sub and super class.
+        JavaClass subClass = classContext.getJavaClass();
+        //No need for null check as every class has at least `Object` as its super class.
+        JavaClass[] superClasses;
+        try {
+            superClasses = subClass.getSuperClasses();
+        } catch (ClassNotFoundException e) {
+            AnalysisContext.reportMissingClass(e);
+            return;
+        }
+        //I store all the methods of subclass in an array
+        Method[] methods = subClass.getMethods();
+        //I filter the non-private and static methods, as private methods can't be overridden.
+        //Then for each method, I go through each method of the superclass for checking method hiding.
+        for (Method method : methods) {
+            //Careful!!! regarding the order of the conditions applied here
+            //Taking advantage of short circuit evaluation here by placing !method.isStatic() first.
+            //I check for the exceptional cases of inner class using three auxiliary private methods.
+            if (!method.isStatic() || method.isPrivate() || isMainMethod(method) ||
+                    isConstructor(method) || isHidingInnerClass(method) || isAutoGeneratedMethod(method)) {
+                continue;
+            }
+
+            for (JavaClass superClass : superClasses) {
+                Method[] superMethods = superClass.getMethods();
+                //I check whether the subclass method is hiding the superclass method. If yes I report the bug.
+                if (Arrays.asList(superMethods).contains(method)) {
+                    bugReporter.reportBug(new BugInstance(this, "HSM_HIDING_METHOD", NORMAL_PRIORITY)
+                            .addClass(subClass.getClassName())
+                            .addMethod(subClass, method)
+                            .addClass(superClass.getClassName())
+                            .addSourceLine(SourceLineAnnotation.fromVisitedInstruction(subClass, method, 0)));
+                }
+            }
+        }
+    }
+
+    @Override
+    public void report() {
+    }
+
+    /**
+     *This method checks for the inner class exceptional cases.
+     *As whenever there an inner class, '.access$' methods are created hiddenly to access the outer class attributes.
+     */
+    private boolean isHidingInnerClass(Method method) {
+        return method.getName().contains("access$");
+    }
+
+    /**
+     *This method checks for the autoGenerated methods for an inner class - exceptional cases.
+     *As whenever there an inner class, '.class$' methods are created hiddenly.
+     */
+    private boolean isAutoGeneratedMethod(Method method) {
+        return method.getName().contains("class$");
+    }
+
+    /**
+     * This method is here to check the exceptional case of Constructors
+     */
+    private boolean isConstructor(Method method) {
+        return Const.STATIC_INITIALIZER_NAME.equals(method.getName()) || Const.CONSTRUCTOR_NAME.equals(method.getName());
+    }
+
+    /**
+     * This method checks for the exceptional case of main method.
+     * As we know main method always have the signature "public static void main(String[] args)".
+     * It is static but usually public class have its own main method as its entry point.
+     * Therefore, it is not an error caused by Programming but a utility to provide UI to user.
+     *
+     * This condition is to abide with the latest main method criteria.  @see <a href="https://openjdk.org/jeps/445">JEP 445</a>
+     */
+    private boolean isMainMethod(Method method) {
+        return !method.isPrivate() && method.getReturnType().equals(BasicType.VOID) && "main".equals(method.getName())
+                && (isStringArray(method.getArgumentTypes()) || method.getArgumentTypes().length == 0);
+    }
+
+    /**
+     * This method checks whether the argument is String array
+     */
+    private boolean isStringArray(Type[] methodArguments) {
+        return methodArguments.length == 1 &&
+                "java.lang.String[]".equals(methodArguments[0].toString());
+    }
+}
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/BadFindHiddenMethodTest.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadFindHiddenMethodTest.java
new file mode 100644
index 00000000000..6255b428b85
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadFindHiddenMethodTest.java
@@ -0,0 +1,17 @@
+package findhiddenmethodtest;
+
+class GrantAccessStatic {
+    public static void displayAccountStatus() {
+        System.out.println("displayAccountStatus (GrantAccessStatic)");
+    }
+}
+
+/**
+ * This test case is a non-compliant test case for the bug.
+ * As the displayAccountStatus() is static, non-private (public) and being hidden by subclass.
+ */
+class BadFindHiddenMethodTest extends GrantAccessStatic {
+    public static void displayAccountStatus() {
+        System.out.println("displayAccountStatus (GrantUserAccessStatic)");
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/BadHidingVsOverriding.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadHidingVsOverriding.java
new file mode 100644
index 00000000000..ab77cdd87d1
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadHidingVsOverriding.java
@@ -0,0 +1,24 @@
+package findhiddenmethodtest;
+
+class BadSuperClass {
+    public static void methodHiding() {
+        System.out.println("methodHiding (BadSuperClass)");
+    }
+    public void methodOverriding() {
+        System.out.println("methodOverriding (BadSuperClass)");
+    }
+}
+
+/**
+ * This class is the non-compliant test case for the bug.
+ * This test case also clarifies the confusion of method overriding and method hiding.
+ * As the `methodHiding` is being hidden while `methodOverriding` is being overridden.
+ */
+class BadHidingVsOverriding extends BadSuperClass {
+    public static void methodHiding() {
+        System.out.println("methodHiding (BadSuperClass)");
+    }
+    public void methodOverriding() {
+        System.out.println("methodOverriding (BadSuperClass)");
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/BadInEqualMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadInEqualMultipleStaticMethod.java
new file mode 100644
index 00000000000..d4ca4b3d4a3
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadInEqualMultipleStaticMethod.java
@@ -0,0 +1,31 @@
+package findhiddenmethodtest;
+
+class SuperBadInEqualMultipleMethod {
+    static void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (Super) " + s);
+    }
+
+    public static void display3() {
+        System.out.println("display3 (SuperBadInEqualMultipleMethod)");
+    }
+}
+
+
+/**
+ * This test case is a non-compliant test case with multiple methods declared in both super and sub classes.
+ * As the overridden methods are static, and non-private.
+ * Number of methods in both classes are different.
+ */
+class BadInEqualMultipleStaticMethod extends SuperBadInEqualMultipleMethod {
+    static void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/BadMainMethodCheck.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMainMethodCheck.java
new file mode 100644
index 00000000000..4771beced97
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMainMethodCheck.java
@@ -0,0 +1,21 @@
+package findhiddenmethodtest;
+
+class BadSuperClassWithMain {
+    public static int main(String[] args) {
+        System.out.println("main (BadSuperClassWithMain)");
+        return 1;
+    }
+}
+
+/**
+ * This class is the non-compliant test case for the bug.
+ * This test case checks the exceptional case of main method
+ * but observe this main method is not the entry point main method due to different signature.
+ * White spaces in "String[]" are intentional to check for whitespace issue in type matching.
+ */
+public class BadMainMethodCheck extends BadSuperClassWithMain{
+    public static int main( String[  ] args) {
+        System.out.println("main (BadMainMethodCheck)");
+        return 2;
+    }
+}
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultiLevelInheritance.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultiLevelInheritance.java
new file mode 100644
index 00000000000..677b84c6409
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultiLevelInheritance.java
@@ -0,0 +1,23 @@
+package findhiddenmethodtest;
+
+class BadGrandClass {
+    public static void display(String s) {
+        System.out.println("Grand Information: " + s);
+    }
+}
+
+class BadParentClass extends BadGrandClass {
+}
+
+/**
+ * This test case is a non-compliant test case with multiple level inheritance.
+ * As the overridden methods are static, non-private.
+ * The `BadParentClass` inherit `display` method form `BadGrandClass`
+ * The `BadMultiLevelInheritance` (child class) hides the `display` method.
+ */
+class BadMultiLevelInheritance extends BadParentClass {
+    public static void display(String s) {
+        BadParentClass.display("");
+        System.out.println("Child information" + s);
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultipleStaticMethods.java
new file mode 100644
index 00000000000..0d46aa7386d
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadMultipleStaticMethods.java
@@ -0,0 +1,25 @@
+package findhiddenmethodtest;
+
+class SuperBadMultipleMethods {
+    static void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (Super) " + s);
+    }
+}
+
+/**
+ * This test case is a non-compliant test case with multiple methods declared in both super and sub classes.
+ * As the overridden methods are static, and non-private.
+ */
+class BadMultipleStaticMethods extends SuperBadMultipleMethods {
+    static void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/BadNonOrderedMultipleStaticMethods.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadNonOrderedMultipleStaticMethods.java
new file mode 100644
index 00000000000..a2f6821429d
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadNonOrderedMultipleStaticMethods.java
@@ -0,0 +1,30 @@
+package findhiddenmethodtest;
+
+class SuperBadNonOrderedMultipleStaticMethods {
+    public static void display3() {
+        System.out.println("display3 (SuperBadInEqualMultipleMethod)");
+    }
+    static void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (Super) " + s);
+    }
+}
+
+
+/**
+ * This test case is a non-compliant test case with multiple methods declared in both super and sub classes.
+ * But the method definition is in different order and number of methods in both classes are different.
+ * As the overridden methods are static, and non-private. It is non-compliant.
+ */
+class BadNonOrderedMultipleStaticMethods extends SuperBadNonOrderedMultipleStaticMethods {
+    static void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    static void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/BadOuterInnerClass.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadOuterInnerClass.java
new file mode 100644
index 00000000000..5dab24e8b28
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadOuterInnerClass.java
@@ -0,0 +1,18 @@
+package findhiddenmethodtest;
+
+/**
+ * This is a non-compliant test case as the methods are declared static and non-private,
+ * There is inheritance so method hiding as well,
+ * but they are in an inner and outer class relation.
+ */
+public class BadOuterInnerClass {
+    public static int badMethod() {
+        return 1;
+    }
+
+    private static class BadInner extends BadOuterInnerClass {
+        public  static int badMethod(){
+            return 2;
+        }
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/BadProtected.java b/spotbugsTestCases/src/java/findhiddenmethodtest/BadProtected.java
new file mode 100644
index 00000000000..24e1b434cdc
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/BadProtected.java
@@ -0,0 +1,17 @@
+package findhiddenmethodtest;
+
+class SuperBadProtected {
+    protected static void display(String s) {
+        System.out.println("Display some information " + s);
+    }
+}
+
+/**
+ * This test case is a non-compliant test case for the bug.
+ * As the display() is static, non-private (protected) and being hidden by subclass.
+ */
+class BadProtected extends SuperBadProtected {
+    protected static void display(String s) {
+        System.out.println("Display some information in sub class " + s);
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodFindHiddenMethodTest.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodFindHiddenMethodTest.java
new file mode 100644
index 00000000000..9ff053a67a7
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodFindHiddenMethodTest.java
@@ -0,0 +1,18 @@
+package findhiddenmethodtest;
+
+class GrantAccess {
+    public void displayAccountStatus() {
+        System.out.print("displayAccountStatus (GrantAccess)");
+    }
+}
+
+/**
+ * This test case is the compliant test case for the bug.
+ * As the displayAccountStatus() is declared as non-static and non-private (public)
+ */
+class GoodFindHiddenMethodTest extends GrantAccess {
+    @Override
+    public void displayAccountStatus() {
+        System.out.print("displayAccountStatus (GrantUserAccess)");
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodInEqualNonStaticMethods.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodInEqualNonStaticMethods.java
new file mode 100644
index 00000000000..651cbb3dde0
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodInEqualNonStaticMethods.java
@@ -0,0 +1,30 @@
+package findhiddenmethodtest;
+
+class SuperGoodInEqualMultipleMethod {
+    void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    private void display2(String s) {
+        System.out.println("Second method (Super) " + s);
+    }
+
+    void display3() {
+        System.out.println("display3 (SuperBadInEqualMultipleMethod)");
+    }
+}
+
+/**
+ * This test case is a compliant test case with multiple methods declared in both super and sub classes.
+ * As the overridden methods are non-static.
+ * Number of methods in both classes are different.
+ */
+class GoodInEqualNonStaticMethods extends SuperGoodInEqualMultipleMethod {
+    void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMainMethodCheck.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMainMethodCheck.java
new file mode 100644
index 00000000000..54d3d12854d
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMainMethodCheck.java
@@ -0,0 +1,18 @@
+package findhiddenmethodtest;
+
+class GoodSuperClassWithMain {
+    public static void main(String[] args) {
+        System.out.println("main (GoodSuperClassWithMain)");
+    }
+}
+
+/**
+ * This class is the compliant test case for the bug.
+ * This test case checks the exceptional case of main method.
+ */
+public class GoodMainMethodCheck extends GoodSuperClassWithMain
+{
+    public static void main(String[] args) {
+        System.out.println("main (GoodMainMethodCheck)");
+    }
+}
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.java
new file mode 100644
index 00000000000..542f5213e7c
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritanceNonStatic.java
@@ -0,0 +1,20 @@
+package findhiddenmethodtest;
+
+class GoodGrandNonStatic {
+    public void display(String s, int i) {
+        System.out.println("Grand Information: ");
+    }
+}
+
+class GoodParentNonStatic extends GoodGrandNonStatic {
+}
+
+/**
+ * This test case is a compliant test case with multiple level inheritance.
+ * As the overridden methods are non-static.
+ */
+class GoodMultiLevelInheritanceNonStatic extends GoodParentNonStatic {
+    public void display(String s, int i) {
+        System.out.println("Child information");
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritancePrivate.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritancePrivate.java
new file mode 100644
index 00000000000..8a4cd8e3cf7
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultiLevelInheritancePrivate.java
@@ -0,0 +1,21 @@
+package findhiddenmethodtest;
+
+class GoodGrandClassPrivate {
+    private static void display(String s) {
+        System.out.println("Grand Information: " + s);
+    }
+}
+
+class GoodParentClassPrivate extends GoodGrandClassPrivate {
+}
+
+/**
+ * This test case is a compliant test case with multiple level inheritance.
+ * As the overridden methods are static but declared private.
+ * So actually none of the child classes inherit any method from its super class(es).
+ */
+class GoodMultiLevelInheritancePrivate extends GoodParentClassPrivate {
+    private static void display(String s) {
+        System.out.println("Child information" + s);
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleNonStaticMethods.java
new file mode 100644
index 00000000000..9b1e87761a9
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleNonStaticMethods.java
@@ -0,0 +1,26 @@
+package findhiddenmethodtest;
+
+class SuperMultipleNonStatic {
+    void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    void display2(String s) {
+        System.out.println("Second method (Super) " + s);
+    }
+}
+
+/**
+ * This test case is a compliant test case with multiple methods declared in both super and sub classes.
+ * As the overridden methods are non-static and non-private.
+ * So, this is overriding instead of method hiding.
+ */
+class GoodMultipleNonStaticMethods extends SuperMultipleNonStatic {
+    void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleStaticMethod.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleStaticMethod.java
new file mode 100644
index 00000000000..5c4d06103ff
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodMultipleStaticMethod.java
@@ -0,0 +1,26 @@
+package findhiddenmethodtest;
+
+class SuperGoodMultipleStaticMethod {
+    private static void display(String s) {
+        System.out.println("first method (Super)" + s);
+    }
+
+    private static void display2(String s) {
+        System.out.println("Second method (Super)" +s);
+    }
+}
+
+/**
+ * This class test is a compliant test case for multiple static method declarations,
+ * but the static methods are declared as private.
+ * So there is no method inherited actually
+ */
+class GoodMultipleStaticMethod extends SuperGoodMultipleStaticMethod {
+    private static void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    private static void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodNonOrderedMultipleNonStaticMethods.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodNonOrderedMultipleNonStaticMethods.java
new file mode 100644
index 00000000000..3c583977f36
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodNonOrderedMultipleNonStaticMethods.java
@@ -0,0 +1,30 @@
+package findhiddenmethodtest;
+
+class SuperGoodNonOrderedMultipleStaticMethods {
+    public static void display3() {
+        System.out.println("display3 (SuperBadInEqualMultipleMethod)");
+    }
+    void display(String s) {
+        System.out.println("first method (Super) " + s);
+    }
+
+    private void display2(String s) {
+        System.out.println("Second method (Super) " + s);
+    }
+}
+
+
+/**
+ * This test case is a compliant test case with multiple methods declared in both super and sub classes.
+ * But the method definition is in different order and number of methods in both classes are different.
+ * As the overridden methods are nonstatic. It is compliant.
+ */
+class GoodNonOrderedMultipleNonStaticMethods extends SuperGoodNonOrderedMultipleStaticMethods {
+    void display(String s) {
+        System.out.println("first method (sub) " + s);
+    }
+
+    void display2(String s) {
+        System.out.println("Second method (sub) " + s);
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassNonStatic.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassNonStatic.java
new file mode 100644
index 00000000000..62b2411eda6
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassNonStatic.java
@@ -0,0 +1,17 @@
+package findhiddenmethodtest;
+
+/**
+ * This is a compliant test case as the methods are declared non-static and non-private,
+ * There is an inheritance thereof method overriding,
+ * but they are in an inner and outer class relation.
+ */
+public class GoodOuterInnerClassNonStatic {
+    public void method1(){
+        System.out.println("method1 (GoodOuterInnerClassPrivate)");
+    }
+    public static class GoodInnerNonStaticGood extends GoodOuterInnerClassNonStatic {
+        public void method1(){
+            System.out.println("method1 (GoodOuterInnerClassPrivate)");
+        }
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassPrivate.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassPrivate.java
new file mode 100644
index 00000000000..1934cddefb3
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodOuterInnerClassPrivate.java
@@ -0,0 +1,17 @@
+package findhiddenmethodtest;
+
+/**
+ * This is a compliant test case as the methods are declared static but private,
+ * There is no inheritance as the methods are private,
+ * but they are in an inner and outer class relation.
+ */
+public class GoodOuterInnerClassPrivate {
+    private static void method1(){
+        System.out.println("method1 (GoodOuterInnerClassPrivate)");
+    }
+    public static class GoodInnerClassPrivate extends GoodOuterInnerClassPrivate {
+        private static void method1(){
+            System.out.println("method1 (GoodInnerClassPrivate)");
+        }
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/findhiddenmethodtest/GoodProtected.java b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodProtected.java
new file mode 100644
index 00000000000..7458899dfcd
--- /dev/null
+++ b/spotbugsTestCases/src/java/findhiddenmethodtest/GoodProtected.java
@@ -0,0 +1,18 @@
+package findhiddenmethodtest;
+
+class SuperGoodProtected {
+    protected void display(String s) {
+        System.out.println("Display some information " + s);
+    }
+}
+
+
+/**
+ * This test case is a compliant test case for the bug.
+ * As the display() is non-static, non-private (protected) and not being hidden by subclass.
+ */
+class GoodProtected extends SuperGoodProtected {
+    protected void display(String s) {
+        System.out.println("Display some information in sub class " + s);
+    }
+}
\ No newline at end of file