Object oriented Programming with Java
1.0.0
Selamat datang di Object -Oriented Programming Storage dengan Java ! Ini menyediakan sumber daya yang komprehensif untuk mengeksplorasi dan mempelajari pemrograman berorientasi objek melalui bahasa Java.
Pemrograman berorientasi objek (OOP - OOP - OOP -Oriented Programming) adalah model pemrograman populer yang banyak digunakan dalam pengembangan perangkat lunak. Ini didasarkan pada konsep "objek", yang merupakan entitas yang menggabungkan data (atribut) dan metode (perilaku). OOP berfokus pada desain perangkat lunak berdasarkan objek interaktif, alih -alih proses dan logika seperti dalam pemrograman pemrograman prosedural.
Pemrograman yang berorientasi objek didasarkan pada 4 prinsip dasar, yaitu: pengemasan, warisan, polimorfisme, dan abstrak. Masing -masing prinsip ini memberikan pendekatan untuk memecahkan masalah dalam pengembangan perangkat lunak dan membantu mengelola kode sumber secara lebih efektif.
1. Encapsulation : Ini adalah konsep menyembunyikan detail penyebaran internal objek, mencegah pengguna mengakses data secara langsung di dalamnya. Pengemasan membantu melindungi data dan perilaku objek dari intervensi yang tidak diinginkan dan menyediakan antarmuka terpadu untuk berinteraksi dengan objek.
// Lớp Employee (Nhân viên) chứa các thuộc tính: tên, tuổi, lương
public class Employee {
// Các biến dữ liệu riêng tư để ngăn chặn truy cập trực tiếp từ bên ngoài lớp
private String name ;
private int age ;
private double salary ;
// Constructor (hàm tạo) để khởi tạo các giá trị của đối tượng
public Employee ( String name , int age , double salary ) {
this . name = name ;
this . age = age ;
this . salary = salary ;
}
// Các phương thức getter để truy cập các biến dữ liệu
public String getName () {
return name ;
}
public int getAge () {
return age ;
}
public double getSalary () {
return salary ;
}
// Các phương thức setter để cập nhật giá trị của các biến dữ liệu
public void setName ( String name ) {
this . name = name ;
}
public void setAge ( int age ) {
this . age = age ;
}
public void setSalary ( double salary ) {
this . salary = salary ;
}
}
// Lớp Main để thực thi mã
public class Main {
public static void main ( String [] args ) {
// Tạo đối tượng của lớp Employee
Employee emp = new Employee ( "John Doe" , 30 , 50000 );
// Truy cập và cập nhật thông qua các phương thức getter và setter
System . out . println ( "Employee name: " + emp . getName ());
emp . setSalary ( 55000 );
System . out . println ( "Updated salary: " + emp . getSalary ());
}
} Dalam contoh ini, name variabel, age , dan salary ditandai sebagai private , yang berarti mereka tidak dapat diakses secara langsung dari luar Employee . Sebaliknya, getName() , getAge() , getSalary() , setName() , setAge() , dan setSalary() disediakan untuk mengakses dan memperbarui nilai variabel ini, memastikan kemasan.
2. Warisan (warisan): Warisan memungkinkan lapisan baru untuk mewarisi sifat dan metode dari lapisan yang ada. Lapisan baru ini dapat menambah atau memodifikasi komponen warisan untuk memenuhi kebutuhannya sendiri, membantu menggunakan kembali dan memperluas kode sumber secara efektif.
// Lớp cơ sở (hay lớp cha): Employee
public class Employee {
private String name ;
private int age ;
// Constructor của lớp Employee
public Employee ( String name , int age ) {
this . name = name ;
this . age = age ;
}
// Getter và Setter
public String getName () {
return name ;
}
public void setName ( String name ) {
this . name = name ;
}
public int getAge () {
return age ;
}
public void setAge ( int age ) {
this . age = age ;
}
// Phương thức để hiển thị thông tin
public void displayInfo () {
System . out . println ( "Name: " + name + ", Age: " + age );
}
}
// Lớp dẫn xuất (hay lớp con): Manager kế thừa từ Employee
public class Manager extends Employee {
private double salary ;
// Constructor của lớp Manager
public Manager ( String name , int age , double salary ) {
super ( name , age ); // Gọi constructor của lớp cơ sở (lớp cha)
this . salary = salary ;
}
// Phương thức mới của lớp Manager
@ Override
public void displayInfo () {
// Gọi phương thức displayInfo của lớp cơ sở (lớp cha)
super . displayInfo ();
System . out . println ( "Salary: " + salary );
}
}
public class Main {
public static void main ( String [] args ) {
// Tạo đối tượng Manager
Manager manager = new Manager ( "Alice Johnson" , 42 , 75000 );
manager . displayInfo (); // Hiển thị thông tin của Manager
}
}Employee adalah kelas dasar, yang berisi informasi dasar seperti nama dan usia.Manager adalah kelas turunan dari Employee dan menambahkan atribut salary .Manager menggunakan kata kunci extends untuk mewarisi dari kelas Employee . Konstruktor Manager disebut super(name, age) ; Untuk menginisialisasi properti yang diwarisi dari kelas Employee .displayInfo() ditimpa di kelas Manager untuk menambahkan lebih banyak informasi tentang gaji, dan hubungi metode displayInfo() dari kelas dasar untuk menampilkan informasi dasar.3. Polimorfisme : Polimorfisme adalah kemampuan di mana kelas yang berbeda dapat digunakan melalui antarmuka yang sama. Metode ini dapat didefinisikan dalam lapisan dasar dan digantikan dengan metode dengan nama yang sama di kelas turunan, yang memungkinkan objek diproses melalui antarmuka umum tanpa mengetahui tipe data spesifik mereka.
Dalam Java, polimorfisme diekspresikan melalui metode overhod yang menutupi dan mengisi ulang metode (metode kelebihan beban).
class Animal {
void speak () {
System . out . println ( "Animal speaks" );
}
}
// Lớp Dog (chó) kế thừa lớp Animal (động vật)
class Dog extends Animal {
// Lớp Dog ghi đè phương thức speak() của lớp cha
@ Override
void speak () {
System . out . println ( "Dog barks" );
}
}
// Lớp Cat (mèo) kế thừa lớp Animal (động vật)
class Cat extends Animal {
// Lớp Dog ghi đè phương thức speak() của lớp cha
@ Override
void speak () {
System . out . println ( "Cat meows" );
}
}
public class Main {
public static void main ( String [] args ) {
Animal myAnimal = new Animal ();
Animal myDog = new Dog ();
Animal myCat = new Cat ();
myAnimal . speak (); // Prints "Animal speaks"
myDog . speak (); // Prints "Dog barks"
myCat . speak (); // Prints "Cat meows"
}
} Dalam contoh ini, metode speak() ditimpa pada lapisan Dog dan Cat . Saat memanggil metode speak() pada objek anak, Java menentukan metode mana yang akan dipanggil pada saat berjalan, tergantung pada jenis objek yang dilengkapi variabel referensi.
class Printer {
// In chuỗi
void print ( String data ) {
System . out . println ( "String: " + data );
}
// In số nguyên
void print ( int data ) {
System . out . println ( "Integer: " + data );
}
// In số thực
void print ( double data ) {
System . out . println ( "Double: " + data );
}
}
public class Main {
public static void main ( String [] args ) {
Printer printer = new Printer ();
// Gọi phương thức print nạp chồng
printer . print ( "Hello, World!" );
printer . print ( 123 );
printer . print ( 98.76 );
}
}Printer memiliki tiga versi metode print , masing -masing memproses tipe data tertentu: String , int , dan double .print , Java akan menentukan versi yang sesuai berdasarkan jenis data dari argumen transmisi.Polimorfisme juga diekspresikan dengan jelas melalui mekanisme penggunaan antarmuka. Antarmuka di Java adalah cara untuk mencapai polimorfisme yang lebih tinggi, memungkinkan lapisan untuk menggunakan banyak antarmuka dan antarmuka yang dapat digunakan oleh lapisan yang berbeda.
Misalkan kita memiliki CanFly antarmuka dan dua lapisan Bird dan Airplane keduanya menerapkan antarmuka ini:
interface CanFly {
void fly ();
}
class Bird implements CanFly {
public void fly () {
System . out . println ( "The bird flaps its wings to fly." );
}
}
class Airplane implements CanFly {
public void fly () {
System . out . println ( "The airplane turns on its engines to fly." );
}
}
public class TestPolymorphism {
public static void main ( String [] args ) {
CanFly myBird = new Bird ();
CanFly myAirplane = new Airplane ();
myBird . fly (); // Output: The bird flaps its wings to fly.
myAirplane . fly (); // Output: The airplane turns on its engines to fly.
}
}CanFly mendefinisikan metode fly() tanpa menyediakan tubuh tubuh.Bird dan Airplane menggunakan metode fly() dengan cara mereka sendiri.myBird dan myAirplane direferensikan melalui antarmuka CanFly , dan ketika memanggil metode fly() , polimorfisme memungkinkan kita untuk tidak peduli dengan objek objek; Kita hanya tahu bahwa mereka bisa terbang.4. Abstraksi : Abstrak memungkinkan pemrogram untuk fokus pada apa yang dilakukan suatu objek tanpa peduli bagaimana melakukannya. Ini menciptakan kelas dasar yang menggambarkan antarmuka umum yang akan diterapkan oleh kelas turunan, menyederhanakan manajemen kompleksitas sistem.
Di Java, abstrak dapat dilakukan dengan dua cara:
Kelas abstrak adalah objek yang tidak dapat dibuat dan dapat berisi metode abstrak tanpa tubuh.
abstract class Animal {
// Phương thức trừu tượng
abstract void makeSound ();
// Phương thức bình thường
void breathe () {
System . out . println ( "Breathing..." );
}
}
class Dog extends Animal {
// Triển khai phương thức trừu tượng trong lớp con
void makeSound () {
System . out . println ( "Bark" );
}
}
public class Main {
public static void main ( String [] args ) {
Animal myDog = new Dog ();
myDog . makeSound (); // In ra "Bark"
myDog . breathe (); // In ra "Breathing..."
}
}Animal adalah lapisan abstrak dengan metode abstrak makeSound() .Dog adalah kelas yang diwariskan dari Animal dan harus memberikan penyebaran khusus untuk metode abstrak makeSound() .Antarmuka (antarmuka) hanya dapat berisi metode abstrak tanpa penyebaran.
interface Vehicle {
void start ();
void stop ();
}
class Car implements Vehicle {
public void start () {
System . out . println ( "Car starting" );
}
public void stop () {
System . out . println ( "Car stopping" );
}
}
class Bike implements Vehicle {
public void start () {
System . out . println ( "Bike starting" );
}
public void stop () {
System . out . println ( "Bike stopping" );
}
}
public class Main {
public static void main ( String [] args ) {
Vehicle myCar = new Car ();
Vehicle myBike = new Bike ();
myCar . start (); // In ra "Car starting"
myCar . stop (); // In ra "Car stopping"
myBike . start (); // In ra "Bike starting"
myBike . stop (); // In ra "Bike stopping"
}
} Di sini, Vehicle adalah antarmuka yang mendefinisikan dua metode abstrak: start() dan stop() . Lapisan Car dan Bike menyebarkan antarmuka ini dan memberikan penyebaran khusus untuk setiap metode.
Kesamaan:
Perbedaan:
| Kelas abstrak | Antarmuka | |
|---|---|---|
| Tujuan | - Sering digunakan ketika sub -kelas memiliki banyak fungsi umum dan membutuhkan tempat umum untuk menempatkan kode yang dapat digunakan kembali. -Membantu mendefinisikan pola dasar untuk sub -layer, pastikan semua sub -kelas mewarisi untuk mengikuti desain umum. | - Sering digunakan untuk mendefinisikan kontrak untuk fungsi tanpa peduli. - Ideal untuk fungsi yang dapat diimplementasikan sangat berbeda. - Baik untuk definisi metode pengumpulan yang dapat dilakukan kelas. |
| Penyebaran | - Dapat berisi metode abstrak (tidak ada tubuh) dan metode non -abstrak (dengan tubuh). - Kelas abstrak juga dapat berisi bidang data dan konstruktor. | - Awalnya, ini hanya memungkinkan definisi metode abstrak tanpa tubuh. - Dari Java 8 dan seterusnya, antarmuka juga memungkinkan definisi metode tubuh melalui metode default dan metode statis. |
| Multi -Inheritance | - Kelas hanya dapat mewarisi dari satu lapisan abstrak. - Ini membatasi fleksibilitas multi -warisan seperti di antarmuka. | - Java memungkinkan lapisan untuk melakukan beberapa antarmuka secara bersamaan, memberikan bentuk multi -warisan. |
| Rahang | - Mungkin ada kendala, membantu mengatur kondisi awal untuk kelas. | - Tidak ada konstruktor. |
| Bidang data | - Tidak seperti antarmuka, kelas abstrak mungkin memiliki bidang data yang bukan statika dan final. - Sub -layer mungkin memiliki atribut terpisah yang diwarisi dari lapisan abstrak. | - Antarmuka tidak mendukung bidang data tidak statis dan final. - Semua variabel yang dinyatakan dalam antarmuka secara otomatis dianggap sebagai final statis publik. |
Pemrograman yang berorientasi objek membawa banyak keunggulan luar biasa dalam pengembangan perangkat lunak, menjadikannya salah satu model desain dan pemrograman utama dalam industri teknologi informasi. Inilah keuntungannya:
Kode Kembali : OOP memungkinkan pemrogram untuk menggunakan kembali kode sumber melalui mekanisme warisan. Lapisan anak dapat mewarisi fitur dari kelas ayah tanpa menulis ulang kode itu. Ini membantu mengurangi pekerjaan pemrograman, meminimalkan potensi kesalahan dan mempercepat pengembangan perangkat lunak.
Kesalahan Mudah Dipertahankan dan Memperbaiki : Struktur pengemasan di OOP membantu menyembunyikan detail penyebaran, hanya menyediakan antarmuka (antarmuka) yang diperlukan untuk pengguna. Ini membuat sistem pemeliharaan dan pembaruan lebih mudah, karena perubahan di dalam objek tidak mempengaruhi objek lain.
Pemodelan Praktis : OOP memungkinkan pemrograman untuk memodelkan entitas nyata dalam bentuk objek perangkat lunak, membuat kode sumber lebih mudah dipahami dan dikelola. Penggunaan objek seperti melakukan data dan perilaku di dunia nyata membantu mengembangkan perangkat lunak untuk menjadi lebih intuitif dan lebih dekat dengan programmer.
Ekspansi : Berkat kemampuan untuk mewarisi dan mengemas, OOP mudah diperluas. Lapisan baru dapat dibuat dengan warisan dari satu atau lebih lapisan yang ada tanpa mempengaruhi lapisan tersebut. Ini membantu sistem tumbuh secara fleksibel dan beradaptasi dengan kebutuhan baru dengan cepat.
Keamanan : Kemasan tidak hanya membantu menyembunyikan detail implementasi tetapi juga menyediakan lapisan keamanan. Data di dalam objek dilindungi dari akses langsung eksternal, memastikan integritas dan keamanan data.
Java adalah salah satu bahasa pemrograman paling populer yang digunakan untuk mengajarkan pemrograman berorientasi objek untuk alasan yang masuk akal.
Java adalah bahasa yang berorientasi objek murni , yang berarti segala sesuatu di Java adalah objek atau kelas. Konsep seperti warisan, pengemasan, polimorfisme, dan abstrak sepenuhnya dibangun ke dalam bahasa. Ini membantu peserta didik dengan mudah mengakses dan mempraktikkan prinsip OOP secara alami selama pemrograman.
Java memiliki sintaks yang jelas dan mudah -untuk -memahami. Sintaks Java didasarkan pada C/C ++, tetapi telah menghapus beberapa fitur kompleks seperti kursor langsung, menjadikannya bahasa yang ideal untuk mengajar pemula. Penghapusan fitur -fitur kompleks ini membantu peserta didik fokus pada pemahaman konsep inti OOP tanpa macet dalam detail yang membingungkan.
Java adalah fondasi bahasa independen , dapat berjalan pada sistem operasi apa pun dengan mesin virtual Java (JVM). Ini berarti bahwa program JAVA dapat mengembangkan dan mengimplementasikan secara konsisten pada platform yang berbeda tanpa mengubah kode. Fleksibilitas ini sangat ideal untuk lingkungan belajar, di mana siswa dan guru dapat menggunakan berbagai perangkat keras dan perangkat lunak.
Saat menggunakan arsip pembelajaran ini, Anda harus mengikuti prinsip pengaturan yang disebutkan di bawah ini. Baca item sesuai dengan aturan dari atas ke bawah, bagian pertama akan menjadi dasar konten berikutnya. Khusus untuk lampiran yang dapat Anda rujuk kapan saja, berisi beberapa buku yang saya gunakan untuk merancang arsip ini.
Untuk menyinkronkan dan mudah dikendalikan, lapisan utama berisi metode utama untuk menjalankan kode sama dengan konten pelajaran. Kelas lain dalam pelajaran untuk diilustrasikan. Sebagai contoh, pelajaran tentang antarmuka ada di
Interface.javamemiliki kelas:Movable,Trackable,Drone,Interface, kelasDroneMovable,Trackable, memiliki efek menafsirkan pengetahuan pelajaran, dan kelasInterfaceuntuk menjalankan kode dari kelas sebelumnya.
Item ini hampir sama dengan penyimpanan saya: struktur data dan algoritma menggunakan C/C ++ , kecuali yang ditulis dalam bahasa Java. Akan ada beberapa perbedaan antara kedua bahasa, pembaca dapat membandingkannya sendiri.
Java adalah bahasa pemrograman dan terjemahan (dan ditafsirkan . Di Java, kode sumber diterjemahkan ke dalam bytecode, yang merupakan indikator biner sederhana yang berfungsi seperti kode komputer untuk komputer. Namun, tidak seperti C atau C ++, kode bytecode JAVA bukanlah kode mesin yang umum untuk semua prosesor spesifik tetapi untuk JAVA (JVM, Virtual, Virtual Machine.
Bytecode ini kemudian diterjemahkan dan dieksekusi oleh mesin virtual Java seolah -olah itu adalah kode mesin asli. JVM berfungsi seperti sistem operasi yang aktif dalam mengelola perintah memori dan pemrosesan, memastikan keamanan dan ponsel kode. Semua karakteristik bahasa Java didefinisikan dengan jelas, terlepas dari sistem spesifik dari sistem dasar, membantu Java untuk dapat menjalankan homogen pada banyak platform yang berbeda tanpa pengeditan kode.
JVM menyediakan lingkungan penegakan hukum yang aman, di mana ia melakukan fungsi yang mirip dengan sistem operasi. Ini mengelola memori, menjalankan perintah berdasarkan tumpukan, dan memproses jenis air. Ini meminimalkan risiko keamanan dan meningkatkan stabilitas aplikasi.
Apakah itu terlihat mirip dengan C dan C ++ dalam hal sintaks, Java bukanlah keturunan langsung C atau versi C ++ berikutnya. Java memiliki lebih banyak kesamaan dengan bahasa dinamis seperti Smalltalk dan Lisp daripada C. Kesamaan hanya berhenti pada sintaks eksternal seperti menggunakan banyak kawat gigi dan titik koma. Java mewarisi filosofi C bahasa yang baik yang harus kompak, mudah diingat tetapi memperluas kosakata melalui paket kelas Java.
Bahasa skrip seperti Perl, Python dan Ruby sangat populer karena cocok untuk aplikasi yang aman dan jaringan. Namun, sebagian besar bahasa skrip tidak dirancang untuk pemrograman skala besar yang serius. Mereka sering tidak cocok untuk proyek besar atau kompleks karena struktur program yang longgar dan sistem data sederhana.
Java menyediakan platform yang aman untuk mengembangkan kerangka kerja tingkat yang lebih tinggi dan bahkan bahasa lain, menggabungkan kesederhanaan dan fitur Java yang memungkinkan pengembangan aplikasi yang cepat dan mudah. Java juga telah belajar dari fitur SmallTalk dan meningkatkannya, terutama dalam penggunaan tes bytecode yang ditetapkan untuk memastikan keakuratan kode kampanye, membantu meningkatkan kinerja dan memastikan keamanan daripada SmallTalk.
Java dirancang untuk menjadi bahasa yang aman, tidak hanya terhadap kesalahan perangkat lunak tetapi juga masalah umum dalam desain dan pemrograman. Java menawarkan banyak lapisan pelindung, dari uji keselamatan kode sebelum berjalan ke cara class loader dimuat, mekanisme beban bytecode dari interpretasi Java, menciptakan "dinding" di sekitar kelas yang tidak dapat diandalkan. Fitur -fitur ini adalah dasar untuk kebijakan keamanan tingkat tinggi, memungkinkan atau tidak memungkinkan berbagai jenis kegiatan pada setiap aplikasi.
Java dimulai dari "papan tulis" dan karenanya dapat menghindari fitur yang kompleks atau kontroversial dalam bahasa lain. Misalnya, Java tidak mengizinkan programmer untuk meregenerasi operator (seperti + hay -), tidak ada uang pemrosesan uang seperti makro atau pernyataan #define, hal -hal yang sering digunakan dalam bahasa lain untuk mendukung ketergantungan pada platform.
Java juga menyediakan struktur paket yang jelas untuk mengatur file kelas, membantu proses kompilasi untuk menangani beberapa fungsi alat buatan Make -Made tradisional secara efektif. Semua informasi tipe data disimpan di kelas Java yang dikompilasi, tanpa perlu file judul sumber berlebih seperti dalam C/C ++. Ini membuat kode Java lebih mudah dibaca dan lebih sedikit konteks.
Java hanya mendukung warisan (setiap kelas hanya memiliki satu kelas "ayah") tetapi memungkinkan warisan banyak antarmuka. Antarmuka di Java, mirip dengan lapisan abstrak di C ++, mengidentifikasi perilaku suatu objek tanpa mempertahankan eksekusi. Ini adalah mekanisme yang kuat yang memungkinkan pengembang untuk mendefinisikan "kontrak" dari perilaku objek yang dapat digunakan dan dirujuk secara independen untuk setiap eksekusi objek tertentu.
Java menghilangkan penggunaan kursor yang dapat merujuk ke area memori apa pun dan menambahkan pengumpulan sampah secara otomatis dan segmen tingkat tinggi. Fitur -fitur ini membantu menghilangkan banyak masalah yang berkaitan dengan keselamatan, konversi, dan optimasi yang sering ditemui bahasa lain. Di Java, subjek yang tidak lagi digunakan akan secara otomatis memulihkan memori, meminimalkan kesalahan manajemen memori manual.
Java tidak menggunakan kursor tradisional tetapi lebih merupakan referensi yang lebih ketat dan lebih aman. Subjek di Java, kecuali untuk tipe primitif, diakses melalui referensi. Ini memungkinkan membangun struktur data yang kompleks dengan aman dalam tipe data tanpa risiko yang terkait dengan kursor di C/C ++.
Java dirancang untuk menangani kesalahan dengan cara yang cerdas dan efektif, berkat mekanisme manajemen pengecualian yang kuat. Di Java, kesalahan tidak hanya ditangkap dan diproses di tempat tertentu dalam program melalui blok kode "tangkapan", tetapi juga dikemas dalam pengecualian. Masing -masing objek ini membawa informasi tentang penyebab kesalahan, memudahkan pemrogram untuk memahami dan menangani kesalahan dengan benar. Terjemahan Java membutuhkan metode untuk menyatakan pengecualian yang mungkin muncul, atau untuk menanganinya segera. Ini membantu membawa informasi kesalahan ke tingkat yang sama dengan informasi lain seperti tipe data pengembalian atau metode metode. Dengan demikian, ketika pemrograman, Anda dapat memprediksi dan mempersiapkan situasi yang mungkin, memastikan bahwa aplikasi Anda akan beroperasi lebih stabil dan lebih aman.
Dalam pemrograman dan pengembangan perangkat lunak, Konvensi Penamaan adalah kumpulan aturan untuk memilih nama variabel, rahang, kelas, dan objek lain dalam kode sumber. Konvensi identifikasi membuat kode sumber lebih mudah dibaca, mudah dipahami dan lebih mudah dipelihara. Penyimpanan saya secara ketat mematuhi konvensi ini, yang disebutkan di bawah ini.
Kelas: Nama kelas selalu dimulai dengan huruf yang dicetak (Pascalcase). Jika nama kelas terdiri dari banyak kata, setiap kata juga harus dimulai dengan cetakan bunga. Misalnya: Student , Car , ColorChooser .
Antarmuka: Seperti kelas, nama antarmuka juga menggunakan Pascalcase. Seringkali nama antarmuka akan dimulai dengan huruf kapital seperti I atau menggunakan bodoh/akhiran seperti able atau ible untuk menggambarkan fitur, seperti Runnable , Accessible .
Metode metode ini selalu dimulai dalam huruf normal dan mengikuti Camelcase. Nama metode biasanya frasa kata kerja atau kata kerja yang menggambarkan tindakan yang dilakukan metode. Misalnya: getName() , calculateTotalWidth() .
Nama variabel juga harus dimulai dengan huruf normal dan diikuti oleh Camelcase. Nama variabel harus jelas dan menjelaskan nilai yang mereka wakili. Misalnya: height , numberOfStudents .
Contoh kelas Dog :
package com . example . animals ;
/**
* A generic Dog class that can be used as a base class for specific breeds.
*/
public class Dog {
private String name ;
private int age ;
/**
* Constructor for Dog class.
*
* @param name The name of the dog.
* @param age The age of the dog.
*/
public Dog ( String name , int age ) {
this . name = name ;
this . age = age ;
}
/**
* Returns the name of the dog.
*
* @return The name of the dog.
*/
public String getName () {
return name ;
}
/**
* Sets the name of the dog.
*
* @param name New name for the dog.
*/
public void setName ( String name ) {
this . name = name ;
}
/**
* Returns the age of the dog.
*
* @return The age of the dog.
*/
public int getAge () {
return age ;
}
/**
* Sets the age of the dog.
*
* @param age New age for the dog.
*/
public void setAge ( int age ) {
this . age = age ;
}
/**
* Provides a string representation of the dog.
*
* @return A string describing the dog's details.
*/
@ Override
public String toString () {
return "Dog[name=" + name + ", age=" + age + "]" ;
}
}| Indikasi akses | publik | Terlindung | bawaan | Pribadi | |
|---|---|---|---|---|---|
| Bersama dengan paket | Di dalam kelas | Memiliki | Memiliki | Memiliki | Memiliki |
| Sub -Class | Memiliki | Memiliki | Memiliki | Tidak | |
| Kelas lainnya | Memiliki | Memiliki | Memiliki | Tidak | |
| Paket yang berbeda | Sub -Class | Memiliki | Memiliki | Tidak | Tidak |
| Kelas lainnya | Memiliki | Tidak | Tidak | Tidak | |
Unified Modeling Language (UML) adalah alat pemodelan grafis standar, yang dirancang untuk membuat sketsa, menjelaskan, dan mendokumentasikan tentang berbagai aspek perangkat lunak aplikasi. Ini sangat berguna di bidang pemrograman berorientasi objek, karena memberikan cara intuitif untuk menampilkan kelas, objek, dan hubungan di antara mereka. UML mencakup berbagai jenis diagram, tetapi dalam konteks pemrograman berorientasi objek, diagram kelas (diagram kelas) dan diagram interaktif (diagram interaksi) adalah dua jenis yang paling umum digunakan.
UML memungkinkan pemrogram untuk menggambarkan struktur sistem menggunakan diagram kelas. Diagram ini menunjukkan kelas dalam sistem, atribut, metode mereka, dan yang paling penting, hubungan antara kelas -kelas seperti pewarisan, keterkaitan, sintesis dan kombinasi. Ini membantu pemrogram memahami dan merancang sistem lebih sistematis.
Setelah diagram UML selesai, itu dapat digunakan sebagai dasar untuk menulis kode sumber. Dalam OOP, transfer dari diagram lapisan ke kode sumber (biasanya Java, C#, atau C ++) cukup langsung, karena kesamaan antara konsep yang dijelaskan dalam UML dan struktur lapisan dalam bahasa pemrograman ini.
UML membantu mendefinisikan secara jelas hubungan antara objek, menyoroti cara komunikasi dan interaksi di antara mereka melalui diagram urutan (diagram urutan) dan diagram kolaborasi (diagram kolaborasi). Ini membantu pemrogram memahami aliran data dan kontrol dalam aplikasi.
Sebelum mulai menulis kode, UML membantu kelompok pengembangan dapat mendeteksi dan memperbaiki masalah desain. Persatuan dalam penggunaan UML juga membantu anggota dalam kelompok dengan mudah memahami ide -ide satu sama lain, sehingga meningkatkan efisiensi koordinasi kerja.
UML menyediakan dokumen lengkap untuk perangkat lunak, yang sangat berguna dalam tahap pemeliharaan dan perangkat lunak. Diagram UML yang baik dapat membantu orang baru yang berpartisipasi dalam proyek dengan cepat menangkap struktur dan fungsi sistem.
Diagram kelas (diagram kelas) adalah salah satu jenis diagram yang digunakan dalam UML dan memainkan peran penting dalam memodelkan sistem perangkat lunak. Diagram kelas memberikan gambaran umum tentang struktur aplikasi dengan menampilkan lapisan sistem, atribut dan metode mereka, dan hubungan antara lapisan -lapisan tersebut. Hubungan -hubungan ini dapat mencakup: tautan (asosiasi), pewarisan (pewarisan), penegakan (realisasi), ketergantungan, agrease, komposisi.
Kelas mewakili konsep yang mencakup status (atribut) dan perilaku (metode). Setiap atribut memiliki satu jenis. Setiap metode memiliki tanda tangan. Nama kelas adalah satu -satunya informasi wajib.
Pertimbangkan contoh berikut:
Diagram UML ini sesuai dengan Animal kelas dalam kode sebagai berikut:
public class Animal {
// Các thuộc tính của lớp
public String name ; // Biến thành viên công khai cho tên
private int age ; // Biến thành viên riêng tư cho tuổi
private String species ; // Biến thành viên riêng tư cho loài
// Phương thức getter cho thuộc tính name
public String getName () {
return name ;
}
// Phương thức setter cho thuộc tính name
public void setName ( String name ) {
this . name = name ;
}
} Simbol + , - dan # dan # dan # dan nama metode di lapisan menunjukkan tingkat kapasitas akses atribut dan metode. Secara khusus:
+ menunjukkan atribut atau metode publik (publik).- Menunjukkan properti atau metode privasi (pribadi).# menunjukkan properti atau metode pelindung (dilindungi).
Flyable dengan metode fly() , kelas Bird dapat menjalankan antarmuka ini dengan menggunakan metode fly() .School mungkin memiliki banyak objek kelas Teacher , tetapi para guru masih ada secara independen dari sekolah.House mungkin berisi banyak benda Room . Ketika House dibatalkan, Room juga akan dibatalkan.| Warisan | Mengumpulkan | |
|---|---|---|
| Mendefinisikan | - Warisan adalah mekanisme di mana satu lapisan (disebut sub -layer) dapat mewarisi sifat dan metode lapisan lain (disebut kelas induk). - Biarkan subdivisi menggunakan kembali kode ayah tanpa menulis ulang. - sesuai dengan hubungan "is-a". | - Elemen adalah bentuk hubungan "di sana" antara dua lapisan. - Menunjukkan hubungan di mana suatu objek dapat berisi atau merujuk ke objek lain, tetapi kedua subjek mungkin ada secara independen. - Sesuai dengan hubungan "has-a". |
| Tujuan | - Gunakan kembali kode dan tingkatkan modul aplikasi. - Juga mendukung polimorfisme, memungkinkan metode anak untuk dapat menimpa atau memperluas metode kelas induk. - Misalnya: kelas hewan memiliki metode gerakan (), kelas burung dan ikan dapat mewarisi hewan dan menggunakan atau mengesampingkan metode gerakan () agar sesuai dengan sifat mereka yang bergerak. | - Mewakili hubungan antara objek, di mana objek mungkin memiliki hubungan parsial satu sama lain tetapi tidak sepenuhnya bergantung satu sama lain. - membantu meningkatkan fleksibilitas dalam struktur data dan mengelola objek yang rumit. - Misalnya, lapisan persegi mungkin memiliki objek dari lapisan titik. Setiap kuadrat terdiri dari empat objek dari lapisan titik (menunjukkan simpul) tetapi titik mungkin ada secara independen tanpa puncak kuadrat. |
| Ketergantungan | - Sub -kelas sangat tergantung pada kelas ayah karena secara langsung menggunakan sifat dan metode ayah. | - Subjek yang relevan mungkin ada secara mandiri; Mereka tidak terlalu bergantung bersama. |
| Kemampuan | - Perluas atau sesuaikan lapisan ayah. - Memodelkan hubungan yang terdesentralisasi. | - Kelola objek terkait. - Memodelkan hubungan fisik. |
Pertimbangkan contoh berikut:
Menyebarkan diagram UML ini di java adalah sebagai berikut:
public class Person {
private String name ;
private int age ;
private Address address ; // Liên kết sử dụng lớp Address
public Person ( String name , int age , Address address ) {
this . name = name ;
this . age = age ;
this . address = address ;
}
// Getter và Setter cho các thuộc tính
public String getName () {
return name ;
}
public void setName ( String name ) {
this . name = name ;
}
public int getAge () {
return age ;
}
public void setAge ( int age ) {
this . age = age ;
}
public Address getAddress () {
return address ;
}
public void setAddress ( Address address ) {
this . address = address ;
}
}
// Định nghĩa lớp Student kế thừa từ Person
public class Student extends Person {
public Student ( String name , int age , Address address ) {
super ( name , age , address );
}
}
// Định nghĩa lớp Teacher kế thừa từ Person
public class Teacher extends Person {
public Teacher ( String name , int age , Address address ) {
super ( name , age , address );
}
}
// Định nghĩa lớp Staff kế thừa từ Person
public class Staff extends Person {
public Staff ( String name , int age , Address address ) {
super ( name , age , address );
}
}
// Định nghĩa lớp Address
public class Address {
private String street ;
private String city ;
private String country ;
public Address ( String street , String city , String country ) {
this . street = street ;
this . city = city ;
this . country = country ;
}
// Getter và Setter cho các thuộc tính
public String getStreet () {
return street ;
}
public void setStreet ( String street ) {
this . street = street ;
}
public String getCity () {
return city ;
}
public void setCity ( String city ) {
this . city = city ;
}
public String getCountry () {
return country ;
}
public void setCountry ( String country ) {
this . country = country ;
}
}
// Định nghĩa lớp Department chứa Teacher và Course
public class Department {
private String name ;
private List < Teacher > teachers ; // Aggregation
private List < Course > courses ; // Composition
public Department ( String name ) {
this . name = name ;
this . teachers = new ArrayList <>();
this . courses = new ArrayList <>();
}
// Phương thức thêm giáo viên và khóa học
public void addTeacher ( Teacher teacher ) {
teachers . add ( teacher );
}
public void addCourse ( Course course ) {
courses . add ( course );
}
}
// Định nghĩa lớp Course
public class Course {
private String courseName ;
private List < Teacher > teachers ; // Association
public Course ( String courseName ) {
this . courseName = courseName ;
this . teachers = new ArrayList <>();
}
public void addTeacher ( Teacher teacher ) {
teachers . add ( teacher );
}
}
// Định nghĩa interface Maintainable
public interface Maintainable {
void maintain ();
}
// Định nghĩa lớp School
public class School implements Maintainable {
private String name ;
private List < Department > departments ; // Composition
public School ( String name ) {
this . name = name ;
this . departments = new ArrayList <>();
}
public void addDepartment ( Department department ) {
departments . add ( department );
}
// Triển khai phương thức từ interface Maintainable
@ Override
public void maintain () {
System . out . println ( "Maintaining the school facilities..." );
// Logic bảo trì cơ sở vật chất có thể được thực hiện ở đây
}
}
