Lua Academy · Pelajaran

Memanggil Metode Induk dengan super

Panggil metode class dasar secara eksplisit untuk inisialisasi kooperatif.

Memanggil Metode Induk dengan super adalah pelajaran Lua Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Lua Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Lua Academy mencakup 4 pelajaran total.

Mengapa Pemanggilan Super?

Saat anak menimpa metode induk tetapi masih memerlukan logika milik induk, anak tersebut memanggil metode induk secara eksplisit. Lua tidak memiliki kata kunci super — Anda merujuk tabel induk secara langsung: Parent.method(self, args).

local Base={}
Base.__index=Base
function Base:describe()
  return "Base[name="..self.name.."]"
end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})

function Child:describe()
  local parentDesc = Base.describe(self)  -- super call
  return parentDesc .. " + Child[extra=true]"
end

local c=setmetatable({name="X"},Child)
print(c:describe())

Super dalam Konstruktor

Konstruktor anak memanggil konstruktor induk melalui Parent.new() atau Parent._init(self,...). Ini memastikan inisialisasi induk dijalankan untuk setiap instans anak.

local Animal={}
Animal.__index=Animal
function Animal._init(self,name,sound)
  self.name=name; self.sound=sound; self.alive=true
end

local Dog={}
Dog.__index=Dog; setmetatable(Dog,{__index=Animal})
function Dog.new(name,breed)
  local self=setmetatable({},Dog)
  Animal._init(self,name,"Woof")  -- super init
  self.breed=breed
  return self
end

local d=Dog.new("Rex","Lab")
print(d.name,d.sound,d.breed)

Inisialisasi Kooperatif

Dalam hierarki yang dalam, setiap tingkat hanya menginisialisasi bidangnya sendiri dan memanggil init milik induk. Dengan demikian, setiap kelas hanya bertanggung jawab atas bidangnya sendiri.

local A={}
function A._init(self,x) self.x=x end

local B={}
function B._init(self,x,y) A._init(self,x); self.y=y end

local C={}
C.__index=C
function C.new(x,y,z)
  local self=setmetatable({},C)
  B._init(self,x,y)
  self.z=z
  return self
end

local c=C.new(1,2,3)
print(c.x,c.y,c.z)  -- 1 2 3

Pembungkus super

Buat pembantu super(self) yang mengembalikan objek proksi untuk memanggil metode induk dengan self. Ini memberikan sintaks yang lebih rapi daripada Parent.method(self, ...).

local function super(self)
  local mt = getmetatable(getmetatable(self).__index)
  if mt then
    return setmetatable({}, {__index=function(_,k)
      local parentCls = mt.__index or mt
      return function(...) return parentCls[k](self,...) end
    end})
  end
end
print("super() helper pattern shown")

Beberapa Tingkat

Saat terdapat beberapa tingkat pewarisan, setiap tingkat memanggil induk langsungnya. Rantai tersebut diteruskan secara otomatis.

local L1={} L1.__index=L1
function L1:intro() return "L1" end

local L2={} L2.__index=L2
setmetatable(L2,{__index=L1})
function L2:intro() return L1.intro(self).."+L2" end

local L3={} L3.__index=L3
setmetatable(L3,{__index=L2})
function L3:intro() return L2.intro(self).."+L3" end

local obj=setmetatable({},L3)
print(obj:intro())  -- L1+L2+L3

Penambahan Perilaku Metode

Tambahkan perilaku pada metode induk: panggil versi induk, lalu tambahkan perilaku ekstra. Ini adalah nasihat "sebelum" atau "sesudah" tanpa kerangka kerja AOP formal.

local Logger={} Logger.__index=Logger
function Logger:log(msg) print("[LOG] "..msg) end

local TimedLogger={} TimedLogger.__index=TimedLogger
setmetatable(TimedLogger,{__index=Logger})

