Example analysis of Java abstract definition

1. Overview

In the concept of OOP, all objects are described through classes; but not all classes are used to describe objects. If a class does not contain enough information to describe a concrete object, such a class is called an abstract class.

Abstract class: (1) Abstract classes cannot instantiate objects. If an object is instantiated, compilation will not pass. Only non-abstract subclasses of abstract classes can create objects (2) that can include: member variables, member methods, constructors, etc. (3) Constructors and class methods (methods modified with static) cannot be declared as abstract methods

Abstract methods: (1) If a class contains an abstract method, then the class must be an abstract class (2) Any The subclass must override the abstract method of the parent class, or declare itself as an abstract class

Definition: abstract class Class name

2. Example: Farmers feeding animals

Animal: Abstract class--------getName(), move(), drink()

Reptile, Mammal: inherit abstract class

Snake, tiger, goat, rabbit: inherit respectively Reptile or Mammal

fammer:bringWater(), feedWater(Animal animal)---- Responsible for bringing water to the designated place, and then the animal moves to the destination and drinks water

The code is as follows:

package abstractDemo;
 
/**
 * @author lpx
 * @Description TODO
 * @date 2021-04-07
 */
public abstract class Animal {
    abstract String getName();
    abstract void move(String destination);
    abstract void drink();
}
abstract class Reptile extends Animal{
 
}
 
abstract class Mammal extends Animal{
 
}
 
class Tiger extends Mammal{
    private static String name="tiger";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("tiger move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("tiger lower it is head and drink");
    }
}
 
class Goat extends Mammal{
    private static String name="goat";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("goat move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("goat lower it head to drink");
    }
}
 
class Rabbit extends Mammal{
    private static String name="rabbit";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("rabbit move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("rabbit put out it is tongue and drink");
    }
}
 
class Snake extends Reptile{
    private static String name="snake";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("snake move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("snake dived into and drink");
    }
}
 
class Farmer{
    public void bringWater(String destination){
        System.out.println("Farmer bring water to " + destination + ".");
    }
 
    public void feedWater(Animal a){ // polymorphism
        this.bringWater("Feeding Room");
        a.move("Feeding Room");
        a.drink();
    }
 
}
 
class Test{
    public static void main(String[] args) {
        Farmer fm=new Farmer();
        Snake snake=new Snake();
        Goat goat=new Goat();
        Tiger tiger=new Tiger();
        Rabbit rabbit=new Rabbit();
 
        fm.feedWater(snake);
        fm.feedWater(goat);
        fm.feedWater(tiger);
        fm.feedWater(rabbit);
    }
}

Execution results:

##Summary:

If each animal is not abstracted For the drink and move methods, polymorphism cannot be achieved. The farmer class needs to overload multiple feedWaters according to different parameters. If you continue to add animals, the number of reloads will increase. In order to facilitate comparison and understanding, I also wrote it according to conventional thinking. The code is as follows:

package abstractDemo;
 
/**
 * @author lpx
 * @Description TODO
 * @date 2021-04-07
 */
 
class Tiger1{
    private static String name="tiger";
 
    String getName() {
        return this.name;
    }
 
    void move(String destination) {
        System.out.println("tiger move to "+destination+".");
    }
 
    void drink() {
        System.out.println("tiger lower it is head and drink");
    }
}
 
class Goat1{
    private static String name="goat";
 
    String getName() {
        return this.name;
    }
 
    void move(String destination) {
        System.out.println("goat move to "+destination+".");
    }
 
    void drink() {
        System.out.println("goat lower it head to drink");
    }
}
 
class Rabbit1{
    private static String name="rabbit";
 
    String getName() {
        return this.name;
    }
 
    void move(String destination) {
        System.out.println("rabbit move to "+destination+".");
    }
 
    void drink() {
        System.out.println("rabbit put out it is tongue and drink");
    }
}
 
class Farmer1{
    public void bringWater(String destination){
        System.out.println("Farmer bring water to " + destination + ".");
    }
 
    public void feedWater(Goat1 goat){ // polymorphism
        this.bringWater("Feeding Room");
        goat.move("Feeding Room");
        goat.drink();
    }
    public void feedWater(Tiger1 tiger){ // polymorphism
        this.bringWater("Feeding Room");
        tiger.move("Feeding Room");
        tiger.drink();
    }
 
    public void feedWater(Rabbit1 rabbit1) {
        this.bringWater("Feeding Room");
        rabbit1.move("Feeding Room");
        rabbit1.drink();
    }
}
 
public class Test1{
    public static void main(String[] args) {
        Farmer1 farmer1=new Farmer1();
        Tiger1 tiger1=new Tiger1();
        Goat1 goat1=new Goat1();
        Rabbit1 rabbit1=new Rabbit1();
        farmer1.feedWater(tiger1);
        farmer1.feedWater(goat1);
        farmer1.feedWater(rabbit1);
    }
}

I typed this example by hand and found that the basics are very important. I didn’t study carefully in the past, which led to confusion in many places. Why write that.

(1) Multiple classes can be defined in a .java file, but only one can be defined as public, and the class name must be the same as the file name

(2) Abstract class inheritance For an abstract class, there is no need to override its abstract method (the reason is also very simple, it is abstract and cannot implement the method body). While non-abstract classes inherit abstract classes must override abstract methods, and non-abstract methods are not necessary.

(3) The difference between rewriting and overloading (high-frequency interview question?)

Overloading: define the same method name but different parameters. It belongs to compile-time polymorphism

Rewriting: the subclass overrides the method @Override of the parent class. Belongs to runtime polymorphism

The above is the detailed content of Example analysis of Java abstract definition. For more information, please follow other related articles on the PHP Chinese website!