Describe the concept of metatables in Lua and how they enable object-oriented programming. Provide an example illustrating the creation and usage of metatables.

Metatables in Lua are a powerful mechanism that allows programmers to modify the behavior of tables, effectively enabling object-oriented programming (OOP) constructs such as encapsulation, inheritance, and polymorphism. Metatables provide a way to define a set of operations or behaviors for a table, allowing us to customize how the table behaves when certain operations are performed on it.

In Lua, every table can have a metatable associated with it. The metatable is another table that holds a collection of metamethods—special keys with predefined names that define the behavior of the table when specific operations are applied to it. Metamethods are functions that get called automatically by Lua when certain events or operations occur on a table.

Let's illustrate the creation and usage of metatables with an example:

```
lua`-- Create a table
local myTable = { x = 10, y = 20 }

-- Create a metatable
local mt = {}

-- Define a metamethod "\_\_add" for addition operation
mt.\_\_add = function(table1, table2)
local result = {}
result.x = table1.x + table2.x
result.y = table1.y + table2.y
return result
end

-- Set the metatable for myTable
setmetatable(myTable, mt)

-- Create another table
local anotherTable = { x = 5, y = 15 }

-- Perform addition operation using the "+" operator
local sumTable = myTable + anotherTable

-- Print the result
print(sumTable.x, sumTable.y) -- Output: 15 35`
```
In the above example, we start by creating a table named `myTable` with two key-value pairs: `x = 10` and `y = 20`. Next, we create an empty table called `mt`, which will serve as the metatable.

We define a metamethod `__add` within the `mt` table. This metamethod defines the behavior of the addition operation (`+`) when applied to tables. In our case, the metamethod adds the corresponding `x` and `y` values from the two tables and returns a new table with the result.

To associate the metatable with `myTable`, we use the `setmetatable` function, passing `myTable` as the first argument and `mt` as the second argument.

Next, we create another table called `anotherTable` with the same structure as `myTable`. To perform the addition operation between `myTable` and `anotherTable`, we simply use the `+` operator. However, behind the scenes, Lua detects that `myTable` has a metatable, and the `__add` metamethod defined in the metatable is invoked.

Finally, we print the values of the `sumTable`, which is the result of the addition operation between `myTable` and `anotherTable`. In this case, the output will be `15 35`, as the metamethod `__add` performed the addition of corresponding `x` and `y` values from both tables.

This example demonstrates how metatables in Lua allow us to customize and extend the behavior of tables, enabling us to create object-oriented programming constructs. By defining metamethods within a metatable, we can control how tables respond to specific operations, thereby implementing OOP concepts such as operator overloading, inheritance, and more.