function TimedLogger:log(msg)
  local ts=os.date("%H:%M:%S")
  Logger.log(self,"["..ts.."] "..msg)  -- augment
end

local tl=setmetatable({},TimedLogger)
tl:log("Server started")

Menghindari Jebakan Super

Selalu gunakan nama kelas induk yang tepat, bukan getmetatable(self).__index, untuk pemanggilan super — pencarian metatabel dapat mengembalikan kelas perantara, bukan induk sebenarnya. Nyatakan secara eksplisit demi kejelasan dan ketepatan.

-- Correct: explicit parent reference
function Child:init(x)
  Base.init(self, x)  -- explicit, clear
end

-- Fragile: uses metatable lookup
function Child:initBad(x)
  local parent = getmetatable(getmetatable(self).__index)
  -- This may not be Base if hierarchy changes!
end
print("Be explicit with parent class references")

Super untuk __tostring

Timpa __tostring pada anak sambil menyertakan representasi induk agar deskripsinya lengkap.

local Base={}
Base.__index=Base
Base.__tostring=function(self) return "Base("..self.name..")" end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})
Child.__tostring=function(self)
  local baseStr = Base.__tostring(self)
  return baseStr.." + Child(level="..self.level..")"
end

local c=setmetatable({name="X",level=5},Child)
print(tostring(c))  -- Base(X) + Child(level=5)

Metode Templat Terlindungi

Pola metode templat: kelas dasar mendefinisikan kerangka algoritme dengan pemanggilan ke langkah-langkah abstrak; subkelas mengimplementasikan langkah-langkah tersebut.

local Processor={} Processor.__index=Processor
function Processor:run(data)
  data = self:preProcess(data)
  data = self:process(data)
  return self:postProcess(data)
end
function Processor:preProcess(d) return d end
function Processor:postProcess(d) return d end
function Processor:process(d) error("implement process()") end

local Upper={} Upper.__index=Upper
setmetatable(Upper,{__index=Processor})
function Upper:process(d) return d:upper() end

local p=setmetatable({},Upper)
print(p:run("hello"))  -- HELLO

Konvensi Pemanggilan Super

Konvensi: awali fungsi init yang hanya digunakan secara internal dengan _ (misalnya _init) dan tampilkan new() publik hanya pada konstruktor tingkat teratas. Ini menjaga rantai pewarisan tetap rapi.

-- Convention summary:
-- Animal._init(self, ...)  -- used for super calls
-- Dog.new(...)             -- only public constructor
-- Never call Dog._init from outside

local Foo={} Foo.__index=Foo
function Foo._init(self,x) self.x=x end
function Foo.new(x)
  return setmetatable({},Foo):_init(x) or
    (function() local s=setmetatable({},Foo); Foo._init(s,x); return s end)()
end
print("Convention: _init for super, new() for public")

Pertanyaan tentang Pemanggilan Super

Bagaimana cara memanggil metode induk dalam Lua?

Ringkasan: Pemanggilan Super

Selalu panggil metode induk melalui referensi kelas yang eksplisit: Parent.method(self, ...). Gunakan konvensi _init untuk konstruktor kooperatif di berbagai tingkat pewarisan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Memanggil Metode Induk dengan super” gratis?

Ya — teks lengkap “Memanggil Metode Induk dengan super” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Lua Academy, upgrade ke CoddyKit PRO. Kursus Lua Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Memanggil Metode Induk dengan super”?

Panggil metode class dasar secara eksplisit untuk inisialisasi kooperatif. Kamu berlatih Lua Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Lua Academy?

Tidak diperlukan pengalaman sebelumnya. Lua Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Memanggil Metode Induk dengan super” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Lua Academy ini?

Ya. Setiap pelajaran Lua Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Pewarisan Tunggal dengan Chaining __index
Memanggil Metode Induk dengan super
Pola Mixin
Penggantian Metode dan Polimorfisme

← Kembali ke Lua Academy