Kelas adalah pilar Pemrograman Berorientasi Objek . OOP sangat memperhatikan organisasi kode, usabilitas ulang, dan enkapsulasi.
Pertama, penafian: OOP sebagian berbeda dengan Pemrograman Fungsional , yang merupakan paradigma yang berbeda banyak digunakan dalam Python. Tidak semua orang yang memprogram dalam Python (atau tentunya sebagian besar bahasa) menggunakan OOP. Anda dapat melakukan banyak hal di Java 8 yang tidak terlalu berorientasi objek. Jika Anda tidak ingin menggunakan OOP, maka jangan. Jika Anda hanya menulis skrip satu kali untuk memproses data yang tidak akan pernah Anda gunakan lagi, maka teruslah menulis seperti Anda.
Namun, ada banyak alasan untuk menggunakan OOP.
Beberapa alasan:
Organisasi: OOP mendefinisikan cara-cara yang dikenal dan standar untuk menggambarkan dan mendefinisikan data dan prosedur dalam kode. Baik data dan prosedur dapat disimpan pada berbagai tingkat definisi (di kelas yang berbeda), dan ada cara standar untuk membicarakan definisi ini. Yaitu, jika Anda menggunakan OOP dengan cara standar, itu akan membantu Anda nantinya dan orang lain memahami, mengedit, dan menggunakan kode Anda. Selain itu, alih-alih menggunakan mekanisme penyimpanan data yang rumit dan sewenang-wenang (dikte dicts atau daftar atau dicts atau daftar dicts set, atau apa pun), Anda dapat memberi nama potongan-potongan struktur data dan dengan mudah merujuknya.
Negara: OOP membantu Anda menentukan dan melacak keadaan. Misalnya, dalam contoh klasik, jika Anda membuat program yang memproses siswa (misalnya, program kelas), Anda dapat menyimpan semua informasi yang Anda butuhkan tentang mereka di satu tempat (nama, usia, jenis kelamin, tingkat kelas, kursus, nilai, guru, teman sebaya, diet, kebutuhan khusus, dll.), dan data ini bertahan selama objek masih hidup, dan mudah diakses.
Enkapsulasi : Dengan enkapsulasi, prosedur dan data disimpan bersama. Metode (istilah OOP untuk fungsi) didefinisikan tepat di samping data yang mereka operasikan dan hasilkan. Dalam bahasa seperti Java yang memungkinkan kontrol akses , atau dalam Python, tergantung pada bagaimana Anda menggambarkan API publik Anda, ini berarti bahwa metode dan data dapat disembunyikan dari pengguna. Apa artinya ini adalah bahwa jika Anda perlu atau ingin mengubah kode, Anda dapat melakukan apa pun yang Anda inginkan untuk implementasi kode, tetapi tetap menggunakan API publik.
Warisan : Warisan memungkinkan Anda untuk menentukan data dan prosedur di satu tempat (dalam satu kelas), lalu menimpa atau memperluas fungsionalitas itu nanti. Misalnya, dengan Python, saya sering melihat orang membuat subclass dictkelas untuk menambah fungsionalitas tambahan. Perubahan yang umum adalah mengganti metode yang melempar pengecualian ketika kunci diminta dari kamus yang tidak ada untuk memberikan nilai default berdasarkan kunci yang tidak dikenal. Ini memungkinkan Anda untuk memperluas kode Anda sendiri sekarang atau nanti, memungkinkan orang lain untuk memperluas kode Anda, dan memungkinkan Anda untuk memperluas kode orang lain.
Dapat digunakan kembali: Semua alasan ini dan lainnya memungkinkan penggunaan kembali kode yang lebih besar. Kode berorientasi objek memungkinkan Anda untuk menulis kode yang solid (diuji) sekali, dan kemudian menggunakan kembali berulang-ulang. Jika Anda perlu mengubah sesuatu untuk kasus penggunaan khusus Anda, Anda bisa mewarisi dari kelas yang ada dan menimpa perilaku yang ada. Jika Anda perlu mengubah sesuatu, Anda dapat mengubah semuanya sambil mempertahankan tanda tangan metode publik yang ada, dan tidak ada yang lebih bijak (mudah-mudahan).
Sekali lagi, ada beberapa alasan untuk tidak menggunakan OOP, dan Anda tidak perlu melakukannya. Tapi untungnya dengan bahasa seperti Python, Anda bisa menggunakan sedikit atau banyak, terserah Anda.
Contoh kasus penggunaan siswa (tidak ada jaminan kualitas kode, hanya sebuah contoh):
Berorientasi pada objek
class Student(object):
def __init__(self, name, age, gender, level, grades=None):
self.name = name
self.age = age
self.gender = gender
self.level = level
self.grades = grades or {}
def setGrade(self, course, grade):
self.grades[course] = grade
def getGrade(self, course):
return self.grades[course]
def getGPA(self):
return sum(self.grades.values())/len(self.grades)
# Define some students
john = Student("John", 12, "male", 6, {"math":3.3})
jane = Student("Jane", 12, "female", 6, {"math":3.5})
# Now we can get to the grades easily
print(john.getGPA())
print(jane.getGPA())
Dikte Standar
def calculateGPA(gradeDict):
return sum(gradeDict.values())/len(gradeDict)
students = {}
# We can set the keys to variables so we might minimize typos
name, age, gender, level, grades = "name", "age", "gender", "level", "grades"
john, jane = "john", "jane"
math = "math"
students[john] = {}
students[john][age] = 12
students[john][gender] = "male"
students[john][level] = 6
students[john][grades] = {math:3.3}
students[jane] = {}
students[jane][age] = 12
students[jane][gender] = "female"
students[jane][level] = 6
students[jane][grades] = {math:3.5}
# At this point, we need to remember who the students are and where the grades are stored. Not a huge deal, but avoided by OOP.
print(calculateGPA(students[john][grades]))
print(calculateGPA(students[jane][grades]))