How do I delete an object that I made? (Lua object-oriented programming)

You are correct, when you remove all references to a table, it is deleted. This is taken care of by Lua's garbage collection:

• http://www.lua.org/manual/5.1/manual.html#2.10
• http://lua-users.org/wiki/GarbageCollectionTutorial

However, there are reasons you might want some sort of cleanup function:

• If your object subscribes to any events that will still exist when you want your object to be deleted, it needs to unsubscribe from them (or else the object can't be cleaned up because the event still holds a reference to it)
• If your object added itself to a collection of (in your example) apples (perhaps so some system can track how many apples are in the game at the moment and iterate through them as necessary), naturally you'll need to remove it from that collection (unless that collection uses weak keys/values)
• If you know the object will stay in memory for a while longer (ex maybe apples are referenced by an AppleTree which you intend to stay in memory for a longer period of time) and each Apple contains a reference to a large table or resource (that is specific to that apple), you should remove the references to that larger table/resource to allow it to be garbage collected.

For all other cases, you can expect that it will be removed from memory as needed. (In regular Lua you can force garbage collection to occur immediately with the debug library's collectgarbage, but Roblox has removed this functionality.)

For example, say these items are part of a player's inventory, and you have a dictionary tracking each player's inventory like playerInventory[player] = inventoryList. So long as you perform playerInventory[player] = nil when the player leaves the server, you don't need to do anything special to each inventory item, so long as the items don't do any of the above points.

If you wish to ensure that a piece of code isn't going to leak memory, you can use tables with weak keys/values to test, such as these functions I've written for that purpose:

local function waitForGarbageCollection() -- Creates garbage and waits for Lua to clean it up
    local t = setmetatable({}, {__mode="v"})
    t[1] = {}
    while t[1] do wait() end
end
local function LeaksMemory(create, cleanup)
    --  create:function() must return 1+ values.
    --  cleanup:function(...) -- optional; given what create returned
    --  Prints status message (with indices of leaked values if needed).
    local t = setmetatable({}, {__mode = "v"})
    local numValues
    do -- put create's values in temporary scope so they can be garbage collected
        local newValues = {create()}
        numValues = #newValues
        if numValues == 0 then error("create returned 0 values") end
        for i = 1, #newValues do
            t[i] = newValues[i]
        end
        if cleanup then cleanup(unpack(newValues)) end
    end
    waitForGarbageCollection()
    local numLeaked = 0
    local report = ": "
    for i = 1, numValues do
        if t[i] ~= nil then
            numLeaked = numLeaked + 1
            if numLeaked == 1 then
                report = report .. i
            else
                report = report .. ", " .. i
            end
        end
    end
    print(numValues > 1
        and string.format("%d/%d leaked%s", numLeaked, numValues, numLeaked > 0 and report or "")
        or numLeaked == 1 and "leaked" or "no leak")
end

-- Example usage:

local Item = {}
Item.__index = Item
function Item.new(ID, Amount)
    local NewItem = {}
    setmetatable(NewItem, Item)

    NewItem.ID = ID or 1
    NewItem.Amount = Amount or 0

    NewItem:Connect()

    return NewItem
end
function Item:Inc()
    self.Amount = self.Amount + 1
end
function Item:Connect()
    self.con = game:GetService("RunService").Heartbeat:Connect(function()
        self:Inc()
    end)
end
function Item:Destroy()
    if self.con then
        self.con:Disconnect()
    end
end

LeaksMemory(Item.new) -- leaked
LeaksMemory(Item.new, Item.Destroy) -- no leak

-- Note: LeaksMemory isn't a perfect indicator, as it assumes you'll give it a reference to everything that might be left in memory. For instance, if we change the Connect function to not refer to self...:

local a = 0
function Item:Connect()
    self.con = game:GetService("RunService").Heartbeat:Connect(function()
        a = a + 1
    end)
end
LeaksMemory(Item.new) -- no leak

-- ... you can see that it claims there is no leak when there really is one. If you can return a reference to everything that might be left in memory (from the function you pass in to LeaksMemory), you can get the full story:
function Item:Connect()
    local function func() a = a + 1 end
    self.con = game:GetService("RunService").Heartbeat:Connect(func)
    return func
end
function Item.new(ID, Amount)
    local NewItem = {}
    setmetatable(NewItem, Item)

    NewItem.ID = ID or 1
    NewItem.Amount = Amount or 0

    return NewItem, NewItem:Connect()
end
LeaksMemory(Item.new) -- 1/2 leaked: 2
LeaksMemory(Item.new, Item.Destroy) -- 0/2 leaked

-- The "1/2 leaked: 2" means that 1 of 2 items were leaked (and it was the item in the 2nd index that remained in memory), but calling Destroy ensured that even the function was removed from memory