Object oriented Programming with Java
1.0.0
ยินดีต้อนรับสู่ ที่เก็บข้อมูลการเขียนโปรแกรมที่มุ่งเน้นวัตถุด้วย Java ! มันมีทรัพยากรที่ครอบคลุมในการสำรวจและเรียนรู้การเขียนโปรแกรมเชิงวัตถุผ่านภาษา Java
การเขียนโปรแกรมเชิงวัตถุ (OOP - OOP - การเขียนโปรแกรม OOP -oriented) เป็นรูปแบบการเขียนโปรแกรมยอดนิยมที่ใช้กันอย่างแพร่หลายในการพัฒนาซอฟต์แวร์ มันขึ้นอยู่กับแนวคิดของ "วัตถุ" ซึ่งเป็นเอนทิตีที่รวมทั้งข้อมูล (คุณลักษณะ) และวิธีการ (พฤติกรรม) 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 และเพิ่มแอตทริบิวต์ salaryManager ใช้คำหลัก extends ไปสืบทอดจากคลาส Employee ตัวสร้างของ Manager ชื่อ super(name, age) ; เพื่อเริ่มต้นคุณสมบัติที่สืบทอดมาจากชั้นเรียน EmployeedisplayInfo() ถูกเขียนทับในคลาส Manager เพื่อเพิ่มข้อมูลเพิ่มเติมเกี่ยวกับเงินเดือนและเรียกใช้วิธี displayInfo() ของคลาสฐานเพื่อแสดงข้อมูลพื้นฐาน3. polymorphism : polymorphism คือความสามารถที่สามารถใช้คลาสที่แตกต่างกันผ่านอินเทอร์เฟซเดียวกัน วิธีการสามารถกำหนดในเลเยอร์ฐานและถูกแทนที่ด้วยวิธีการของชื่อเดียวกันในคลาสอนุพันธ์ทำให้วัตถุสามารถประมวลผลผ่านอินเทอร์เฟซทั่วไปโดยไม่ทราบชนิดข้อมูลเฉพาะของพวกเขา
ใน Java polymorphism จะแสดงออกผ่านวิธีการที่อยู่เหนือกว่าและการชาร์จวิธีการใหม่ (วิธีการโอเวอร์โหลด)
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 และ doubleprint Java จะกำหนดเวอร์ชันที่เหมาะสมตามประเภทข้อมูลของอาร์กิวเมนต์การส่งสัญญาณpolymorphism ยังแสดงออกอย่างชัดเจนผ่านกลไกการใช้อินเตอร์เฟส อินเทอร์เฟซใน 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() polymorphism ช่วยให้เราไม่สนใจเกี่ยวกับวัตถุของวัตถุ; เรารู้เพียงว่าพวกเขาสามารถบินได้4. Abstraction : บทคัดย่อช่วยให้โปรแกรมเมอร์มุ่งเน้นไปที่สิ่งที่วัตถุทำโดยไม่สนใจวิธีการทำ มันสร้างคลาสพื้นฐานที่อธิบายอินเทอร์เฟซทั่วไปที่คลาสอนุพันธ์จะนำไปใช้เพื่อลดความซับซ้อนของการจัดการความซับซ้อนของระบบ
ใน 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 ปรับใช้อินเทอร์เฟซนี้และให้การปรับใช้เฉพาะสำหรับแต่ละวิธี
ความคล้ายคลึงกัน:
ความแตกต่าง:
| คลาสนามธรรม | ส่วนต่อประสาน | |
|---|---|---|
| วัตถุประสงค์ | - มักใช้เมื่อคลาสย่อยมีฟังก์ชั่นทั่วไปมากมายและต้องการสถานที่ทั่วไปในการวางรหัสที่สามารถนำกลับมาใช้ใหม่ได้ -ช่วยกำหนดรูปแบบพื้นฐานสำหรับเครื่องย่อยย่อยตรวจสอบให้แน่ใจว่า sub -class ทั้งหมดได้รับมรดกเพื่อติดตามการออกแบบทั่วไป | - มักใช้เพื่อกำหนดสัญญาสำหรับฟังก์ชั่นโดยไม่ต้องดูแล - เหมาะอย่างยิ่งสำหรับฟังก์ชั่นที่สามารถนำไปใช้แตกต่างกันมาก - ดีสำหรับคำจำกัดความของวิธีการรวบรวมที่ชั้นเรียนสามารถดำเนินการได้ |
| การปรับใช้ | - สามารถมีวิธีการทั้งสองวิธี (ไม่มีร่างกาย) และวิธีการที่ไม่ได้ใช้ (กับร่างกาย) - คลาสนามธรรมยังสามารถมีเขตข้อมูลและตัวสร้าง | - ในขั้นต้นมันอนุญาตให้คำจำกัดความของวิธีการนามธรรมที่ไม่มีร่างกายเท่านั้น - จาก Java 8 เป็นต้นไปอินเทอร์เฟซยังช่วยให้คำจำกัดความของวิธีการของร่างกายผ่านวิธีการเริ่มต้นและวิธีการคงที่ |
| หลาย -inheritance | - คลาสสามารถสืบทอดได้จากเลเยอร์นามธรรมเดียวเท่านั้น - นี่เป็นการจำกัดความยืดหยุ่นของการเชื่อมโยงหลายแบบเช่นเดียวกับในอินเทอร์เฟซ | - Java อนุญาตให้เลเยอร์ดำเนินการหลายอินเทอร์เฟซในเวลาเดียวกันโดยให้แบบฟอร์มแบบหลายตัว |
| กราม | - อาจมีข้อ จำกัด ช่วยกำหนดเงื่อนไขเริ่มต้นสำหรับชั้นเรียน | - ไม่มีตัวสร้าง |
| เขตข้อมูล | - ไม่เหมือนกับอินเทอร์เฟซคลาสนามธรรมอาจมีเขตข้อมูลที่ไม่ใช่สถิติและสุดท้าย - เครื่องย่อยย่อยอาจมีแอตทริบิวต์แยกต่างหากที่สืบทอดมาจากเลเยอร์นามธรรม | - อินเทอร์เฟซไม่รองรับฟิลด์ข้อมูลไม่คงที่และสุดท้าย - ตัวแปรทั้งหมดที่ประกาศในอินเทอร์เฟซจะถูกพิจารณาโดยอัตโนมัติ |
การเขียนโปรแกรมเชิงวัตถุนำมาซึ่งข้อได้เปรียบที่โดดเด่นมากมายในการพัฒนาซอฟต์แวร์ทำให้เป็นหนึ่งในรูปแบบการออกแบบและการเขียนโปรแกรมหลักในอุตสาหกรรมเทคโนโลยีสารสนเทศ นี่คือข้อดีของมัน:
การใช้รหัสซ้ำ : OOP อนุญาตให้โปรแกรมเมอร์นำซอร์สโค้ดกลับมาใช้ใหม่ผ่านกลไกการสืบทอด เลเยอร์ของเด็กสามารถสืบทอดคุณสมบัติจากชั้นเรียนพ่อได้โดยไม่ต้องเขียนรหัสนั้นใหม่ สิ่งนี้จะช่วยลดงานการเขียนโปรแกรมลดข้อผิดพลาดที่อาจเกิดขึ้นและเพิ่มความเร็วในการพัฒนาซอฟต์แวร์
ง่ายต่อการบำรุงรักษาและแก้ไขข้อผิดพลาด : โครงสร้างบรรจุภัณฑ์ใน OOP ช่วยซ่อนรายละเอียดการปรับใช้เพียงให้เฉพาะอินเตอร์เฟส (อินเตอร์เฟส) ที่จำเป็นสำหรับผู้ใช้ สิ่งนี้ทำให้การบำรุงรักษาระบบและอัปเดตง่ายขึ้นเนื่องจากการเปลี่ยนภายในวัตถุไม่ส่งผลกระทบต่อวัตถุอื่น ๆ
การสร้างแบบจำลองเชิงปฏิบัติ : OOP ช่วยให้การเขียนโปรแกรมเป็นแบบจำลองเอนทิตีจริงในรูปแบบของวัตถุซอฟต์แวร์ทำให้ซอร์สโค้ดเข้าใจและจัดการง่ายขึ้น การใช้วัตถุเช่นการดำเนินการข้อมูลและพฤติกรรมในโลกแห่งความเป็นจริงช่วยพัฒนาซอฟต์แวร์ให้กลายเป็นโปรแกรมที่ใช้งานง่ายและใกล้ชิดกับโปรแกรมเมอร์มากขึ้น
การขยายตัว : ด้วยความสามารถในการสืบทอดและแพ็คทำให้ OOP ขยายง่าย สามารถสร้างเลเยอร์ใหม่ได้ด้วยการสืบทอดจากหนึ่งชั้นหรือมากกว่าหนึ่งชั้นที่มีอยู่โดยไม่ส่งผลกระทบต่อเลเยอร์เหล่านั้น สิ่งนี้จะช่วยให้ระบบเติบโตอย่างยืดหยุ่นและปรับให้เข้ากับความต้องการใหม่ได้อย่างรวดเร็ว
ความปลอดภัย : บรรจุภัณฑ์ไม่เพียง แต่ช่วยซ่อนรายละเอียดการใช้งาน แต่ยังมีเลเยอร์ความปลอดภัย ข้อมูลภายในวัตถุได้รับการปกป้องจากการเข้าถึงโดยตรงภายนอกเพื่อให้มั่นใจถึงความสมบูรณ์และความปลอดภัยของข้อมูล
Java เป็นหนึ่งในภาษาการเขียนโปรแกรมที่ได้รับความนิยมมากที่สุดที่ใช้ในการสอนการเขียนโปรแกรมเชิงวัตถุด้วยเหตุผลที่น่าเชื่อถือ
Java เป็นภาษาที่มีวัตถุบริสุทธิ์ - หมายถึงทุกสิ่งใน Java เป็นวัตถุหรือคลาส แนวคิดเช่นมรดก, บรรจุภัณฑ์, ความหลากหลายและบทคัดย่อถูกสร้างขึ้นเป็นภาษาอย่างสมบูรณ์ สิ่งนี้ช่วยให้ผู้เรียนเข้าถึงและฝึกฝนหลักการ OOP ได้อย่างง่ายดายในระหว่างการเขียนโปรแกรม
Java มีไวยากรณ์ที่ชัดเจนและง่ายต่อ -to -understand ไวยากรณ์ของ Java ขึ้นอยู่กับ C/C ++ แต่ได้ลบคุณสมบัติที่ซับซ้อนบางอย่างเช่นเคอร์เซอร์โดยตรงทำให้เป็นภาษาที่เหมาะสำหรับการสอนผู้เริ่มต้น การกำจัดคุณสมบัติที่ซับซ้อนเหล่านี้ช่วยให้ผู้เรียนมุ่งเน้นไปที่การทำความเข้าใจแนวคิดหลักของ OOP โดยไม่ต้องจมลงในรายละเอียดที่สับสน
Java เป็นรากฐานภาษาอิสระ สามารถทำงานบนระบบปฏิบัติการใด ๆ ด้วยเครื่องเสมือน Java (JVM) ซึ่งหมายความว่าโปรแกรม Java สามารถพัฒนาและนำไปใช้อย่างต่อเนื่องบนแพลตฟอร์มที่แตกต่างกันโดยไม่ต้องเปลี่ยนรหัส ความยืดหยุ่นนี้เหมาะสำหรับสภาพแวดล้อมการเรียนรู้ที่นักเรียนและครูสามารถใช้ฮาร์ดแวร์และซอฟต์แวร์ที่หลากหลาย
ในขณะที่ใช้การเก็บถาวรนี้เพื่อการเรียนรู้คุณควรทำตามหลักการจัดการที่กล่าวถึงด้านล่าง อ่านรายการตามกฎจากบนลงล่างส่วนแรกจะเป็นพื้นฐานของเนื้อหาถัดไป โดยเฉพาะอย่างยิ่งสำหรับ ภาคผนวกที่ คุณสามารถอ้างอิงได้ตลอดเวลามีหนังสือบางเล่มที่ฉันใช้สำหรับการออกแบบที่เก็บถาวรนี้
ในการซิงโครไนซ์และควบคุมง่ายเลเยอร์หลักมีวิธีหลักในการเรียกใช้รหัสเหมือนกับเนื้อหาบทเรียน ชั้นเรียนอื่น ๆ ในบทเรียนเพื่อแสดงให้เห็น ตัวอย่างเช่นบทเรียนเกี่ยวกับอินเทอร์เฟซอยู่ใน
Interface.javaมีคลาส:Movable,Trackable,Drone,Interface, การเคลื่อนMovable,Trackable,Droneคลาสโดรนมีผลของการตีความความรู้บทเรียนและคลาสInterfaceเพื่อเรียกใช้รหัสจากคลาสก่อนหน้า
รายการนี้เกือบจะเหมือนกับที่เก็บข้อมูลของฉัน: โครงสร้างข้อมูลและอัลกอริทึมโดยใช้ C/C ++ ยกเว้นที่เขียนด้วยภาษา Java จะมีความแตกต่างระหว่างสองภาษาผู้อ่านสามารถเปรียบเทียบได้เอง
Java เป็นทั้งภาษาการเขียนโปรแกรมและ การแปล (และ ตีความ ใน Java ซอร์สโค้ดถูกแปลเป็น bytecode ซึ่งเป็นตัวบ่งชี้ไบนารีที่ง่ายซึ่งทำงานเหมือนรหัสคอมพิวเตอร์สำหรับคอมพิวเตอร์อย่างไรก็ตามไม่เหมือนกับ C หรือ C ++
ไบต์นี้ได้รับการแปลและดำเนินการโดยเครื่องเสมือน Java ราวกับว่ามันเป็นรหัสเครื่องเนทีฟ JVM ทำงานเหมือนระบบปฏิบัติการที่ใช้งานอยู่ในการจัดการหน่วยความจำและคำสั่งการประมวลผลเพื่อให้มั่นใจถึงความปลอดภัยและมือถือของรหัส ลักษณะทั้งหมดของภาษา Java ถูกกำหนดไว้อย่างชัดเจนโดยไม่คำนึงถึงระบบเฉพาะของระบบพื้นฐานช่วยให้ Java สามารถทำงานเป็นเนื้อเดียวกันบนแพลตฟอร์มที่แตกต่างกันได้หลายแพลตฟอร์มโดยไม่ต้องแก้ไขรหัส
JVM จัดเตรียมสภาพแวดล้อมการบังคับใช้ที่ปลอดภัยซึ่งทำหน้าที่คล้ายกับระบบปฏิบัติการ มันจัดการหน่วยความจำการดำเนินการคำสั่งตามสแต็คและการประมวลผลประเภทน้ำ สิ่งนี้จะช่วยลดความเสี่ยงด้านความปลอดภัยและเพิ่มความเสถียรของแอปพลิเคชัน
ไม่ว่าจะดูคล้ายกับ C และ C ++ ในแง่ของไวยากรณ์ Java ไม่ใช่ลูกหลานโดยตรงของ C หรือ C ++ เวอร์ชันถัดไป Java มีความเหมือนกันกับภาษาไดนามิกเช่น Smalltalk และ Lisp มากกว่า C. ความคล้ายคลึงกันจะหยุดที่ไวยากรณ์ภายนอกเช่นใช้วงเล็บปีกกาและเครื่องหมายอัฒภาคจำนวนมาก Java สืบทอดปรัชญาของ C ของภาษาที่ดีที่ควรมีขนาดกะทัดรัดง่ายต่อการจดจำ แต่ขยายคำศัพท์ผ่านแพ็คเกจคลาส Java
ภาษาสคริปต์เช่น Perl, Python และ Ruby เป็นที่นิยมมากเพราะเหมาะสำหรับแอปพลิเคชันที่ปลอดภัยและเครือข่าย อย่างไรก็ตามภาษาสคริปต์ส่วนใหญ่ไม่ได้ออกแบบมาสำหรับการเขียนโปรแกรมขนาดใหญ่อย่างจริงจัง พวกเขามักจะไม่เหมาะสำหรับโครงการขนาดใหญ่หรือซับซ้อนเนื่องจากโครงสร้างโปรแกรมที่หลวมและระบบข้อมูลอย่างง่าย
Java เป็นแพลตฟอร์มที่ปลอดภัยในการพัฒนาเฟรมเวิร์กระดับที่สูงขึ้นและแม้แต่ภาษาอื่น ๆ การรวมความเรียบง่ายและคุณสมบัติของ Java ที่ช่วยให้การพัฒนาแอพพลิเคชั่นอย่างรวดเร็วและรวดเร็ว Java ยังได้เรียนรู้จากคุณสมบัติของ SmallTalk และปรับปรุงโดยเฉพาะอย่างยิ่งในการใช้ชุดทดสอบ bytecode เพื่อให้แน่ใจว่าความถูกต้องของรหัสแคมเปญช่วยปรับปรุงประสิทธิภาพและความปลอดภัยมากกว่า SmallTalk
Java ได้รับการออกแบบให้เป็นภาษาที่ปลอดภัยไม่เพียง แต่ต่อต้านข้อผิดพลาดของซอฟต์แวร์ แต่ยังรวมถึงปัญหาที่พบบ่อยในการออกแบบและการเขียนโปรแกรม Java เสนอเลเยอร์ป้องกันจำนวนมากจากการทดสอบความปลอดภัยของรหัสก่อนที่จะทำงานไปยังวิธีที่โหลดตัวโหลดคลาสซึ่งเป็นกลไกการโหลดไบต์ของการตีความ Java สร้าง "กำแพง" รอบคลาสที่ไม่น่าเชื่อถือ คุณสมบัติเหล่านี้เป็นรากฐานสำหรับนโยบายความปลอดภัยระดับสูงอนุญาตให้หรือไม่อนุญาตให้มีกิจกรรมประเภทต่าง ๆ ในแต่ละแอปพลิเคชัน
Java เริ่มต้นจาก "กระดานไวท์บอร์ด" และดังนั้นจึงสามารถหลีกเลี่ยงคุณสมบัติที่ซับซ้อนหรือเป็นที่ถกเถียงกันในภาษาอื่น ๆ ตัวอย่างเช่น Java ไม่อนุญาตให้โปรแกรมเมอร์สร้างใหม่ (เช่น + Hay -) ไม่มีเงินประมวลผลเงินเช่น Macros หรือ #Define งบสิ่งที่มักใช้ในภาษาอื่น ๆ เพื่อสนับสนุนการพึ่งพาบนแพลตฟอร์ม
Java ยังมีโครงสร้างแพ็คเกจที่ชัดเจนในการจัดระเบียบไฟล์คลาสช่วยให้กระบวนการรวบรวมสามารถจัดการกับฟังก์ชั่นบางอย่างของเครื่องมือ Make -Made แบบดั้งเดิมได้อย่างมีประสิทธิภาพ ข้อมูลชนิดข้อมูลทั้งหมดจะถูกเก็บรักษาไว้ในคลาส 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
วิธีการของวิธีการเริ่มต้นในตัวอักษรปกติเสมอและติดตาม camelcase ชื่อวิธีมักจะเป็นวลีคำกริยาหรือคำกริยาที่อธิบายถึงการกระทำที่วิธีการดำเนินการ ตัวอย่างเช่น: getName() , calculateTotalWidth()
ชื่อตัวแปรควรเริ่มต้นด้วยตัวอักษรปกติและตามด้วย camelcase ชื่อตัวแปรควรชัดเจนและอธิบายค่าที่เป็นตัวแทน ตัวอย่างเช่น: 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 + "]" ;
}
}| ข้อบ่งชี้การเข้าถึง | สาธารณะ | ได้รับการคุ้มครอง | ค่าเริ่มต้น | ส่วนตัว | |
|---|---|---|---|---|---|
| พร้อมกับแพ็คเกจ | ภายในชั้นเรียน | มี | มี | มี | มี |
| คลาสย่อย | มี | มี | มี | ไม่ใช่ | |
| ชั้นเรียนอื่น ๆ | มี | มี | มี | ไม่ใช่ | |
| แพ็คเกจที่แตกต่างกัน | คลาสย่อย | มี | มี | ไม่ใช่ | ไม่ใช่ |
| ชั้นเรียนอื่น ๆ | มี | ไม่ใช่ | ไม่ใช่ | ไม่ใช่ | |
Unified Modeling Language (UML) เป็นเครื่องมือสร้างแบบจำลองกราฟิกมาตรฐานออกแบบมาเพื่อร่างอธิบายและเอกสารเกี่ยวกับแง่มุมต่าง ๆ ของซอฟต์แวร์แอปพลิเคชัน มันมีประโยชน์อย่างยิ่งในสาขาการเขียนโปรแกรมเชิงวัตถุเนื่องจากเป็นวิธีที่ใช้งานง่ายในการแสดงคลาสวัตถุและความสัมพันธ์ระหว่างพวกเขา UML มีไดอะแกรมหลายประเภท แต่ในบริบทของการเขียนโปรแกรมเชิงวัตถุ -ไดอะแกรมคลาส (ไดอะแกรมคลาส) และไดอะแกรมแบบโต้ตอบ (ไดอะแกรมปฏิสัมพันธ์) เป็นสองประเภทที่ใช้กันมากที่สุด
UML ช่วยให้โปรแกรมเมอร์อธิบายโครงสร้างของระบบโดยใช้ไดอะแกรมคลาส แผนภาพนี้แสดงคลาสในระบบคุณลักษณะวิธีการและที่สำคัญที่สุดคือความสัมพันธ์ระหว่างคลาสเช่นการสืบทอดการเชื่อมโยงการสังเคราะห์และการรวมกัน สิ่งนี้ช่วยให้โปรแกรมเมอร์เข้าใจและออกแบบระบบอย่างเป็นระบบมากขึ้น
เมื่อแผนภาพ UML เสร็จสมบูรณ์แล้วจะสามารถใช้เป็นพื้นฐานสำหรับการเขียนซอร์สโค้ด ใน OOP การถ่ายโอนจากไดอะแกรมเลเยอร์ไปยังซอร์สโค้ด (โดยปกติแล้ว Java, C#หรือ C ++) ค่อนข้างตรงเนื่องจากความคล้ายคลึงกันระหว่างแนวคิดที่อธิบายไว้ใน UML และโครงสร้างเลเยอร์ในภาษาการเขียนโปรแกรมเหล่านี้
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 ;
}
} Symbols + , - และ # และ # และ # และชื่อวิธีในเลเยอร์หมายถึงระดับความสามารถในการเข้าถึงของแอตทริบิวต์และวิธีการ โดยเฉพาะ:
+ ระบุคุณลักษณะหรือวิธีการสาธารณะ (สาธารณะ)- ระบุคุณสมบัติหรือวิธีการเป็นส่วนตัว (ส่วนตัว)# หมายถึงคุณสมบัติหรือวิธีการป้องกัน (ป้องกัน)
Flyable ด้วยวิธี fly() คลาส Bird สามารถเรียกใช้อินเทอร์เฟซนี้ได้โดยการปรับใช้วิธี fly()School อาจมีวัตถุมากมายในชั้นเรียน Teacher แต่ครูยังคงเป็นอิสระจากโรงเรียนHouse อาจมีวัตถุมากมายใน Room เมื่อ House ถูกยกเลิก Room ก็จะถูกยกเลิก| มรดก | รวมตัว | |
|---|---|---|
| กำหนด | - การสืบทอดเป็นกลไกที่ชั้นหนึ่ง (เรียกว่า sub -layer) สามารถสืบทอดธรรมชาติและวิธีการของเลเยอร์อื่น (เรียกว่าคลาสแม่) - อนุญาตให้แผนกต่างๆนำรหัสของพ่อกลับมาใช้ใหม่โดยไม่ต้องเขียนใหม่ - สอดคล้องกับความสัมพันธ์ "IS-A" | - องค์ประกอบเป็นรูปแบบของความสัมพันธ์ "มี" ระหว่างสองชั้น - ระบุความสัมพันธ์ที่วัตถุอาจมีหรืออ้างถึงวัตถุอื่น ๆ แต่ทั้งสองวิชาอาจมีอยู่อย่างอิสระ - สอดคล้องกับความสัมพันธ์ "Have-A" |
| วัตถุประสงค์ | - นำรหัสกลับมาใช้ใหม่และปรับปรุงโมดูลของแอปพลิเคชัน - ยังสนับสนุน polymorphism ช่วยให้วิธีการของเด็กสามารถเขียนทับหรือขยายวิธีการของชั้นพาเรนต์ - ตัวอย่างเช่น: คลาสสัตว์มีวิธีการย้าย () ชั้นเรียนนกและปลาสามารถสืบทอดสัตว์และใช้หรือแทนที่วิธีการเคลื่อนไหว () เพื่อให้เหมาะกับธรรมชาติที่เคลื่อนไหวของพวกเขา | - แสดงถึงความสัมพันธ์ระหว่างวัตถุที่วัตถุอาจมีความสัมพันธ์บางส่วนซึ่งกันและกัน แต่ไม่ได้ขึ้นอยู่กับกันและกันอย่างสมบูรณ์ - ช่วยเพิ่มความยืดหยุ่นในโครงสร้างข้อมูลและจัดการวัตถุที่ซับซ้อน - ตัวอย่างเช่นเลเยอร์สี่เหลี่ยมอาจมีวัตถุของเลเยอร์จุด แต่ละตารางประกอบด้วยวัตถุสี่ชิ้นของเลเยอร์จุด (ระบุจุดยอด) แต่จุดอาจมีอยู่อย่างอิสระโดยไม่ต้องสูงสุดของสี่เหลี่ยมจัตุรัส |
| การพึ่งพาอาศัยกัน | - คลาสย่อยขึ้นอยู่กับชั้นเรียนของพ่ออย่างมากเพราะมันใช้คุณสมบัติและวิธีการของพ่อโดยตรง | - วิชาที่เกี่ยวข้องอาจมีอยู่อย่างอิสระ พวกเขาไม่ได้พึ่งพากันอย่างรุนแรง |
| ความสามารถ | - ขยายหรือปรับแต่งเลเยอร์ของพ่อ - การสร้างแบบจำลองความสัมพันธ์แบบกระจายอำนาจ | - จัดการวัตถุที่เกี่ยวข้อง - การสร้างแบบจำลองความสัมพันธ์ทางกายภาพ |
พิจารณาตัวอย่างต่อไปนี้:
การปรับใช้แผนภาพ UML นี้ใน Java มีดังนี้:
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
}
}
