The difference between Java interfaces and classes: definition of member variables and methods

Java interfaces and classes are two important concepts in object-oriented programming. There are some differences between interfaces and classes in defining member variables and methods. This article will introduce the differences between the two through specific code examples.

First, let’s take a look at the interface. An interface is an abstract data type that only contains the declaration of methods without the specific implementation of the methods. An interface defines which methods a class should implement, but cannot define member variables. The methods in the interface are public and abstract by default, so there is no need to declare the access modifier of the method in the interface.

The following is a sample code for an interface:

public interface Animal {
    public void eat();
    public void sleep();
}

In the above code, Animal is an interface that defines an eat() method and a sleep() method. Any class that implements the Animal interface must implement these two methods.

The advantage of the interface is that it provides a decoupled way to separate implementation details and method declarations. In this way, different classes can implement the same interface, thereby achieving the purpose of code reuse.

Next, let’s take a look at classes. A class is a concrete data type that can contain definitions of member variables and methods. A class can define its own member variables and methods as needed, and can have multiple constructors, including ordinary methods, static methods, private methods, etc. Classes can inherit from other classes and implement one or more interfaces.

The following is a sample code for a class:

public class Dog implements Animal {
    private String name;

    public Dog(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + "正在吃东西");
    }

    public void sleep() {
        System.out.println(name + "正在睡觉");
    }

    public void bark() {
        System.out.println(name + "正在汪汪叫");
    }

    public static void main(String[] args) {
        Dog dog = new Dog("旺财");
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

In the above code, Dog is a class that implements the Animal interface. It contains a name member variable and three methods: eat(), sleep() and bark(). In addition to implementing the two methods in the Animal interface, the Dog class also adds a unique bark() method. A Dog object is created in the main function and three methods are called for testing.

It should be noted that a class can implement one or more interfaces, but can only inherit one parent class. If a class inherits the parent class and implements the interface at the same time, then the inheritance relationship should be placed in the front and the interface implementation relationship in the back, for example:

public class Cat extends AnimalClass implements AnimalInterface {
    // ...
}

In the above code, the Cat class first inherits the parent class AnimalClass , and then implements the interface AnimalInterface.

In short, Java interfaces and classes are different in defining member variables and methods. Interfaces can only define method signatures and cannot define member variables; classes can define their own member variables and methods, and can implement one or more interfaces. Interfaces and classes are important concepts in object-oriented programming. It is very important for Java developers to master their usage proficiently.

The above is the detailed content of The difference between Java interfaces and classes: definition of member variables and methods. For more information, please follow other related articles on the PHP Chinese website!