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
}
}
