Difference between normal class and abstract class

Making a class abstract allows you to use abstract functions. Abstract functions allow you to guarantee that children/subclasses will have these functions on them. The abstract class will not be instantiatable (can't exist "in the world").

Example:

public abstract class Dog

cannot exist via

Dog dog = new Dog()

but a subclass

public class GreatDane : Dog

can exist in the world.

GreatDane greatDane = new GreatDane()

Why? It makes no sense to create a generic "dog" in the world. Being abstract stops it being created. It also allows you to have abstract function template/stubs that all children/subclasses must have.

public abstract class Dog
{
    public abstract void Bark(); // Note there is no code/implementation. I am just telling my children to have this function on them.
}

public class GreatDane : Dog
{
    public override void Bark()
    {
        // Unique bark like a Great Dane
    }
}

Why not use an Interface like IBarkable?
You could, but having the base class "Dog" allows for shared/common behaviour. You could have regular functions, virtual functions or abstract functions.

For example, if 90% of dogs bark the same way, you can make Bark() virtual, so there is default/shared/common implementation.

public abstract class Dog // Abstract so it can't be instantiated, even though there are no abstract functions
{
    public virtual void Bark()
    {
        // Default (but overridable) barking code. Some dogs use this code.
    }

    public void WagTail()
    {
        // Only code that exists to wag tail. All dogs use this code.
    }

}

public class GreatDane : Dog
{
    // I will be lazy and use the base class's Bark()
}

public class Rottweiler : Dog
{
    public override void Bark()
    {
        // I will use this unique bark.
    }
}

With interfaces, every Bark() would be unique, leading to copy & pasted code.