Object-oriented implementation on Expense Tracking App I am creating a Expense Tracking Application in C# and right now I am trying to build its building blocks in a console app. I Would like to know your feedback if it is in a Object Oriented Design/Structure.

namespace ExpenseTrackerOOP
{
    class ExpenseTracker
    {
        static void Main(string[] args)
        {
            Account expense = new Expenses();
            expense.Initialize();

            Account earnings = new Earnings();
            earnings.Initialize();

        }
    }


    public enum ExpenseType
    {
        Food,
        Transportation,
        Utitlities
    }
    public enum AccountTypes
    {
        Expenses,
        Earnings
    }
    public class AccountType
    {
        public AccountTypes Type;
    }

    public abstract class Account
    {
        public decimal Value { get; set; }

        public AccountType Type;

        public abstract void Initialize();
    }

    public class Expenses : Account
    {
        public List&lt;Expenses&gt; Expenses_list { get; set; }

        public override void Initialize()
        {
            Expenses_list = new List&lt;Expenses&gt;(){
                new Expenses() { Value = 10, Type = (new AccountType{Type = AccountTypes.Expenses}) },
                new Expenses() { Value = 20, Type = (new AccountType{Type = AccountTypes.Expenses}) },
                new Expenses() { Value = 30, Type = (new AccountType{Type = AccountTypes.Expenses}) }
            };
        }
    }


    public class Earnings : Account
    {
        public List&lt;Earnings&gt; Earnings_list { get; set; }

        public override void Initialize()
        {
            Earnings_list = new List&lt;Earnings&gt;(){
                new Earnings() { Value = 10, Type = (new AccountType{Type = AccountTypes.Earnings}) },
                new Earnings() { Value = 20, Type = (new AccountType{Type = AccountTypes.Earnings}) },
                new Earnings() { Value = 30, Type = (new AccountType{Type = AccountTypes.Earnings}) }
            };
        }
    }
}
There are several aspects about your code worth reviewing: OO-principles, code conventions, functional design. Since you specifically requested to review OO-design and your question lacks context to review functional design, I'll focus on the former.

Inheritance
Expenses and Earnings both derive from Account to provide their specific implementation of Initialze. Because of a lack of context, I can't make a call about this design. The implementation of both classes does seem off. I don't think you want each instance of these classes to create and store the same fixed list of presets.

Polymorphism
This is proper use of polymorphism. The declaring type Account is the closest fit to enable the use case Initialize. The instance type Expenses provides the specific implementation of that method.

Account expense = new Expenses();
expense.Initialize();



Composition
You have been a bit too diligent in the composition of some of your classes. AccountType is a redundant class, which acts only as a wrapper for AccountTypes Type. Get rid of it and use AccountTypes directly in Account.

public class AccountType
{
     public AccountTypes Type;
}



Encapsulation
Account is an abstract class that does not provide an explicit constructor. A public default constructor is implied. It is impossible for derived classes to reduce the scope of the access modifier, hence it's a breach in encapsulation. Consider providing a protected constructor for abstract classes.
public abstract class Account
{
    protected Account() {}
}

All your properties and fields are mutable. This might be as desiged, but at least think about whether this is a requirement or just lazy design.

public decimal Value { get; set; }