Explain the difference between Java abstract class and ordinary class in detail

On Abstract Classes

In the object-oriented concept, all objects are described by classes, but conversely, not all classes are used to describe objects. If there is not enough information in a class to describe a concrete object, such a class is an abstract class.

Seeing this may still find it difficult to understand. Give an example to illustrate 1: What do you think of when you talk about animals? Cats, dogs, chickens, ducks and geese? Of course, all these can be done. So, can you identify a specific object for the word animal? Obviously not. Even more strictly speaking, what do you think of when you talk about cats? Orange cat, short beauty …

After all:

There are 1,000 Hamley meows in 1,000 people's hearts.

Therefore, in our design, animals can be designed as abstract classes, while a specific species can be realized by inheriting animals.

I understand this part of polymorphism for a long time, one day suddenly will be used, also understand the so-called parent class reference to subclass object is what it means. But after writing, I found that I understand that speaking out is still very vague. Polymorphism is really very important, very important a point, to understand this part.

What is the difference between abstract classes and ordinary classes?

Grammatical rules of abstract classes

Syntax rules for abstract classes: abstract Keyword modification

1. Abstract classes cannot be instantiated.

2. Abstract classes may have abstract methods.

If there are abstract methods in 3.1 classes, then this class 1 must be an abstract class.

4. There can be ordinary properties, methods, static properties, and static methods in abstract classes.

5. Constructors can exist in abstract classes.

public abstract class AbstractObject{
	//  Common attribute 
    String name;
	//  Construction method 
    public AbstractObject(String name) {
        this.name = name;
    }
    //  Static method  -  Class name access 
    public static void staticMethod(){
        System.out.println(" Abstract classes can have static methods .");
    }
	//  Abstract method 
    public abstract void move();
	//  Common method 
    public void commonMethod(String food){
        System.out.println(" Abstract classes can have common methods .");
    }
}

Abstract classes cannot be instantiated

This part can remember the conclusion directly and temporarily, and the whole process can be skipped for the time being. According to my learning experience (the foundation is so poor), this part will be stupid when I look directly.

Define an abstract class of animals. Animals have to move (no! ) So define a common move () method.

public abstract class Animal {
    String name;
    public Animal(String name) {
        this.name = name;
    }
    public abstract void move();
}

When I wrote the example with IDEA, the second situation appeared directly! Damn it, abstract classes new It's coming out!

public class Test {
    public static void main(String[] args) {
    	//  Abstract classes cannot be instantiated ! Compile-time errors are reported directly !
        // Red-marked information : 'Animal' is abstract; cannot be instantiated
        Animal animal = new Animal(" Kitten ");
        //  No. 1 2 A situation 
        Animal animalObjcet = new Animal(" Kitten ") {
            @Override
            public void move() {
                System.out.println(" I'm starting to move !");
            }
        };
    }
}

Explanation of Case 2-Extended Knowledge: Anonymous Inner Classes (Skipped)

There is a knowledge point involved here called anonymous inner class.
The format of anonymous inner classes is as follows:

new  Class name or interface name (){
	 Override method ;
}
//  Put 1 From a comparative point of view , Obviously, what follows is 1 Anonymous inner classes 
new Animal(" Kitten ") {
    @Override
    public void move() {
        System.out.println(" I'm starting to move !");
    }
};

Anonymous: This class has no name
Inner class: A class that exists inside a class.

It actually inherits and implements a subclass of the Animal abstract class. That is to say, the Animal class is not instantiated here. This simple writing is equivalent to the following writing.

public class AnimalObject extends Animal{
    public AnimalObject(String name) {
        super(name);
    }
    @Override
    public void move() {
        System.out.println(" I am 1 Animals that can only move !");
    }
}

public class Test {
    public static void main(String[] args) {
        AnimalObject animalObject = new AnimalObject(" I am a subclass of animal abstract class ");
        animalObjcet.move();	//  I am 1 Animals that can only move !
    }
}

Subclasses of abstract classes

Note: There is one point that needs to be emphasized here. For methods in abstract classes, our words should be implemented. For methods that have been implemented, our words can be rewritten. After writing, I found that all my words in the previous description are rewritten.
Wrong writing: Do not override abstract methods in (Override) abstract classes
Correct writing: Do not implement abstract methods in (Implement) abstract classes
Added again: It seems that rewriting is not an error, and @ Override annotation is added in the automatic generation of IDEA. I won't continue to modify it.

1. Do not implement abstract methods in abstract classes

Subclass 1 is also an abstract class when an abstract method in an abstract class is not overridden. (Class 1 with an abstract method is an abstract class.)

public abstract class AbstractCat extends Animal{
    Integer weight;
    public AbstractCat(String name, Integer weight) {
        super(name);    //  Inherit the name of the parent class 
        this.weight = weight; //  The age of a cat 
    }
    //  This is not rewritten , It is still an abstract method 
    public abstract void move();
    //  Attention : The following writing is rewritten ! Only the method body is empty .
    // public void move(){};
}

2. Implement abstract methods in abstract classes

After implementing all the abstract methods in the abstract class, the cat class can now be a normal class.

public class Cat extends AbstractCat{
    public Cat(String name, Integer weight) {
        super(name, weight);
    }
    @Override
    public void move() {
        System.out.println("1 The weight that only runs is as high as " + weight + "kg Adj. " + name);
    }
}

Under Test 1:

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat(" Orange cat ", 20);
        cat.move();	// 1 The weight that only runs is as high as 20kg Orange cat 
    }
}

Ok, here, your orange cat finally runs!

On the Extension of Implementing Abstract Methods

I read many articles saying that subclasses should be rewritten (rewriting is wrong! Corrected here to implement) the abstract method of the parent class, abstract method. What if I only implement some abstract methods?
Step 1: Modify the Animal class

public abstract class Animal {
    String name;
    public Animal(String name) {
        System.out.println(" I am the construction method of animals !");
        this.name = name;
    }
    //  Add more abstract methods 
    public abstract void move();
    public abstract void eat();
    public abstract void sleep();
}

Step 2: Implement some abstract methods in the AbstractCat class

//  Do not add  abstract  Keyword will report an error 
// Class 'AbstractCat' must either be declared abstract or implement abstract method 'move()' in 'Animal'
public abstract class AbstractCat extends Animal{
    Integer weight;
    public AbstractCat(String name, Integer weight) {
        super(name);
        System.out.println(" I am the construction method of abstract cats !");
        //  Inherit the name of the parent class 
        this.weight = weight; //  The age of a cat 
    }
    @Override
    public void eat() {
        System.out.println(this.name + " Eating cat food ");
    }
    @Override
    public void sleep() {
        System.out.println(this.name + " Go to sleep !");
    }
}

Step 3: Cat class debut

public abstract class Animal {
    String name;
    public Animal(String name) {
        this.name = name;
    }
    public abstract void move();
}

0

Summary

1. Ordinary classes can be instantiated, but abstract classes cannot, because abstract classes are only a concept and cannot be mapped to concrete objects.

2. Both ordinary classes and abstract classes can be inherited, but after the abstract class is inherited, the subclass needs to override all the abstract methods in the abstract class, otherwise the subclass must be an abstract class.

Reference and extended reading

The difference between method overloading and method rewriting of Java basic series No.1 bomb
Characteristics of Java polymorphic member access in the second round of Java basic series
Java Basic Series 3 of the operation string classes are there? What's the difference?