{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b15a33d5-9d7e-42b9-b94d-e6ec5a9ea0ef",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Python sebagai Pemrograman Berorientasi Objek (Bagian 1)\n",
    "Dalam bagian ini, kita akan memperkenalkan konsep dasar dari pemrograman berorientasi objek (OOP) dan mengapa OOP menjadi pendekatan yang kuat dalam pengembangan perangkat lunak. Banyak bahasa pemrograman yang menerapkan paradigma Pemrograman Berorientasi Objek (OOP). Beberapa di antaranya termasuk:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea853468-3207-4f3d-b5e7-6958dc2c0451",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "1. **Python**: mendukung OOP dengan sintaks yang mudah dipahami dan fleksibel untuk membuat kelas, objek, dan menerapkan konsep-konsep OOP.\n",
    "2. **Java**:Kode Java ditulis dalam bentuk kelas dan objek, dan bahasa ini mendukung konsep-konsep seperti pewarisan, enkapsulasi, dan polimorfisme.\n",
    "3. **C++**: pengembangan dari C dengan tambahan fitur-fitur OOP. Bahasa ini mendukung konsep OOP seperti pewarisan, enkapsulasi, dan polimorfisme.\n",
    "4. **C#**: dikembangkan oleh Microsoft dan sangat terintegrasi dengan platform .NET. C# juga mendukungOOP seperti pewarisan, enkapsulasi, dan polimorfisme.\n",
    "5. **Ruby**: Ruby adalah bahasa dinamis yang sepenuhnya mendukung OOP. Bahasa ini sangat fleksibel dalam hal pemrograman berorientasi objek.\n",
    "6. **PHP**: Meskipun pertama kali dirancang sebagai bahasa skrip untuk pengembangan web, PHP juga memiliki fitur-fitur OOP yang cukup kuat.\n",
    "7. **Swift**: Swift adalah bahasa yang dikembangkan oleh Apple untuk pengembangan aplikasi iOS dan macOS. Bahasa ini mendukung konsep-konsep OOP modern.\n",
    "8. **Kotlin**: bahasa yang secara eksplisit dirancang untuk berjalan di atas Java Virtual Machine (JVM). Ia juga mendukung OOP dan banyak fitur modern lainnya."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c67885b-5611-40b8-a0ec-9e638c3307e3",
   "metadata": {
    "editable": true,
    "jp-MarkdownHeadingCollapsed": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## 1 Definisi Pemrograman Berorientasi Objek (OOP)\n",
    "Pemrograman Berorientasi Objek (OOP) adalah paradigma pemrograman yang memodelkan dunia nyata dalam bentuk objek-objek yang memiliki atribut (data) dan perilaku (metode). Dalam OOP, program direncanakan dan dibangun dengan cara yang mirip dengan cara kita memandang dunia nyata. Objek adalah inti dari OOP, yang memungkinkan kita merepresentasikan dan mengorganisir komponen-komponen dalam program."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cf263b3-016a-4c45-a65b-c4102d3f1d90",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## 2 Tujuan dan Keunggulan OOP dalam Pengembangan Perangkat Lunak\n",
    "Tujuan utama  OOP adalah mengatur kode menjadi lebih terstruktur, modular, dan mudah dikelola. Beberapa keunggulan OOP dalam pemecahan masalah  antara lain:\n",
    "1. Modularitas: Program dibagi menjadi objek-objek yang independen, membuat kode lebih mudah dikelola dan dimodifikasi.\n",
    "2. Reusabilitas: Objek yang telah dibuat dapat digunakan kembali dalam berbagai proyek, menghemat waktu dan usaha.\n",
    "3. Abstraksi: Objek memungkinkan kita untuk fokus pada informasi yang relevan dan menyembunyikan kompleksitas di belakang antarmuka yang sederhana.\n",
    "4. Pewarisan: Pewarisan memungkinkan pengembangan kelas baru berdasarkan kelas yang sudah ada, mengurangi redundansi dan meningkatkan efisiensi."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7290688a-6810-4973-a5f8-64cbca586996",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## 3. Prinsip Dasar Kelas (Class)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4de52a31-5603-4785-a857-47d3ab70e7ad",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### 3.1 Konsep Kelas sebagai Blueprint untuk Objek\n",
    "Kelas dalam pemrograman berorientasi objek berperan sebagai blueprint atau cetak biru yang mendefinisikan struktur dan perilaku yang akan dimiliki oleh objek yang akan dihasilkan dari kelas tersebut. Kelas menyediakan kerangka kerja untuk menciptakan objek yang memiliki atribut (data) dan metode (fungsi) yang terkait."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d86ff824-0a08-45bd-9ee5-2d4075cc5d5c",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### 3.2 Pembuatan dan Definisi Kelas dalam Python\n",
    "Dalam Python, pembuatan kelas melibatkan penggunaan kata kunci class, diikuti oleh nama kelas dan blok kode yang mendefinisikan atribut dan metode kelas. Berikut adalah contoh pembuatan dan definisi kelas dalam Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70e73fe2-2768-454b-8a8b-87cd0577de31",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    \n",
    "    def greet(self):\n",
    "        print(f\"Hello, my name is {self.name} and I am {self.age} years old.\")\n",
    "\n",
    "# Membuat objek dari kelas Person\n",
    "person1 = Person(\"Alice\", 25)\n",
    "person2 = Person(\"Bob\", 30)\n",
    "\n",
    "# Memanggil metode pada objek\n",
    "person1.greet()\n",
    "person2.greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "766ac92d-42c9-484f-95a6-9f8481c7d3d5",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Dalam contoh di atas, kami membuat kelas Person yang memiliki atribut name dan age, serta metode greet() untuk memberi salam. Objek person1 dan person2 diciptakan dari kelas Person dengan atribut yang berbeda, dan metode greet() dipanggil pada masing-masing objek."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10aa33e6-4a01-4df6-9885-86e249ed34f9",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## 4. Kelas dengan Properties dan Method\n",
    "Dalam bagian ini, kita akan mempelajari tentang properties (sifat-sifat) dan method dalam kelas, serta bagaimana mengimplementasikan keduanya dalam pemrograman berorientasi objek dengan menggunakan bahasa pemrograman Python. Properties (sifat-sifat) adalah variabel yang terkait dengan objek dan mendefinisikan atribut-atribut yang dimilikinya. Method (metode) adalah fungsi yang terkait dengan objek dan mendefinisikan perilaku atau tindakan yang dapat dilakukan oleh objek tersebut.\n",
    "* Properties adalah variabel yang terkait dengan objek dalam pemrograman berorientasi objek.\n",
    "* Method adalah fungsi yang terkait dengan objek dalam pemrograman berorientasi objek."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb04232d-ef5c-46e3-8e11-40881d4ea50e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name  # Ini adalah property \"name\"\n",
    "        self.age = age    # Ini adalah property \"age\"\n",
    "        self.grades = []  # Ini adalah property \"grades\"\n",
    "    \n",
    "    def add_grade(self, grade):\n",
    "        self.grades.append(grade)  # Ini adalah method \"add_grade\"\n",
    "    \n",
    "    def get_average_grade(self):\n",
    "        if len(self.grades) > 0:\n",
    "            return sum(self.grades) / len(self.grades)  # Ini adalah method \"get_average_grade\"\n",
    "        else:\n",
    "            return \"No grades available.\"  # Ini adalah method \"get_average_grade\"\n",
    "\n",
    "# Membuat objek dari kelas Student\n",
    "student1 = Student(\"Alice\", 20)\n",
    "student2 = Student(\"Bob\", 22)\n",
    "\n",
    "# Menggunakan method untuk menambahkan nilai dan mendapatkan rata-rata nilai\n",
    "student1.add_grade(85)\n",
    "student1.add_grade(90)\n",
    "student2.add_grade(78)\n",
    "student2.add_grade(88)\n",
    "\n",
    "print(f\"Average grade of {student1.name}: {student1.get_average_grade()}\")\n",
    "print(f\"Average grade of {student2.name}: {student2.get_average_grade()\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31b5a23c-a234-4944-a090-9ae5c505ba4b",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Dalam contoh di atas, kelas Student memiliki properties name, age, dan grades (yang berfungsi sebagai daftar nilai mahasiswa). Metode add_grade() digunakan untuk menambahkan nilai ke dalam daftar grades, sedangkan metode get_average_grade() menghitung rata-rata nilai mahasiswa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c685e983-f0ee-4849-aedf-5c08870a59c3",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "class SimpleGUI:\n",
    "    def __init__(self, root):\n",
    "        self.root = root\n",
    "        self.root.title(\"Simple GUI\")\n",
    "        \n",
    "        self.label = tk.Label(root, text=\"Hello, Tkinter!\")\n",
    "        self.label.pack()\n",
    "        \n",
    "        self.button = tk.Button(root, text=\"Click Me\", command=self.change_text)\n",
    "        self.button.pack()\n",
    "    \n",
    "    def change_text(self):\n",
    "        self.label.config(text=\"Button Clicked!\")\n",
    "\n",
    "# Membuat instance dari kelas Tk (root window)\n",
    "root = tk.Tk()\n",
    "\n",
    "# Membuat objek SimpleGUI\n",
    "gui = SimpleGUI(root)\n",
    "\n",
    "# Memulai loop utama GUI\n",
    "root.mainloop()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4aba4d6c-cd15-4106-882a-ce95eeae1328",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## 5. Kelas dengan Properties dan Method\n",
    "Dalam bagian ini, kita akan membahas cara membuat objek dari kelas menggunakan constructor, mengakses properties yang dimiliki objek, dan menggunakan method yang terkait dengan objek tersebut. Ketika kita ingin membuat objek dari suatu kelas, kita menggunakan konstruktor. Konstruktor adalah metode khusus dalam kelas yang digunakan untuk menginisialisasi objek dengan nilai awal (properties) yang diberikan. Setelah objek tercipta, kita dapat mengakses properties yang dimilikinya. Properties ini adalah atribut yang didefinisikan dalam kelas. Selain itu, objek juga dapat menggunakan method yang ada dalam kelas untuk melakukan tindakan tertentu.\n",
    "* **Kelas**: blueprint atau template yang mendefinisikan struktur, atribut, dan metode yang akan dimiliki oleh objek yang akan dibuat berdasarkan kelas tersebut.\n",
    "* **Objek**: Objek adalah instance yang dibuat berdasarkan blueprint kelas, memiliki atribut dan perilaku yang didefinisikan dalam kelas.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "089182ae-bb81-428a-b4c5-041fc57ba561",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, brand, model):\n",
    "        self.brand = brand\n",
    "        self.model = model\n",
    "        self.speed = 0\n",
    "    \n",
    "    def accelerate(self, amount):\n",
    "        self.speed += amount\n",
    "    \n",
    "    def brake(self, amount):\n",
    "        if self.speed >= amount:\n",
    "            self.speed -= amount\n",
    "        else:\n",
    "            self.speed = 0\n",
    "    \n",
    "    def display_speed(self):\n",
    "        print(f\"The {self.brand} {self.model}'s speed is {self.speed} km/h.\")\n",
    "\n",
    "# Membuat objek dari kelas Car\n",
    "car1 = Car(\"Toyota\", \"Camry\")\n",
    "car2 = Car(\"Honda\", \"Civic\")\n",
    "\n",
    "# Menggunakan method untuk mengubah kecepatan dan menampilkan kecepatan\n",
    "car1.accelerate(30)\n",
    "car1.display_speed()\n",
    "\n",
    "car2.accelerate(20)\n",
    "car2.display_speed()\n",
    "\n",
    "car1.brake(10)\n",
    "car1.display_speed()\n",
    "\n",
    "car2.brake(15)\n",
    "car2.display_speed()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5695fbfa-8ee8-4785-be12-52877cda7bda",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "class Download:\n",
    "    def __init__(self, url):\n",
    "        self.url = url\n",
    "    \n",
    "    def download_file(self, save_as):\n",
    "        try:\n",
    "            response = requests.get(self.url)\n",
    "            if response.status_code == 200:\n",
    "                with open(save_as, 'wb') as file:\n",
    "                    file.write(response.content)\n",
    "                print(f\"File downloaded and saved as {save_as}\")\n",
    "            else:\n",
    "                print(\"Failed to download file.\")\n",
    "        except Exception as e:\n",
    "            print(\"An error occurred:\", e)\n",
    "\n",
    "# Meminta input URL dan nama berkas\n",
    "url = input(\"Enter the URL of the file: \")\n",
    "filename = input(\"Enter the filename to save as: \")\n",
    "\n",
    "# Membuat objek Download dan mengunduh berkas\n",
    "downloader = Download(url)\n",
    "downloader.download_file(filename)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dabd493e-003e-40e8-905d-c16810ea18e2",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## 6. Pewarisan (Inheritance) dalam OOP\n",
    "Dalam bagian ini, kami akan menjelaskan tentang konsep pewarisan dalam pemrograman berorientasi objek (OOP), serta bagaimana kita dapat menggunakan pewarisan untuk membangun kelas turunan (subclass). Pewarisan adalah mekanisme di mana sebuah kelas baru (kelas turunan atau subclass) dapat mewarisi atribut dan metode dari kelas yang sudah ada (kelas induk atau superclass). Konsep ini memungkinkan untuk membentuk hierarki kelas yang menggambarkan hubungan \"adalah bagian dari\". Berikut adalah contoh penggunaan pewarisan untuk membangun kelas turunan:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e81a75fa-ec0d-458f-a3cc-dd77b2ed9952",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    \n",
    "    def speak(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "# Membuat objek dari kelas turunan\n",
    "dog = Dog(\"Buddy\")\n",
    "print(dog.name + \" says:\", dog.speak())\n",
    "\n",
    "cat = Cat(\"Whiskers\")\n",
    "print(cat.name + \" says:\", cat.speak())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "413d3311-1cfd-49f3-8f79-dbb44a733436",
   "metadata": {},
   "source": [
    "Dalam contoh ini, kelas Animal adalah kelas induk dengan atribut name dan metode speak(). Kelas Dog dan Cat adalah kelas turunan yang mewarisi dari Animal. Masing-masing kelas turunan mengimplementasikan ulang metode speak(), sehingga menggambarkan karakteristik suara yang berbeda. Berikut adalah contoh penggunaan pewarisan dalam sebuah aplikasi sederhana dengan modul turtle yang menggambarkan konsep hewan berdasarkan pewarisan:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cef5c29d-b6fc-4739-8d88-b85563dd9d22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ________\n",
      "|        |\n",
      "|  Rectangle  |\n",
      "|________|\n",
      "\n",
      "   /\\   \n",
      "  /  \\  \n",
      " /____\\ \n",
      "Triangle\n",
      "\n",
      "  _____\n",
      " /     \\\n",
      "|   Circle  |\n",
      " \\_____/\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Shape:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    \n",
    "    def draw(self):\n",
    "        pass\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    def draw(self):\n",
    "        return f\" ________\\n|        |\\n|  {self.name}  |\\n|________|\"\n",
    "\n",
    "class Triangle(Shape):\n",
    "    def draw(self):\n",
    "        return f\"   /\\\\   \\n  /  \\\\  \\n /____\\\\ \\n{self.name}\"\n",
    "\n",
    "class Circle(Shape):\n",
    "    def draw(self):\n",
    "        return f\"  _____\\n /     \\\\\\n|   {self.name}  |\\n \\\\_____/\"\n",
    "        \n",
    "# Membuat objek dari kelas turunan dan menggambar bentuk\n",
    "rectangle = Rectangle(\"Rectangle\")\n",
    "triangle = Triangle(\"Triangle\")\n",
    "circle = Circle(\"Circle\")\n",
    "\n",
    "shapes = [rectangle, triangle, circle]\n",
    "\n",
    "for shape in shapes:\n",
    "    print(shape.draw())\n",
    "    print()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4a00dc2-fbf4-4b40-99cc-e4153e2a5da0",
   "metadata": {},
   "source": [
    "## 7. Method Khusus dalam OOP\n",
    "Dalam bagian ini, kita akan membahas penggunaan method khusus dalam pemrograman berorientasi objek (OOP), khususnya method __init__ dan __str__. Method __init__ adalah method khusus yang digunakan untuk menginisialisasi objek saat pertama kali dibuat dari kelas. Method ini dapat digunakan untuk mengatur nilai awal dari properties objek. Method __str__ adalah method khusus yang digunakan untuk mengembalikan representasi string yang mendeskripsikan objek. Method ini berguna untuk memberikan informasi yang lebih deskriptif ketika objek dicetak atau digunakan dalam konteks string. Berikut adalah contoh penggunaan method khusus __init__ dan __str__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1976b28-4f48-4c5c-ae14-09c23136e974",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"Student: {self.name}, Age: {self.age}\"\n",
    "\n",
    "# Membuat objek dari kelas Student\n",
    "student1 = Student(\"Alice\", 20)\n",
    "student2 = Student(\"Bob\", 22)\n",
    "\n",
    "# Mencetak objek menggunakan method __str__\n",
    "print(student1)\n",
    "print(student2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad729819-df3d-45fe-9ce9-7db194545d31",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author, year):\n",
    "        self.title = title\n",
    "        self.author = author\n",
    "        self.year = year\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"Title: {self.title}, Author: {self.author}, Year: {self.year}\"\n",
    "\n",
    "# Membuat objek dari kelas Book\n",
    "book1 = Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", 1925)\n",
    "book2 = Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960)\n",
    "\n",
    "# Mencetak objek menggunakan method __str__\n",
    "print(book1)\n",
    "print(book2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}