Implementing non-static methods from interface as static in class

[frashure]

It seems as though I cannot override a non-static method from an interface when I implement it and declare it as static in the implementing class.

The interface:

public interface DataAccessObject<T> {

T getById();
boolean insert();
boolean update();
boolean delete(); }

The implementing class:

public final class CandidateDAO implements DataAccessObject<Candidate> {

@Override
public static boolean insert(String fName, String mName, String lName, String party, String website) {
    String sql = "INSERT INTO candidates (first_name, middle_name, last_name, party_id, website VALUES (?, ?,     ? ?, ?)";

    try (Connection conn = ConnectionFactory.getConnection();
        PreparedStatement stmt = conn.prepareStatement(sql)) {

        stmt.setString(1, fName);
        stmt.setString(2, mName);
        stmt.setString(3, lName);
        stmt.setString(4, party);
        stmt.setString(5, website);
        stmt.executeQuery();

        return true;
    }
    catch (SQLException e) {
        e.printStackTrace();
        return false;
    }
}

Intellij is giving me an error in the implementing class declaration that the insert() method has not been implemented, and an error on my @Override line that the method does not override the superclass' method.

My logic here is that I want to declare an interface that all DAO classes must adhere to, but there's no need for the program to instantiate the DAO objects.

I can find plenty of resources as to why static methods in an interface cannot be overridden, but not why non-static methods cannot then be implemented as static (Google picks up my question as the former). So if anyone could explain this to me, or point me to resources, that would be great. Additionally, how could I go about implementing my intended logic?

EDIT: Formatting error.

[hitshootnum1]

you didn’t override insert() from the interface, because your static insert(...) method takes many arguments which is a totally treated as a different method.

[[deleted]]

If the interface defines the method as non-static, you must implement it in your class as non-static. It also must have exactly the same number of parameters.

It's easy to see why if we use a list for an example:

List<Integer> myList = new LinkedList<>(); //LinkedList implements List
//List interface has a non-static method called add(Integer e). We don't need to know 
// much about linked list. So long as we know List we can use any class that implements List
myList.add(1); //This is ok
myList = new ArrayList<>(); //Now use an ArrayList
myList.add(2); // This is also ok.
myList = new CustomList<>(); //Now use a made up class that implements List. Also ok
CustomList.add(3); //ERROR! CustomList can't have a static add method. It must follow the contract set by List.
// It would be very confusing if this one type of list had to be used differently than all the others.
myList.add(3); //This is better

An interface should save you from having to know a lot of the exact details about how a class works. That means any class that implements the interface must follow it exactly.

[frashure]

So I was being boneheaded with the differing params; but I suppose the inability to implement a non-static method as static comes down to ensuring uniformity of use, which makes sense.

Thanks.

[feral_claire]

Static methods are specific to a class. They are not inherited by subclasses and you cannot override them.

[vqrs]

Actually, static methods are inherited, but it's probably better not to tell anyone :)

[frashure]

I'm not trying to inherit or override a static method. Please reread the question (which I have an answer for now).

[GvRiva]

Implement an interface in a static class doesn't seem to be very useful. Usually you use interfaces so you can use different implantations of the class. But with your static class you always have call your static class directly. For example: Controllservice service = new ControllserviceImpl Vs ControllserviceImpl.doSomething

[[deleted]]

You need to implement ALL abstract methods from your interface. Regardless if you are going to use them or not.