Object oriented Programming with Java
1.0.0
歡迎使用Java到面向對象的編程存儲！它提供了一個綜合資源，可以通過Java語言探索和學習面向對象的編程。
面向對象的編程（OOP -OOP -OOP-面向的編程）是一種流行的編程模型，可在軟件開發中廣泛使用。它基於“對象”的概念，該概念是結合數據（屬性）和方法（行為）的實體。 OOP專注於基於交互式對象的軟件設計，而不是程序編程編程中的過程和邏輯。
面向對象的編程基於4個基本原理，即：包裝，繼承，多態性和抽象。這些原則中的每一個都提供了一種解決軟件開發問題的方法，並有助於更有效地管理源代碼。
1。封裝：這是隱藏對象的內部部署細節，以防止用戶直接訪問內部數據的概念。包裝有助於保護對象的數據和行為免受不需要的干預措施，並提供了與對象交互的統一接口。
// 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 ());
}
}在此示例中，變量name ， age和salary被標記為private ，這意味著他們無法直接從Employee的外部訪問。相反，提供了getName() ， getAge() ， getSalary() ， setName() ， setAge()和setSalary()以訪問和更新這些變量的值，從而確保包裝。
2。繼承（繼承）：繼承允許新圖層從現有層繼承屬性和方法。該新層可以添加或修改繼承組件以滿足其自身需求，從而有效地重複使用和擴展源代碼。
// 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班是基類，其中包含基本信息，例如名稱和年齡。Manager層是來自Employee的派生類，並添加了salary屬性。Manager層使用extends到從Employee類繼承的關鍵字。 Manager的構造函數稱為super(name, age) ；初始化從Employee類繼承的屬性。Manager類中覆蓋了displayInfo()方法，以添加有關工資的更多信息，並調用基類的displayInfo()方法以顯示基本信息。3。多態性：多態性是可以通過相同界面使用不同類別的能力。該方法可以在基本層中定義，並由衍生物類中同名的方法替換，從而使對象可以通過公共接口處理而不知道其特定數據類型。
在Java中，多態性是通過過渡和充電該方法（方法過載）的過頭方法表達的。
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"
}
}在此示例中， speak()方法在Dog和Cat層中被覆蓋。當在孩子的對像上調用speak()方法時，Java確定在運行時將調用哪種方法，具體取決於參考變量的對像類型。
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類具有三個版本的print方法，每個版本都處理特定的數據類型： String ， int和double 。print方法，Java都會根據傳輸參數的數據類型確定適當的版本。也通過使用界面的機制清楚地表達了多態性。 Java中的接口是實現較高多態性的一種方法，允許一層部署許多接口和可以由不同層部署的接口。
假設我們有一個接口CanFly和兩層Bird和Airplane都實現了此接口：
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定義了fly()方法，而無需提供身體。Bird和Airplane都以自己的方式部署了fly()方法。myBird和myAirplane對像都通過接口CanFly引用，當調用fly()方法時，多態性使我們不關心對象的對象。我們只知道他們可以飛。4。抽象：摘要允許程序員專注於對像在不關心如何做的情況下進行的操作。它創建了一個基類，該基類描述了派生類將實現的一般接口，從而簡化了系統複雜性的管理。
在Java中，可以通過兩種方式完成摘要：
抽像類是無法創建的對象，並且可以包含沒有身體的抽象方法。
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是帶有抽象方法的抽象層makeSound() 。Dog是來自Animal的遺傳階級，必須為makeSound() 。接口（接口）只能包含無需部署的抽象方法。
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"
}
}在這裡， Vehicle是定義兩個抽象方法的接口： start()和stop() 。 Car和Bike層部署此接口並為每種方法提供特定的部署。
相似：
差異：
| 抽像類 | 介面 | |
|---|---|---|
| 目的 | - 通常在子類具有許多常見功能時使用，並且需要一個共同的位置來放置可以重複使用的代碼。 - 幫助定義子層的基本模式，請確保所有子類都繼承它以遵循共同的設計。 | - 通常用於定義不關心的功能合同。 - 理想的功能可以非常不同。 - 非常適合班級可以執行的收集方法的定義。 |
| 部署 | - 可以包含抽象方法（無體）和非摘要方法（帶有身體）。 - 抽像類還可以包含數據字段和構造函數。 | - 最初，它僅允許定義沒有身體的抽象方法。 - 從Java 8開始，該接口還允許通過默認方法和靜態方法定義身體方法。 |
| 多態 | - 類只能從單個抽象層繼承。 - 這限制了界面中多啟示的靈活性。 | - Java允許一層同時執行多個接口，從而提供多種媒介形式。 |
| 顎 | - 可能有限制，有助於設置課程的初始條件。 | - 沒有構造函數。 |
| 數據字段 | - 與接口不同，抽像類可能具有不是靜態和最終的數據字段。 - 子層可能具有從抽象層繼承的單獨屬性。 | - 接口不支持數據字段不是靜態的，最終的。 - 接口中聲明的所有變量自動被視為公共靜態決賽。 |
面向對象的編程為軟件開髮帶來了許多出色的優勢，使其成為信息技術行業的主要設計和編程模型之一。這是它的優勢：
重複使用代碼：OOP允許程序員通過繼承機制重複使用源代碼。孩子的層可以在不重寫該代碼的情況下繼承父親類的功能。這有助於減少編程工作，最大程度地減少潛在錯誤並加快軟件開發。
易於維護和修復錯誤：OOP中的包裝結構有助於隱藏部署詳細信息，僅提供用戶所需的接口（接口）。這使系統維護和更新更加容易，因為在對象內部更改不會影響其他對象。
實用建模：OOP允許編程以軟件對象的形式對真實實體進行建模，從而使源代碼易於理解和管理。在現實世界中執行數據和行為之類的對象的使用有助於開發軟件，以變得更加直觀，更接近程序員。
擴展：由於能夠繼承和包裝，OOP很容易擴展。可以通過從存在的一個或多個層的繼承而創建一個新圖層，而不會影響這些層。這有助於系統靈活地生長并快速適應新需求。
安全性：包裝不僅有助於隱藏實現詳細信息，還可以提供安全層。對象內部的數據受到外部直接訪問的保護，以確保數據的完整性和安全性。
Java是出於合理的原因，Java是用於教授對象的編程的最受歡迎的編程語言之一。
Java是一種面向對象的語言，這意味著Java中的所有內容都是對像或類。諸如繼承，包裝，多態性和摘要之類的概念完全內置在語言中。這有助於學習者在編程過程中自然輕鬆訪問和練習OOP原則。
Java具有清晰而簡單的 - 理解語法。 Java的語法基於C/C ++，但已刪除了一些複雜的功能，例如直接光標，使其成為教學者的理想語言。消除這些複雜的功能有助於學習者專注於理解OOP的核心概念，而不會陷入混亂的細節中。
Java是一個獨立的語言基礎，可以使用Java（JVM）虛擬機上的任何操作系統運行。這意味著Java程序可以在不同的平台上始終如一地開發和實施，而無需更改代碼。這種靈活性非常適合學習環境，學生和老師可以使用各種硬件和軟件。
在使用此檔案進行學習時，您應該遵循下面提到的安排原則。根據從上到下的規則讀取項目，第一部分將是下一個內容的基礎。特別是對於您可以隨時參考的附錄，它包含我用於設計此檔案的一些書籍。
為了同步並易於控制，主層包含執行代碼與課程內容相同的主要方法。課程中的其他課程要說明。例如，有關接口的課程在
Interface.java中。 Java具有類：Movable，Trackable，Drone，Interface，MovableTrackable，可Drone的無人機類具有解釋課程知識的效果，而Interface類則可以從先前類IT執行代碼。
此項目與我的存儲幾乎相同：使用C/C ++的數據結構和算法，但使用Java語言編寫的順序幾乎相同。兩種語言之間會有一些差異，讀者可以自己比較它們。
Java既是一種編程語言又是翻譯（並解釋。在Java中，源代碼被翻譯成字節碼，這是簡單的二進制指標，例如計算機計算機代碼的工作。但是，與C或C ++不同，Java的Bytecode不是任何特定的處理器的本機機器代碼，而是用於Java（JVM）的Java（Jvm）（JVM），而是用於JAVM（JVM）的通用平台。
然後，Java Virtual Machine翻譯和執行此字節碼，就好像是本機機器代碼一樣。 JVM在管理內存和處理命令中的工作就像是主動操作系統，以確保代碼的安全性和移動設備。無論基本系統的特定係統如何，Java語言的所有特徵都是明確定義的，可以幫助Java能夠在許多不同的平台上運行均勻的情況，而無需編碼。
JVM提供了一個安全的執法環境，其執行功能類似於操作系統。它可以管理內存，基於堆棧執行命令以及處理水類型。這樣可以最大程度地減少安全風險並提高應用程序的穩定性。
無論是在語法方面看起來與C ++相似，Java還是C ++的下一個版本的直接後代。 Java與SmallTalk和Lisp等動態語言有更多的共同點，而不是C。相似性僅在外部語法上停止，例如使用許多括號和分號。 Java繼承了C的良好語言哲學，該語言應該是緊湊，易於記住的，但通過Java class軟件包擴展了詞彙。
Perl，Python和Ruby等腳本語言非常受歡迎，因為它們適合安全且網絡的應用程序。但是，大多數腳本語言並不是為嚴重的大規模編程而設計的。由於程序結構和簡單的數據系統，它們通常不適合大型或複雜的項目。
Java提供了一個安全的平台來開發更高級別的框架甚至其他語言，結合了Java的簡單性和功能，可以快速輕鬆地開發應用程序。 Java還從SmallTalk的功能中學到了這些知識，並改進了它們，尤其是在使用字節碼測試集以確保活動代碼的準確性，有助於提高性能並確保安全性比SmallTalk相比。
Java旨在成為一種安全的語言，不僅是針對軟件錯誤，而且還針對設計和編程中的常見問題。 Java提供了許多保護層，從代碼的安全測試到運行到類加載器的加載方式，即Java解釋的字節碼加載機制，從而在不可靠的類中創建“牆”。這些功能是高級安全策略的基礎，允許或不允許在每個應用程序上進行各種活動。
Java從“白板”開始，因此可以避免其他語言中復雜或有爭議的功能。例如，Java不允許程序員再生運算符（例如 + Hay-），沒有錢處理宏或#Define語句，即通常以其他語言使用的東西來支持對平台的依賴。
Java還提供了一個清晰的軟件包結構來組織類文件，幫助編譯過程有效地處理傳統製造工具的某些功能。所有數據類型信息均保留在編譯的Java類中，而無需像C/C ++一樣多餘的源標題文件。這使Java代碼易於閱讀和更少的上下文。
Java僅支持繼承（每個類只有一個“父親”類），但允許繼承許多接口。 Java中的接口（類似於C ++中的抽象層）在不捍衛其執行的情況下標識對象的行為。這是一種強大的機制，允許開發人員定義對象行為的“合同”，該行為可以獨立使用並獨立引用任何特定對象執行。
Java消除了可以參考任何存儲區域的光標的使用，並添加自動垃圾收集和高級段。這些功能有助於消除與其他語言經常遇到的安全，轉換和優化有關的許多問題。在Java中，不再使用的主題會自動恢復內存，最大程度地減少手動內存管理錯誤。
Java不使用傳統光標，而是更緊密，更安全的參考。除原始類型外，Java中的受試者是通過參考訪問的。這允許在數據類型中安全地構建複雜的數據結構，而沒有與C/C ++相關的風險。
由於強大的異常管理機制，Java旨在以智能有效的方式處理錯誤。在Java中，不僅通過“捕獲”代碼塊在程序中的特定位置捕獲和處理錯誤，而且還包裝成異常。這些對像中的每一個都帶來了有關錯誤原因的信息，使程序員可以易於正確理解和處理錯誤。 Java翻譯要求該方法聲明可能出現的例外，或立即處理它們。這有助於將錯誤信息與其他信息（例如返回數據類型或方法的方法）相同。因此，在編程時，您可以預測並準備可能的情況，以確保您的應用程序將更加穩定和更安全。
在軟件編程和開發中， “命名約定”是一個規則集合，用於在源代碼中選擇變量，下巴，類和其他對象的名稱。標識公約使源代碼易於閱讀，易於理解且易於維護。我的存儲嚴格符合下面提到的這一約定。
班級：班級名稱總是從打印字母（pascalcase）開始。如果班級名稱由許多單詞組成，則每個單詞也必須從花卉印刷開始。例如： Student ， Car ， ColorChooser 。
接口：像類一樣，接口的名稱也使用pascalcase。通常，接口名稱將從我的大寫字母開始，例如I或使用啞巴/後綴able或ible來描述該功能，例如Runnable ， Accessible功能。
該方法的方法始終以普通字母開始，並遵循駱駝箱。方法名稱通常是描述該方法執行的動作的動詞或動詞短語。例如： getName() ， calculateTotalWidth() 。
變量名稱也應從普通字母開始，然後是駱駝箱。變量名稱應清楚並描述它們所代表的價值。例如： height ， numberOfStudents 。
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 + "]" ;
}
}| 訪問指示 | 民眾 | 受保護 | 預設 | 私人的 | |
|---|---|---|---|---|---|
| 以及包裝 | 在班上 | 有 | 有 | 有 | 有 |
| 子類 | 有 | 有 | 有 | 不是 | |
| 其他課程 | 有 | 有 | 有 | 不是 | |
| 不同的軟件包 | 子類 | 有 | 有 | 不是 | 不是 |
| 其他課程 | 有 | 不是 | 不是 | 不是 | |
統一建模語言（UML）是一種標準的圖形建模工具，旨在繪製，描述和記錄有關應用程序軟件的不同方面。它在面向對象的編程領域特別有用，因為它提供了一種直觀的方式來顯示類，對象和它們之間的關係。 UML包括許多不同類型的圖表，但是在面向對象的編程，類圖（類圖）和交互式圖（交互圖）的上下文中，是兩種最常用的類型。
UML允許程序員使用類圖來描述系統的結構。該圖顯示了系統中的類，屬性，它們的方法，最重要的是，諸如繼承，鏈接，合成和組合之類的類之間的關係。這可以幫助程序員更系統地理解和設計系統。
UML圖完成後，它可以用作編寫源代碼的基礎。在OOP中，由於UML中描述的概念與這些編程語言中的層結構之間的相似性，從圖層圖到源代碼（通常是Java，C＃或C ++）的傳輸非常直接。
UML有助於清楚地定義對象之間的關係，突出通過序列圖（序列圖）和協作圖（協作圖）來突出它們之間的通信方式和交互方式。這有助於程序員了解應用程序中的數據流和控制。
在開始編寫代碼之前，UML幫助開發小組可以檢測並糾正設計問題。使用UML的統一還可以幫助小組中的成員輕鬆理解彼此的想法，從而提高了工作協調的效率。
UML為軟件提供完整的文檔，這在維護和軟件升級階段非常有用。良好的UML圖可以幫助參與該項目的新人快速捕獲系統的結構和功能。
類圖（類圖）是UML中使用的圖的類型之一，它在模擬軟件系統中起著重要作用。類圖通過顯示系統層，它們的屬性和方法以及這些層之間的關係來概述應用程序的結構。這些關係可能包括：鏈接（關聯），繼承（繼承），執法（實現），依賴關係，敏捷，組成。
類代表一個包括狀態（屬性）和行為（方法）的概念。每個屬性都有一種類型。每種方法都有一個簽名。班級名稱是唯一的強制性信息。
考慮以下示例：
該UML圖對應於代碼中的類Animal ，如下所示：
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 ;
}
}圖層中的符號+ ， -以及＃和#和＃和方法名稱表示屬性和方法的訪問能力級別。具體來說：
+表示公共的屬性或方法（公共）。-指示屬性或隱私方法（私有）。#表示屬性或保護方法（受保護）。
fly()方法的接口Flyable ， Bird類可以通過部署fly()方法來執行此接口。School課程可能有許多Teacher課的對象，但是教師仍然獨立於學校。House層可能包含Room的許多物體。取消House時， Room也將被取消。| 遺產 | 收集 | |
|---|---|---|
| 定義 | - 繼承是一種機制，其中一層（稱為子層）可以繼承另一層的性質和方法（稱為父類）。 - 允許該細分無需重寫父親的代碼。 - 對應於“ IS-A”關係。 | - 元素是兩層之間“那裡”關係的一種形式。 - 指示對象可以包含或指其他對象的關係，但是這兩個主題可能獨立存在。 - 對應於“ has-a”關係。 |
| 目的 | - 重複使用代碼並改進應用程序的模塊。 - 還支持多態性，使孩子的方法能夠覆蓋或擴展父類的方法。 - 例如：動物類具有Move（）方法，鳥類和魚類類別可以繼承動物，並使用或覆蓋Move（）方法適合其移動性質。 | - 代表對象之間的關係，其中對象可能彼此之間存在部分關係，但並非完全依賴對象。 - 幫助增強數據結構的靈活性並管理複雜的對象。 - 例如，平方層可能具有點層的對象。每個正方形由點層的四個對象組成（指示頂點），但點可能獨立存在而無需正方形的峰。 |
| 依賴 | - 子類強烈取決於父親的階級，因為它直接使用了父親的特性和方法。 | - 相關主題可能獨立存在；他們不堅定地依賴。 |
| 能力 | - 擴展或自定義父親的層。 - 建模分散關係。 | - 管理關聯的對象。 - 建模物理關係。 |
考慮以下示例：
在Java中部署此UML圖如下：
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
}
}
