Java เป็นภาษาโปรแกรมระดับสูงที่หลากหลายซึ่งเปิดตัวครั้งแรกในปี 1995 มีการใช้กันอย่างแพร่หลายในการพัฒนาแอปพลิเคชันมือถือ เว็บแอปพลิเคชัน และซอฟต์แวร์ระดับองค์กร Java ได้รับการออกแบบมาให้ไม่ขึ้นอยู่กับแพลตฟอร์ม ซึ่งหมายความว่าโค้ด Java สามารถทำงานบนอุปกรณ์หรือระบบปฏิบัติการใดๆ ที่ติดตั้ง Java Virtual Machine (JVM) ได้ ในบทความนี้ เราจะแนะนำคุณตลอดกระบวนการเชี่ยวชาญ Java ภายในเวลาเพียง 30 วัน
Java เป็นภาษาโปรแกรมยอดนิยมที่บริษัทขนาดใหญ่หลายแห่งใช้ ความเป็นอิสระของแพลตฟอร์มและความสามารถในการปรับขนาดทำให้เหมาะสำหรับการสร้างแอปพลิเคชันที่ซับซ้อน ลักษณะเชิงวัตถุทำให้การบำรุงรักษาโค้ดง่ายขึ้น นอกจากนี้ยังมีชุมชนนักพัฒนาจำนวนมากที่มีส่วนร่วมในโครงการโอเพ่นซอร์สและให้การสนับสนุนผู้เริ่มต้น
ตลอดระยะเวลา 30 วัน สิ่งนี้จะแนะนำคุณตลอดกระบวนการเชี่ยวชาญ Java เราจะครอบคลุมทุกอย่างตั้งแต่การตั้งค่าสภาพแวดล้อมการพัฒนาของคุณไปจนถึงหัวข้อขั้นสูง เช่น มัลติเธรดและการเขียนโปรแกรมเครือข่าย ในตอนท้ายของบทความนี้ คุณจะมีความเข้าใจอย่างถ่องแท้เกี่ยวกับ Java และทักษะที่จำเป็นในการสร้างแอปพลิเคชัน Java ของคุณเอง
วันที่ 1–5: การตั้งค่าสภาพแวดล้อมของคุณ
Java เป็นภาษาโปรแกรมยอดนิยมที่ใช้ในการสร้างแอปพลิเคชันที่หลากหลาย ตั้งแต่ซอฟต์แวร์เดสก์ท็อปไปจนถึงแอปพลิเคชันบนเว็บและแอปบนอุปกรณ์เคลื่อนที่ เพื่อเริ่มต้นการเดินทางสู่การเรียนรู้ Java อย่างเชี่ยวชาญ คุณต้องตั้งค่าสภาพแวดล้อมการพัฒนาก่อน ส่วนนี้จะแนะนำคุณตลอดกระบวนการตั้งค่าสภาพแวดล้อมของคุณในช่วงห้าวันแรก
การติดตั้งชุดพัฒนา Java (JDK)
ขั้นตอนแรกในการตั้งค่าสภาพแวดล้อม Java ของคุณคือการดาวน์โหลดและติดตั้ง Java Development Kit (JDK) JDK เป็นชุดเครื่องมือที่จำเป็นสำหรับการพัฒนาแอปพลิเคชัน Java คุณสามารถดาวน์โหลด JDK เวอร์ชันล่าสุดได้จากเว็บไซต์ทางการของ Oracle เมื่อคุณดาวน์โหลดตัวติดตั้ง JDK แล้ว ให้ทำตามตัวช่วยสร้างการติดตั้งเพื่อทำการติดตั้งให้เสร็จสมบูรณ์
การตั้งค่าสภาพแวดล้อมการพัฒนาแบบรวม (IDE)
Integrated Development Environment (IDE) คือแอปพลิเคชันซอฟต์แวร์ที่ให้สภาพแวดล้อมที่ครอบคลุมสำหรับการพัฒนา Java มี IDE ยอดนิยมหลายตัวสำหรับการพัฒนา Java รวมถึง Eclipse, IntelliJ IDEA และ NetBeans ในบทความนี้ เราจะใช้ Eclipse เป็น IDE ที่เราเลือก คุณสามารถดาวน์โหลด Eclipse ได้จากเว็บไซต์ Eclipse เมื่อคุณดาวน์โหลด Eclipse แล้ว ให้ทำตามวิซาร์ดการติดตั้งเพื่อทำการติดตั้งให้เสร็จสมบูรณ์
การสร้าง "สวัสดีชาวโลก!" ครั้งแรกของคุณ โปรแกรม
เมื่อคุณได้ตั้งค่าสภาพแวดล้อมการพัฒนาของคุณแล้ว ก็ถึงเวลาสร้างโปรแกรม Java แรกของคุณ ในภาษาชวา คำดั้งเดิม “สวัสดีชาวโลก!” โปรแกรมเป็นโปรแกรมง่ายๆ ที่แสดงข้อความ “Hello, World!” บนหน้าจอ. หากต้องการสร้างโปรแกรมนี้ ให้เปิด Eclipse และสร้างโปรเจ็กต์ Java ใหม่ จากนั้นสร้างคลาส Java ใหม่และป้อนโค้ดต่อไปนี้:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
เมื่อคุณป้อนรหัสนี้แล้ว ให้รันโปรแกรมเพื่อดูผลลัพธ์ “Hello, World!” พิมพ์ไปที่คอนโซล
ทำความเข้าใจเกี่ยวกับไวยากรณ์และโครงสร้างของ Java
Java เป็นภาษาโปรแกรมเชิงวัตถุระดับสูงที่อ่านและเขียนได้ง่าย มีไวยากรณ์ที่คล้ายกับภาษา C-style อื่นๆ เช่น C++ และ C# โค้ด Java ถูกคอมไพล์เป็น bytecode ที่สามารถดำเนินการบนแพลตฟอร์มใดๆ ที่ติดตั้ง Java Virtual Machine (JVM) การทำความเข้าใจไวยากรณ์และโครงสร้างของ Java มีความสำคัญอย่างยิ่งต่อการเป็นนักพัฒนา Java ที่เชี่ยวชาญ
นี่คือตัวอย่างโค้ดใน Java ที่สาธิตไวยากรณ์และโครงสร้างของภาษาพื้นฐานบางส่วน:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
ในข้อมูลโค้ดนี้ เรากำหนดคลาสที่เรียกว่า HelloWorld คีย์เวิร์ด public บ่งบอกว่าคลาสนี้สามารถเข้าถึงได้จากคลาสอื่น เครื่องหมายปีกกา {} ล้อมรอบเนื้อหาของคลาส
ภายในชั้นเรียน เรากำหนดวิธีการ main นี่คือจุดเริ่มต้นสำหรับโปรแกรมของเราและเป็นวิธีแรกที่ถูกดำเนินการเมื่อเรารันโค้ดของเรา คำหลัก public static ระบุว่าวิธีนี้สามารถเข้าถึงได้จากภายนอกชั้นเรียน และไม่จำเป็นต้องสร้างอินสแตนซ์ของชั้นเรียนก่อนจึงจะสามารถเรียกได้ พารามิเตอร์ String[] args คืออาร์เรย์ของสตริงที่สามารถส่งผ่านไปยังเมธอดได้เมื่อมีการเรียกใช้
ภายในเมธอด main เราใช้เมธอด System.out.println เพื่อพิมพ์สตริง 'Hello, World!' ไปที่คอนโซล เมธอด println เป็นสมาชิกของออบเจ็กต์ System.out ซึ่งแสดงถึงสตรีมเอาต์พุตมาตรฐาน
วันที่ 6–10: ประเภทข้อมูลและตัวดำเนินการ
ตอนนี้เมื่อคุณมีความเข้าใจพื้นฐานเกี่ยวกับวิธีการตั้งค่าสภาพแวดล้อมการพัฒนาของคุณและเขียนโปรแกรม Java แบบง่ายๆ แล้ว ก็ถึงเวลาที่จะเจาะลึกลงไปในภาษานี้ ในส่วนนี้ เราจะกล่าวถึงพื้นฐานของประเภทข้อมูลและตัวดำเนินการใน Java
รู้เบื้องต้นเกี่ยวกับชนิดข้อมูลใน Java
ตัวแปรทุกตัวใน Java มีประเภทข้อมูลซึ่งกำหนดขนาดและประเภทของค่าที่สามารถเก็บได้ Java มีประเภทข้อมูลหลักสองประเภท: ประเภทดั้งเดิมและประเภทอ้างอิง ประเภทดั้งเดิมเป็นหน่วยการสร้างพื้นฐานของ Java และรวมถึง:
- บูลีน: แสดงถึงค่าจริงหรือเท็จ
- ไบต์: จำนวนเต็ม 8 บิต
- short: จำนวนเต็ม 16 บิต
- int: จำนวนเต็ม 32 บิต
- long: จำนวนเต็ม 64 บิต
- float: จำนวนจุดลอยตัวที่มีความแม่นยำเพียงตัวเดียว
- double: จำนวนจุดลอยตัวที่มีความแม่นยำสองเท่า
- ถ่าน: อักขระ Unicode ตัวเดียว
ในทางกลับกัน ประเภทการอ้างอิงจะรวมถึงอ็อบเจ็กต์ อาร์เรย์ และคลาส
การทำงานกับตัวเลข — จำนวนเต็ม จำนวนทศนิยม และจำนวนคู่
Java ให้การสนับสนุนการทำงานกับตัวเลขประเภทต่างๆ รวมถึงจำนวนเต็ม จำนวนทศนิยม และจำนวนคู่ จำนวนเต็มเป็นตัวเลขจำนวนเต็มที่ไม่มีจุดทศนิยม ในขณะที่ทศนิยมและสองเท่าเป็นตัวเลขที่มีจุดทศนิยม
นี่คือตัวอย่างของการประกาศและการเริ่มต้นตัวแปรของข้อมูลตัวเลขประเภทต่างๆ:
int age = 32; // Integer (whole number) float weight = 68.5f; // Float double height = 1.75; // Double - float without 'f'
โปรดทราบว่าเมื่อประกาศตัวแปร float คุณต้องเติม "f" ต่อท้ายค่าเพื่อระบุว่าเป็นตัวแปร float
การทำงานกับอักขระและสตริง
อักขระและสตริงยังเป็นประเภทข้อมูลที่สำคัญใน Java อักขระคืออักขระ Unicode ตัวเดียว ในขณะที่สตริงคือลำดับอักขระ
นี่คือตัวอย่างของการประกาศและการเริ่มต้นตัวแปรประเภทถ่านและสตริง:
char gender = 'M'; // Character uses single quotes String name = "John"; // String uses double quotes
การทำงานกับบูลีน
Booleans เป็นประเภทข้อมูลที่เรียบง่ายแต่ทรงพลังใน Java ซึ่งสามารถแสดงค่าได้เพียงสองค่าเท่านั้น: จริงและเท็จ มักใช้ในคำสั่งและลูปแบบมีเงื่อนไข
นี่คือตัวอย่างของการประกาศและการเริ่มต้นตัวแปรบูลีน:
boolean isStudent = true; // Boolean values are lowercase and are not wrapped in any quotation marks
ทำความเข้าใจกับตัวดำเนินการทางคณิตศาสตร์และการกำหนด
ใน Java คุณสามารถดำเนินการทางคณิตศาสตร์ได้โดยใช้ตัวดำเนินการต่อไปนี้:
+(เพิ่มเติม)-(ลบ)*(การคูณ)/(ฝ่าย)%(โมดูลัส)
คุณยังสามารถใช้ตัวดำเนินการกำหนดเพื่อกำหนดค่าให้กับตัวแปรและดำเนินการทางคณิตศาสตร์ในเวลาเดียวกันได้ ตัวอย่างเช่น:
int x = 5; x = x + 2; // This is the same as the line above x += 2;
ถึงตอนนี้ คุณควรมีความเข้าใจที่ชัดเจนเกี่ยวกับประเภทข้อมูลพื้นฐานและตัวดำเนินการใน Java ในส่วนถัดไป เราจะพูดถึงโครงสร้างการควบคุม ซึ่งจำเป็นสำหรับการตัดสินใจและการดำเนินการซ้ำในโปรแกรมของคุณ
วันที่ 11–15: คำสั่งควบคุมและลูป
ในส่วนนี้ เราจะเจาะลึกลงไปในคำสั่งควบคุมและลูปใน Java คำสั่งควบคุมคือคำสั่งที่กำหนดขั้นตอนการทำงานของโปรแกรม ในขณะที่ลูปถูกใช้เพื่อรันบล็อกโค้ดซ้ำๆ ในตอนท้ายของส่วนนี้ คุณจะมีความเข้าใจที่ดีเกี่ยวกับวิธีการใช้คำสั่งควบคุมและลูปในโปรแกรม Java ของคุณ
การใช้คำสั่ง if-else
คำสั่ง If-else ใช้ในการตัดสินใจในโปรแกรม Java อนุญาตให้คุณดำเนินการบล็อกโค้ดบางบล็อกหากเงื่อนไขเป็นจริง และบล็อกโค้ดอื่นหากเงื่อนไขเป็นเท็จ นี่คือตัวอย่างของคำสั่ง if-else:
// Initialise a variable
int x = 5;
// Execute a block of code based on the variable's condition
// If variable 'x' is less than 10
if (x < 10) {
System.out.println("x is less than 10");
// If variable 'x' is greater than or equal to 10
} else {
System.out.println("x is greater than or equal to 10");
}
// Output: x is less than 10
การทำงานกับคำสั่งสวิตช์
คำสั่ง Switch เป็นอีกวิธีหนึ่งในการตัดสินใจในโปรแกรม Java มักใช้เมื่อมีหลายกรณีที่ต้องพิจารณา นี่คือตัวอย่างของคำสั่ง switch:
// Initialise a variable
int day = 3;
// Execute a block of code based on the variable's condition
switch (day) {
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
case 3:
System.out.println("Wednesday");
break;
default:
System.out.println("Invalid day");
break;
}
// Output: Wednesday
การใช้ for, while และ do- While Loop
ลูปใช้เพื่อดำเนินการบล็อกโค้ดซ้ำ ๆ Java มีลูปสามประเภท: for, while และ do- While for loop ถูกใช้เมื่อคุณทราบจำนวนครั้งที่คุณต้องการดำเนินการบล็อกของโค้ด while loop ถูกใช้เมื่อคุณต้องการรันบล็อคโค้ดในขณะที่เงื่อนไขบางอย่างเป็นจริง do- While loop นั้นคล้ายคลึงกับ while loop แต่จะรันบล็อกของโค้ดอย่างน้อยหนึ่งครั้งเสมอ นี่คือตัวอย่างของการวนซ้ำแต่ละประเภท:
// for loop
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
// while loop
int j = 0;
while (j < 5) {
System.out.println(j);
j++;
}
// do-while loop
int k = 0;
do {
System.out.println(k);
k++;
} while (k < 5);
การทำงานกับคำสั่งแบ่งและดำเนินการต่อ
คำสั่งแบ่งและดำเนินการต่อใช้เพื่อเปลี่ยนการไหลของลูป คำสั่ง break ใช้เพื่อยุติการวนซ้ำก่อนกำหนด ในขณะที่คำสั่ง Continue ใช้เพื่อข้ามการวนซ้ำปัจจุบันของลูปและไปยังคำสั่งถัดไป นี่คือตัวอย่างของแต่ละข้อความ:
// Counter starts at 0 and ends at 5
for (int i = 0; i < 5; i++) {
// If 'i' is equal to 3, skip the rest of the current iteration
if (i == 3) {
continue;
}
System.out.println(i);
// If 'i' is equal to 4, break out of the for loop
if (i == 4) {
break;
}
}
ด้วยความรู้ที่ได้รับจากส่วนนี้ ตอนนี้คุณมีความเข้าใจเกี่ยวกับวิธีการใช้คำสั่งควบคุมและลูปใน Java เป็นอย่างดี
วันที่ 16–20: วิธีการและชั้นเรียน
ยินดีต้อนรับสู่สัปดาห์ที่สี่ของการท้าทาย Java 30 วัน! ในส่วนนี้ เราจะกล่าวถึงแนวคิดที่สำคัญของวิธีการและคลาสต่างๆ มาดำดิ่งกัน
การกำหนดและวิธีการเรียก
ใน Java วิธีการคือชุดของคำสั่งที่ทำงานเฉพาะ เป็นบล็อกโค้ดที่ใช้ซ้ำได้ซึ่งสามารถเรียกได้จากทุกที่ในโปรแกรม เรากำหนดวิธีการโดยใช้คีย์เวิร์ด “void” สำหรับวิธีที่ไม่ส่งคืนค่า หรือประเภทข้อมูลสำหรับวิธีที่ส่งคืนค่า ในส่วนนี้ คุณจะได้เรียนรู้วิธีกำหนดและเรียกใช้เมธอดใน Java
ต่อไปนี้เป็นตัวอย่างของการกำหนดวิธีการที่รับจำนวนเต็มสองตัวแล้วส่งคืนผลรวม จากนั้นจึงเรียกเมธอดนั้น:
public class Calculator {
public static void main(String[] args) {
// Initialise variables
int a = 5;
int b = 7;
// Call function with two arguments and stores the result in a variable
int sum = addNumbers(a, b);
System.out.println("The sum of " + a + " and " + b + " is " + sum); // Output: The sum of 5 and 7 is 12
}
// Defines the function that's called in the main function that takes two parameters
public static int addNumbers(int x, int y) {
// Stores the sum of parameters 'x' and 'y' in a variable
int sum = x + y;
// Returns the variable
return sum;
}
}
ในตัวอย่างนี้ เรากำหนดวิธีการที่เรียกว่า addNumbers ซึ่งรับจำนวนเต็มสองตัว (x และ y) แล้วส่งคืนผลรวม จากนั้นเราจะเรียกเมธอดนี้จากเมธอด main และส่งผ่านค่า a และ b เป็นอาร์กิวเมนต์ เมธอด addNumbers จะบวกตัวเลขทั้งสองนี้เข้าด้วยกันและส่งกลับผลลัพธ์ซึ่งจัดเก็บไว้ในตัวแปร sum สุดท้ายนี้ เราจะพิมพ์ข้อความไปยังคอนโซลที่แสดงค่าดั้งเดิมของ a และ b รวมถึงผลรวมของค่าเหล่านั้น
ทำความเข้าใจกับอาร์กิวเมนต์ของวิธีการและประเภทการส่งคืน
เมธอด Java สามารถรับพารามิเตอร์ซึ่งเป็นตัวแปรที่ถูกส่งผ่านเป็นอาร์กิวเมนต์เมื่อเรียกใช้เมธอด นอกจากนี้เรายังสามารถระบุประเภทการส่งคืนสำหรับวิธีการ ซึ่งเป็นประเภทข้อมูลของค่าที่วิธีการจะส่งคืนหลังจากดำเนินการ การทำความเข้าใจอาร์กิวเมนต์ของวิธีการและประเภทการส่งคืนเป็นสิ่งสำคัญสำหรับการเขียนโค้ดที่มีประสิทธิภาพและบำรุงรักษาได้
นี่คือตัวอย่างโค้ดที่แสดงให้เห็นถึงอาร์กิวเมนต์ของวิธีการและประเภทการส่งคืน:
public class Calculator {
public static void main(String[] args) {
// Initialise variables
int num1 = 10;
int num2 = 5;
// Calls functions, each with the two variables as arguments, and stores them in new respective variables
int sum = add(num1, num2);
int difference = subtract(num1, num2);
int product = multiply(num1, num2);
int quotient = divide(num1, num2);
System.out.println("Sum: " + sum); // Output: Sum: 15
System.out.println("Difference: " + difference); // Output: Difference: 5
System.out.println("Product: " + product); // Output: Product: 50
System.out.println("Quotient: " + quotient); // Output: Quotient: 2
}
// Defines function "add" to return the sum of two numbers
public static int add(int num1, int num2) {
return num1 + num2;
}
// Defines function "subtract" to return the difference of two numbers
public static int subtract(int num1, int num2) {
return num1 - num2;
}
// Defines function "multiply" to return the product of two numbers
public static int multiply(int num1, int num2) {
return num1 * num2;
}
// Defines function "divide" to return the division of two numbers
public static int divide(int num1, int num2) {
return num1 / num2;
}
}
ในโค้ดข้างต้น เราได้กำหนดไว้สี่วิธี — add(), subtract(), multiply() และ divide() วิธีการเหล่านี้รับอาร์กิวเมนต์จำนวนเต็มสองตัวและส่งกลับค่าจำนวนเต็ม ในเมธอด main() เราเรียกเมธอดเหล่านี้และเก็บค่าที่ส่งคืนไว้ในตัวแปร สุดท้าย เราจะพิมพ์ค่าของตัวแปรเหล่านี้โดยใช้วิธี System.out.println()
การทำงานกับวิธีการในตัวและวิธีการที่ผู้ใช้กำหนด
Java มีวิธีการในตัวมากมายที่เราสามารถใช้เพื่อทำงานต่างๆ ตัวอย่างเช่น คลาส “Math” จัดเตรียมวิธีการสำหรับการดำเนินการทางคณิตศาสตร์ ในขณะที่คลาส “String” จัดเตรียมวิธีการสำหรับการจัดการสตริง นอกเหนือจากการใช้วิธีการในตัวแล้ว เรายังสามารถกำหนดวิธีการของเราเองเพื่อดำเนินงานที่กำหนดเองได้
นี่คือตัวอย่าง:
public class Example {
public static void main(String[] args) {
// Initialise a double variable
double x = 5.0;
// Built-in Math class: square root (sqrt) method
double y = Math.sqrt(x);
System.out.println("The square root of " + x + " is " + y);
// Output: The square root of 5.0 is 2.23606797749979
// Initialise a string variable
String message = "Hello, world!";
// Built-in String class: length method (number of characters in the string)
int length = message.length();
System.out.println("The length of the message is " + length);
// Output: The length of the message is 13
// Initialise two int variables
int a = 10;
int b = 20;
// User-defined method: addition function
int sum = addNumbers(a, b);
System.out.println("The sum of " + a + " and " + b + " is " + sum);
// Output: The sum of 10 and 20 is 30
}
// Definition of addition function that returns the sum of two parameters
public static int addNumbers(int num1, int num2) {
int sum = num1 + num2;
return sum;
}
}
ในข้อมูลโค้ดนี้ ขั้นแรกเราใช้เมธอด sqrt จากคลาส Math ในตัวเพื่อค้นหารากที่สองของ x จากนั้น เราใช้วิธี length จากคลาส String ในตัวเพื่อค้นหาความยาวของสตริง message
สุดท้ายนี้ เรากำหนดวิธีการของเราเองที่เรียกว่า addNumbers ซึ่งรับอาร์กิวเมนต์จำนวนเต็มสองตัวและส่งกลับผลรวม เราเรียกวิธีนี้และพิมพ์ผลลัพธ์
ทำความเข้าใจเกี่ยวกับคลาสและออบเจ็กต์
คลาสคือพิมพ์เขียวหรือเทมเพลตสำหรับการสร้างวัตถุ วัตถุเป็นตัวอย่างของคลาสที่มีสถานะและพฤติกรรมเฉพาะของตัวเอง ใน Java เราใช้คลาสเพื่อสรุปข้อมูลและพฤติกรรมให้เป็นเอนทิตีเดียว การทำความเข้าใจคลาสและอ็อบเจ็กต์เป็นแนวคิดพื้นฐานในการเขียนโปรแกรมเชิงวัตถุ
นี่คือตัวอย่างโค้ดที่สาธิตการสร้างคลาสและออบเจ็กต์:
public class Car {
// Class fields
private String make;
private String model;
private int year;
// Class constructor
public Car(String make, String model, int year) {
this.make = make;
this.model = model;
this.year = year;
}
// Class method
public void startEngine() {
System.out.println("The " + make + " " + model + " is starting.");
}
}
public class Main {
public static void main(String[] args) {
// Creates an object of Car class
Car myCar = new Car("Toyota", "Camry", 2022);
// Calls the startEngine() method of the Car object
myCar.startEngine();
}
}
ในตัวอย่างนี้ เราได้กำหนดคลาสชื่อ Car โดยมีสามฟิลด์: make, model และ year นอกจากนี้เรายังกำหนด Constructor ที่จะรับค่าสำหรับฟิลด์เหล่านี้ เช่นเดียวกับเมธอดที่เรียกว่า startEngine() ที่จะพิมพ์ข้อความที่ระบุว่ารถกำลังสตาร์ท
ในคลาส Main เราได้สร้างอ็อบเจ็กต์ของคลาส Car ชื่อ myCar โดยส่งผ่านค่าสำหรับฟิลด์โดยใช้ตัวสร้าง จากนั้นเราได้เรียกเมธอด startEngine บนอ็อบเจ็กต์นี้ ซึ่งส่งข้อความไปยังคอนโซล
การทำงานกับตัวสร้างและตัวทำลาย
ตัวสร้างเป็นวิธีการพิเศษที่ถูกเรียกเมื่อมีการสร้างวัตถุ ใช้เพื่อเริ่มต้นสถานะของวัตถุ ใน Java ตัวสร้างมีชื่อเดียวกันกับคลาสและไม่มีประเภทการส่งคืน ในทางกลับกัน destructors ไม่มีอยู่ใน Java แต่ Java ให้การจัดการหน่วยความจำอัตโนมัติผ่านตัวรวบรวมขยะแทน
นี่คือตัวอย่างของคลาสที่เราใช้กับ Constructor และ Destructor ด้านบน:
public class Car {
// Class fields
public Car(String make, String model, int year) {
// Fields initialised
System.out.println("A new car has been created.");
}
// Class method
public void drive() {
System.out.println("The " + year + " " + make + " " + model + " is driving.");
}
// Class method
public void finalize() {
System.out.println("The " + year + " " + make + " " + model + " is being destroyed.");
}
}
ในตัวอย่างนี้ คลาส Car มีตัวสร้างที่รับพารามิเตอร์สามตัว: make, model และ year เมื่อสร้างอ็อบเจ็กต์ Car ใหม่ด้วยพารามิเตอร์เหล่านี้ ตัวสร้างจะเริ่มต้นคุณสมบัติ make, model และ year ของอ็อบเจ็กต์ และพิมพ์ข้อความไปยังคอนโซล
คลาส Car ยังมีวิธี drive ที่พิมพ์ข้อความระบุว่ารถยนต์กำลังขับอยู่ ในที่สุด คลาสก็มีเมธอด destructor finalize ที่พิมพ์ข้อความที่ระบุว่ารถกำลังถูกทำลาย โปรดทราบว่าเมธอด finalize จะถูกเรียกโดยอัตโนมัติโดยตัวรวบรวมขยะของ Java เมื่อไม่มีการใช้งานอ็อบเจ็กต์อีกต่อไป
นี่คือตัวอย่างของการสร้างวัตถุ Car ใหม่และเรียกใช้เมธอด drive:
Car myCar = new Car("Toyota", "Camry", 2021); // Output: A new car has been created.
myCar.drive(); // Output: The 2021 Toyota Camry is driving.
รหัสนี้จะสร้างอ็อบเจ็กต์ Car ใหม่ด้วย make 'Toyota', model 'Camry' และ year 2021 จากนั้น จะเรียกใช้เมธอด drive บนอ็อบเจ็กต์นี้ ซึ่งพิมพ์ ข้อความระบุว่ารถกำลังขับอยู่ เมื่อโปรแกรมสิ้นสุดและวัตถุ Car ไม่ได้ใช้งานอีกต่อไป เมธอด finalize จะถูกเรียกใช้ ซึ่งจะพิมพ์ข้อความระบุว่ารถกำลังถูกทำลาย
วันที่ 21–25: การเขียนโปรแกรมเชิงวัตถุ (OOP) ใน Java
Java เป็นภาษาการเขียนโปรแกรมเชิงวัตถุยอดนิยมที่ใช้แนวคิด OOP เพื่อสร้างโค้ดที่แข็งแกร่งและสามารถนำมาใช้ซ้ำได้ ในส่วนนี้ เราจะกล่าวถึงพื้นฐานของ OOP ใน Java
รู้เบื้องต้นเกี่ยวกับแนวคิด OOP ใน Java
การเขียนโปรแกรมเชิงวัตถุเป็นกระบวนทัศน์การเขียนโปรแกรมที่มีพื้นฐานอยู่บนแนวคิดของ "วัตถุ" ซึ่งสามารถประกอบด้วยข้อมูลและวิธีการได้ Java เป็นภาษาเชิงวัตถุและช่วยให้คุณสร้างคลาสและวัตถุได้
คุณสามารถอ่านเพิ่มเติมเกี่ยวกับแนวคิด OOP ได้ในบทความอื่นของฉัน ซึ่งฉันเจาะลึก:
การทำงานกับมรดกและความหลากหลาย
การสืบทอดเป็นกลไกที่ช่วยให้คุณสามารถสร้างคลาสใหม่ตามคลาสที่มีอยู่ คลาสใหม่ที่เรียกว่าคลาสย่อยจะสืบทอดคุณสมบัติและวิธีการทั้งหมดของคลาสที่มีอยู่ซึ่งเรียกว่าซูเปอร์คลาส Polymorphism ช่วยให้คุณสามารถใช้วัตถุคลาสย่อยราวกับว่ามันเป็นวัตถุซุปเปอร์คลาส
นี่คือตัวอย่างโค้ดที่แสดงให้เห็นถึงการสืบทอดและความหลากหลาย:
// Parent class
class Vehicle {
void drive() {
System.out.println("Driving a vehicle");
}
}
// Child class inheriting from parent class (Vehicle)
class Car extends Vehicle {
void drive() {
System.out.println("Driving a car");
}
}
// Child class inheriting from parent class (Vehicle)
class Motorcycle extends Vehicle {
void drive() {
System.out.println("Riding a motorcycle");
}
}
// Main method
public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
Vehicle car = new Car();
Vehicle motorcycle = new Motorcycle();
vehicle.drive(); // Output: Driving a vehicle
car.drive(); // Output: Driving a car
motorcycle.drive(); // Output: Riding a motorcycle
}
ในตัวอย่างนี้ เรามีคลาสพาเรนต์/ซูเปอร์คลาส Vehicle และคลาสย่อย/คลาสย่อยสองคลาส Car และ Motorcycle ที่สืบทอดมาจากคลาสพาเรนต์ เมธอด drive() ถูกกำหนดไว้ในคลาสพาเรนต์ และถูกแทนที่ในคลาสย่อยทั้งสองคลาสด้วยการใช้งานเฉพาะของตัวเอง ในคลาส Main เราสร้างอินสแตนซ์ของแต่ละคลาสและเรียกใช้เมธอด drive() ในแต่ละคลาส เนื่องจาก car และ motorcycle ได้รับการประกาศเป็นประเภท Vehicle แต่สร้างอินสแตนซ์เป็น Car และ Motorcycle ตามลำดับ การใช้งานที่ถูกต้องของ drive() ถูกเรียกตามประเภทอ็อบเจ็กต์ขณะรันไทม์ พวกเขาแต่ละคนเรียกเมธอดเวอร์ชันของตัวเอง โดยเอาชนะเมธอดของซูเปอร์คลาส และแสดงให้เห็นถึงความหลากหลาย
การห่อหุ้มและการสรุปข้อมูลใน Java
การห่อหุ้มเป็นกระบวนการซ่อนรายละเอียดการใช้งานของคลาสจากโลกภายนอก และจัดเตรียมอินเทอร์เฟซสาธารณะสำหรับการโต้ตอบกับคลาส Data Abstraction เป็นกระบวนการซ่อนรายละเอียดการใช้งานข้อมูลและแสดงเฉพาะฟังก์ชันการทำงานให้กับผู้ใช้เท่านั้น
นี่คือตัวอย่างโค้ดที่สาธิตการห่อหุ้มและการสรุปข้อมูล:
public class BankAccount {
// Private fields
private double balance;
private String accountNumber;
// Class constructor
public BankAccount(double balance, String accountNumber) {
this.balance = balance;
this.accountNumber = accountNumber;
}
// Public method (getter)
public double getBalance() {
return balance;
}
// Public method (setter)
public void deposit(double amount) {
balance += amount;
}
// Public method (modifier)
public void withdraw(double amount) {
if (balance >= amount) {
balance -= amount;
} else {
System.out.println("Insufficient funds.");
}
}
}
ในตัวอย่างนี้ เรามีคลาส BankAccount ที่มีตัวแปรอินสแตนซ์ส่วนตัว balance และ accountNumber ตัวแปร balance ถูกห่อหุ้มและสามารถเข้าถึงได้โดยใช้เมธอด getter และ setter เท่านั้น ซึ่งช่วยรักษาความสมบูรณ์ของข้อมูลและความปลอดภัยโดยป้องกันการเข้าถึงสถานะภายในของออบเจ็กต์โดยไม่ได้รับอนุญาต
เมธอด deposit และ withdraw อนุญาตให้มีการแก้ไขตัวแปร balance ในขณะเดียวกันก็บังคับใช้ตรรกะทางธุรกิจด้วย เช่น การตรวจสอบให้แน่ใจว่าบัญชีมีเงินทุนเพียงพอก่อนที่จะอนุญาตให้ถอนเงินได้
ด้วยการห่อหุ้มตัวแปร balance และจัดเตรียมวิธีการสาธารณะเพื่อโต้ตอบกับตัวแปร เรากำลังสรุปรายละเอียดการใช้งานของคลาส BankAccount และจัดเตรียมอินเทอร์เฟซที่เรียบง่ายสำหรับโค้ดอื่น ๆ ที่จะใช้ นี่คือตัวอย่างข้อมูลที่เป็นนามธรรม
การจัดการข้อยกเว้นใน OOP
การจัดการข้อยกเว้นเป็นกลไกที่ช่วยให้คุณจัดการกับข้อผิดพลาดที่เกิดขึ้นระหว่างการทำงานของโปรแกรม ใน Java ข้อยกเว้นคืออ็อบเจ็กต์ที่ถูกส่งออกมาเมื่อมีข้อผิดพลาดเกิดขึ้น คุณสามารถใช้บล็อก try-catch เพื่อจัดการกับข้อยกเว้น
นี่คือตัวอย่างโค้ดสำหรับการจัดการข้อยกเว้น:
public class Example {
public static void main(String[] args) {
try {
// Try block for code that might throw an exception
int[] numbers = {1, 2, 3};
System.out.println(numbers[10]);
} catch (ArrayIndexOutOfBoundsException e) {
// Catch block to handle an ArrayIndexOutOfBoundsException error
System.out.println("An error occurred: " + e.getMessage());
} finally {
// Finally block for optional code that will always run, regardless of whether an exception was thrown or caught
System.out.println("This code block will always execute.");
}
}
}
ในตัวอย่างนี้ เราสร้างอาร์เรย์ของจำนวนเต็มที่เรียกว่า numbers แต่จากนั้นพยายามพิมพ์ค่าในดัชนีที่ไม่มีอยู่ (numbers[10]) ซึ่งจะส่งผลให้มีการโยน ArrayIndexOutOfBoundsException
เพื่อจัดการกับข้อยกเว้นนี้ เราใช้บล็อก try-catch รหัสภายในบล็อก try คือรหัสที่เราต้องการเรียกใช้ แต่อาจทำให้เกิดข้อยกเว้น หากมีข้อยกเว้นเกิดขึ้น โค้ดภายในบล็อก catch ที่เกี่ยวข้องจะถูกดำเนินการแทน ในกรณีนี้ เราจะพิมพ์ข้อความแสดงข้อผิดพลาดที่มีข้อความข้อยกเว้นด้วย
สุดท้ายนี้ บล็อก finally ใช้เพื่อรันโค้ดที่ควรรันอยู่เสมอ ไม่ว่าจะมีข้อยกเว้นเกิดขึ้นหรือไม่ก็ตาม ในตัวอย่างนี้ เราพิมพ์ข้อความที่ระบุว่าบล็อกนี้จะดำเนินการอยู่เสมอ
ทำความเข้าใจเกี่ยวกับอินเทอร์เฟซและคลาสนามธรรม
อินเทอร์เฟซเป็นวิธีกำหนดสัญญาที่คลาสต้องใช้ อินเทอร์เฟซคือชุดของวิธีการเชิงนามธรรมที่คลาสต้องใช้ คลาสนามธรรมเป็นคลาสที่ไม่สามารถสร้างอินสแตนซ์ได้และใช้เป็นคลาสพื้นฐานสำหรับคลาสอื่น
นี่คือตัวอย่างโค้ดที่สาธิตการใช้อินเทอร์เฟซและคลาสนามธรรม:
// Interface for a Shape
interface Shape {
void draw(); // Method signature for drawing the shape
}
// Abstract class for an Animal
abstract class Animal {
// Fields
String name;
int age;
// Abstract class constructor
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
// Abstract method for making a sound
abstract void makeSound();
}
// Concrete class that implements the interface and extends the abstract class
class Circle extends Animal implements Shape {
// Extra field for the Circle
double radius;
// Class constructor
public Circle(String name, int age, double radius) {
// Calls super() to initialise inherited fields
super(name, age);
this.radius = radius;
}
// Implementation of the makeSound() method of the Animal abstract class
@Override
public void makeSound() {
System.out.println("The circle makes no sound.");
}
// Implementation of the draw() method of the Shape interface
@Override
public void draw() {
System.out.println("Drawing a circle with radius " + radius);
}
}
// Usage of interface and abstract class
public class Main {
public static void main(String[] args) {
// Creating an instance of the Circle class
Circle circle = new Circle("Circe", 5, 10.0);
// Calling the makeSound() method of the Animal abstract class
circle.makeSound(); // Output: The circle makes no sound.
// Calling the draw() method of the Shape interface
circle.draw(); // Output: Drawing a circle with radius 10.0
}
}
ในตัวอย่างนี้ เรากำหนดอินเทอร์เฟซ Shape ที่มีเมธอดเดียว draw() นอกจากนี้เรายังกำหนดคลาสนามธรรม Animal ที่มีตัวสร้างและวิธีการนามธรรม makeSound() จากนั้นเรากำหนดคลาสที่เป็นรูปธรรม Circle ที่ใช้ Shape และขยาย Animal Circle มีตัวสร้างที่รับอาร์กิวเมนต์สำหรับ name, age และ radius และใช้ makeSound() และ draw() วิธีการ สุดท้ายนี้ เราสร้างอินสแตนซ์ของวัตถุ Circle ในคลาส Main และเรียกใช้เมธอด makeSound() และ draw() ของมัน
วันที่ 26–30: หัวข้อขั้นสูงใน Java
ในส่วนนี้ เราจะพูดถึงหัวข้อขั้นสูงใน Java ที่จะยกระดับทักษะการเขียนโปรแกรมของคุณไปอีกระดับ
การทำงานกับคอลเลกชันและข้อมูลทั่วไป
Java Collections Framework จัดเตรียมชุดอินเทอร์เฟซและคลาสสำหรับการจัดการและจัดการกลุ่มของอ็อบเจ็กต์ Generics จัดเตรียมวิธีการกำหนดคลาส อินเทอร์เฟซ และเมธอดที่สามารถทำงานกับข้อมูลประเภทใดก็ได้
นี่คือตัวอย่างโค้ดที่สาธิตการใช้คอลเลกชันและข้อมูลทั่วไป:
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
// Initialise a collection 'ArrayList'
List<String> list = new ArrayList<String>();
// Add elements to the array list
list.add("apple");
list.add("banana");
list.add("orange");
// Print each item in 'list' through a for loop
for (String item : list) {
System.out.println(item);
}
}
}
ในตัวอย่างนี้ เราใช้คลาส ArrayList ซึ่งเป็นคอลเลกชันประเภทหนึ่งที่ช่วยให้เราสามารถจัดเก็บรายการแบบไดนามิกได้ นอกจากนี้เรายังใช้ข้อมูลทั่วไปเพื่อระบุว่า ArrayList นี้จะมีเฉพาะวัตถุ String เท่านั้น จากนั้นเราเพิ่มผลไม้สามรายการลงในรายการโดยใช้เมธอด add() และวนซ้ำรายการโดยใช้ for-each วนซ้ำเพื่อพิมพ์แต่ละรายการไปยังคอนโซล นี่เป็นเพียงตัวอย่างง่ายๆ แต่คอลเลกชันและข้อมูลทั่วไปอาจเป็นเครื่องมือที่ทรงพลังมากใน Java ช่วยให้คุณสามารถจัดเก็บและจัดการข้อมูลจำนวนมากได้อย่างมีประสิทธิภาพและง่ายดาย
ทำความเข้าใจเกี่ยวกับมัลติเธรดใน Java
มัลติเธรดช่วยให้สามารถรันเธรดการดำเนินการหลายเธรดพร้อมกันในโปรแกรมเดียว Java ให้การสนับสนุนในตัวสำหรับมัลติเธรดผ่านคลาส Thread และอินเทอร์เฟซ Runnable
นี่คือตัวอย่างข้อมูลโค้ด:
// A custom thread class that extends the Thread class
public class MyThread extends Thread {
private String threadName;
// Constructor that initialises the thread name
public MyThread(String threadName) {
this.threadName = threadName;
}
// The method that runs when the thread starts
public void run() {
// Prints a message indicating that the thread is running
System.out.println("Thread " + threadName + " is running.");
// Loops 5 times and prints the count of each iteration
for(int i = 1; i <= 5; i++) {
try {
// Put the thread to sleep for 1 second
Thread.sleep(1000);
} catch(InterruptedException e) {
// Prints a message if the thread is interrupted
System.out.println("Thread " + threadName + " interrupted.");
}
// Prints the count of the current iteration
System.out.println("Thread " + threadName + " count: " + i);
}
// Prints a message indicating that the thread is exiting
System.out.println("Thread " + threadName + " exiting.");
}
}
public class Main {
public static void main(String[] args) {
// Creates two instances of the custom thread class
MyThread thread1 = new MyThread("Thread 1");
MyThread thread2 = new MyThread("Thread 2");
// Starts the threads
thread1.start();
thread2.start();
}
}
รหัสนี้จะสร้างคลาส MyThread ที่ขยายคลาส Thread และแทนที่เมธอด run() เมธอด run() มีโค้ดที่จะดำเนินการเมื่อเธรดเริ่มต้น ในกรณีนี้ เธรดจะพิมพ์ชื่อออกมา จากนั้นนับจาก 1 ถึง 5 โดยมีการหน่วงเวลา 1 วินาทีระหว่างการนับแต่ละครั้ง
คลาส Main สร้างสองอินสแตนซ์ของคลาส MyThread และเริ่มต้นโดยใช้เมธอด start() สิ่งนี้จะสร้างเธรดการดำเนินการสองเธรดแยกกันที่ทำงานพร้อมกัน ผลลัพธ์ของการรันโปรแกรมนี้จะเป็นดังนี้:
Thread 1 is running. Thread 2 is running. Thread 1 count: 1 Thread 2 count: 1 Thread 1 count: 2 Thread 2 count: 2 Thread 1 count: 3 Thread 2 count: 3 Thread 1 count: 4 Thread 2 count: 4 Thread 1 count: 5 Thread 2 count: 5 Thread 1 exiting. Thread 2 exiting.
การทำงานกับไฟล์อินพุตและเอาต์พุต
File I/O คือกระบวนการอ่านและเขียนข้อมูลเข้าและออกจากไฟล์ Java มีคลาสหลายคลาสสำหรับการทำงานกับไฟล์ รวมถึง FileReader, FileWriter, BufferedReader, BufferedWriter และอื่นๆ
ต่อไปนี้คือตัวอย่างโค้ดสำหรับการอ่านและเขียนลงในไฟล์ใน Java:
import java.io.*;
public class FileIOExample {
public static void main(String[] args) {
try {
/* Writing to a file */
// Create a new FileWriter object that writes to a file
FileWriter writer = new FileWriter("myFile.txt");
writer.write("Hello world!\\n");
writer.write("This is a sample file.\\n");
// Close the FileWriter object, which flushes the stream and releases any system resources associated with it
writer.close();
/* Reading from a file */
// Create a new File object that represents the file
File file = new File("myFile.txt");
// Create a new BufferedReader object that reads from the file using a FileReader
BufferedReader reader = new BufferedReader(new FileReader(file));
String line;
// Read each line of the file until there are no more lines
while ((line = reader.readLine()) != null) {
// Print each line to the console
System.out.println(line);
}
// Close the BufferedReader object, which releases any system resources associated with it
reader.close();
// Catch any IOException that may occur
} catch (IOException e) {
// Print an error message with the exception's message
System.out.println("An error occurred: " + e.getMessage());
// Print the stack trace for the exception
e.printStackTrace();
}
}
}
ในตัวอย่างนี้ ขั้นแรกเราสร้างออบเจ็กต์ FileWriter เพื่อเขียนไปยังไฟล์ชื่อ myFile.txt จากนั้นเราจะเขียนข้อความสองบรรทัดลงในไฟล์โดยใช้วิธี write() และปิดวัตถุตัวเขียนโดยใช้วิธี close()
ต่อไป เราสร้างวัตถุ File เพื่ออ่านจากไฟล์และวัตถุ BufferedReader เพื่ออ่านไฟล์ทีละบรรทัด จากนั้นเราจะวนซ้ำไฟล์โดยใช้วิธี readLine() จนกระทั่งถึงจุดสิ้นสุดของไฟล์ ภายในลูป เราจะพิมพ์แต่ละบรรทัดไปที่คอนโซล
หากมีข้อยกเว้นเกิดขึ้นขณะอ่านหรือเขียนไฟล์ เราจะตรวจจับข้อยกเว้นและพิมพ์ข้อความแสดงข้อผิดพลาดไปยังคอนโซลโดยใช้วิธี getMessage() และวิธี printStackTrace()
ทำความเข้าใจเกี่ยวกับการเขียนโปรแกรมเครือข่ายใน Java
Java จัดเตรียมชุดคลาสและอินเทอร์เฟซที่ครอบคลุมสำหรับการเขียนโปรแกรมเครือข่าย รวมถึงคลาส Socket และ ServerSocket สำหรับการสร้างและจัดการการเชื่อมต่อเครือข่าย
ต่อไปนี้คือตัวอย่างโค้ดที่สาธิตวิธีสร้างแอปพลิเคชันเครือข่ายไคลเอ็นต์-เซิร์ฟเวอร์:
/*** Server side ***/
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class Server {
public static void main(String[] args) throws IOException {
// Create a server socket and listen on port 1234
ServerSocket server = new ServerSocket(1234);
System.out.println("Server started. Waiting for clients to connect...");
// Loop to accept incoming client connections
while (true) {
Socket client = server.accept();
System.out.println("Client connected: " + client.getInetAddress().getHostName());
// Create a new thread to handle the client
ClientHandler clientHandler = new ClientHandler(client);
clientHandler.start();
}
}
// Client handler thread
private static class ClientHandler extends Thread {
private Socket client;
private Scanner in;
private PrintWriter out;
public ClientHandler(Socket socket) {
this.client = socket;
}
public void run() {
try {
// Create input and output streams for the client
in = new Scanner(client.getInputStream());
out = new PrintWriter(client.getOutputStream(), true);
out.println("Welcome to the server!");
// Loop to receive messages from the client and send back an echo
while (in.hasNextLine()) {
String input = in.nextLine();
System.out.println("Received message from client: " + input);
out.println("Echo: " + input);
}
} catch (IOException e) {
System.out.println("Error: " + e);
} finally {
try {
// Close the client socket
client.close();
} catch (IOException e) {
System.out.println("Error closing client socket: " + e);
}
System.out.println("Client disconnected: " + client.getInetAddress().getHostName());
}
}
}
}
/*** Client side ***/
import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
public class Client {
public static void main(String[] args) throws IOException {
// Connect to the server on port 1234
Socket socket = new Socket("localhost", 1234);
System.out.println("Connected to server.");
// Create input and output streams for the client
Scanner in = new Scanner(socket.getInputStream());
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
Scanner console = new Scanner(System.in);
String message;
// Loop to send messages to the server and receive responses
do {
System.out.print("Enter a message to send to the server: ");
message = console.nextLine();
out.println(message);
String response = in.nextLine();
System.out.println("Server response: " + response);
} while (!message.equalsIgnoreCase("bye"));
// Close the client socket
socket.close();
}
}
ในตัวอย่างนี้ โค้ดฝั่งเซิร์ฟเวอร์ตั้งค่า ServerSocket บนพอร์ต 1234 และรอรับการเชื่อมต่อไคลเอ็นต์ขาเข้า เมื่อไคลเอนต์เชื่อมต่อ จะสร้างเธรด ClientHandler ใหม่เพื่อจัดการไคลเอนต์ เธรด ClientHandler สร้างสตรีมอินพุตและเอาท์พุตสำหรับไคลเอ็นต์ ส่งข้อความต้อนรับไปยังไคลเอ็นต์ จากนั้นเข้าสู่ลูปเพื่อรับข้อความจากไคลเอ็นต์ และส่งเสียงสะท้อนกลับ เมื่อไคลเอ็นต์ยกเลิกการเชื่อมต่อ เธรดจะปิดซ็อกเก็ตไคลเอ็นต์
รหัสฝั่งไคลเอ็นต์เชื่อมต่อกับเซิร์ฟเวอร์บนพอร์ต 1234 และสร้างสตรีมอินพุตและเอาต์พุตสำหรับไคลเอ็นต์ จากนั้นจะเข้าสู่ลูปเพื่ออ่านข้อความจากคอนโซลและส่งไปยังเซิร์ฟเวอร์ และรับการตอบกลับจากเซิร์ฟเวอร์และพิมพ์ไปยังคอนโซล การวนซ้ำจะดำเนินต่อไปจนกว่าผู้ใช้จะพิมพ์ "บาย" โดยที่การวนซ้ำในฝั่งไคลเอ็นต์จะหยุดลงและซ็อกเก็ตไคลเอ็นต์จะถูกปิดโดยการเรียกเมธอด socket.close() ซึ่งจะปิดทั้งสตรีมอินพุตและเอาต์พุตที่เกี่ยวข้องกับซ็อกเก็ต และปล่อย ทรัพยากร.
การใช้ Java Libraries และ Frameworks
Java มีคอลเลกชันไลบรารีและเฟรมเวิร์กมากมายที่สามารถช่วยคุณสร้างแอปพลิเคชันที่แข็งแกร่งและปรับขนาดได้อย่างรวดเร็ว ไลบรารีและเฟรมเวิร์ก Java ยอดนิยมบางตัว ได้แก่ Spring, Hibernate, Apache Struts และอื่นๆ
นี่คือตัวอย่างที่สาธิตการใช้งาน Spring, Hibernate และ Apache Struts ในเว็บแอปพลิเคชัน:
/*** Employee.java ***/
@Entity
@Table(name = "employee")
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
private String email;
private String department;
// getters and setters
}
/*** EmployeeDAO.java ***/
@Repository
public class EmployeeDAO {
// Inject SessionFactory dependency using @Autowired
@Autowired
private SessionFactory sessionFactory;
// Save or update an employee in the database
public void save(Employee employee) {
Session session = sessionFactory.getCurrentSession();
session.saveOrUpdate(employee);
}
// Retrieve a list of all employees from the database
public List<Employee> list() {
Session session = sessionFactory.getCurrentSession();
return session.createQuery("from Employee", Employee.class).list();
}
}
/*** EmployeeService.java ***/
@Service
public class EmployeeService {
// Inject EmployeeDAO dependency using @Autowired
@Autowired
private EmployeeDAO employeeDAO;
// Use @Transactional to wrap save operation in a transaction
@Transactional
public void save(Employee employee) {
employeeDAO.save(employee);
}
// Use @Transactional to wrap list operation in a transaction
@Transactional(readOnly = true)
public List<Employee> list() {
return employeeDAO.list();
}
}
/*** EmployeeController.java ***/
@Controller
@RequestMapping("/employee")
public class EmployeeController {
// Inject EmployeeService dependency using @Autowired
@Autowired
private EmployeeService employeeService;
// Map request for employee list to this method
@RequestMapping("/list")
public ModelAndView list() {
// Get list of employees from EmployeeService
List<Employee> employees = employeeService.list();
/* Return a ModelAndView object that will render the "list" view
and pass the "employees" list as a model attribute */
return new ModelAndView("list", "employees", employees);
}
// Map request for adding a new employee to this method
@RequestMapping("/add")
public ModelAndView add() {
/* Return a ModelAndView object that will render the "add" view
and pass a new Employee object as a model attribute */
return new ModelAndView("add", "employee", new Employee());
}
// Map request for saving a new employee to this method
@RequestMapping("/save")
public ModelAndView save(@ModelAttribute Employee employee) {
// Call save method of EmployeeService to save the employee to the database
employeeService.save(employee);
// Redirect to the employee list page after saving
return new ModelAndView("redirect:/employee/list");
}
}
<!-- list.jsp -->
<%@ taglib prefix="c" uri="<http://java.sun.com/jsp/jstl/core>" %>
<!-- Importing JSTL Core tag library -->
<table>
<tr>
<th>Name</th>
<th>Email</th>
<th>Department</th>
</tr>
<!-- Using JSTL forEach loop to iterate over the employees list -->
<c:forEach var="employee" items="${employees}">
<tr>
<td>${employee.name}</td>
<td>${employee.email}</td>
<td>${employee.department}</td>
</tr>
</c:forEach>
</table>
<!-- add.jsp -->
<form:form modelAttribute="employee" method="post" action="/employee/save">
<!-- Using Spring form tag to bind the form inputs to the Employee model -->
<table>
<tr>
<td>Name:</td>
<td><form:input path="name"/></td>
<!-- Using Spring input tag to create an input field for employee name -->
</tr>
<tr>
<td>Email:</td>
<td><form:input path="email"/></td>
<!-- Using Spring input tag to create an input field for employee email -->
</tr>
<tr>
<td>Department:</td>
<td><form:input path="department"/></td>
<!-- Using Spring input tag to create an input field for employee department -->
</tr>
<tr>
<td colspan="2"><input type="submit" value="Save"/></td>
<!-- Adding a submit button to the form -->
</tr>
</table>
</form:form>
ตัวอย่างนี้แสดงวิธีสร้างเว็บแอปพลิเคชันอย่างง่ายโดยใช้ Spring, Hibernate และ Apache Struts คลาส Employee คือ Hibernate entity ที่คงอยู่ในฐานข้อมูลโดยใช้ EmployeeDAO EmployeeService ให้ชั้นของนามธรรมระหว่าง DAO และตัวควบคุม และช่วยให้สามารถจัดการธุรกรรมได้ EmployeeController จัดการคำขอ HTTP และส่งคืน ModelAndView ซึ่งแมปชื่อมุมมองลอจิคัลกับเพจ JSP จริง หน้า JSP ใช้แท็ก JSTL เพื่อวนซ้ำรายชื่อพนักงานและแสดงในตาราง และเพื่อสร้างแบบฟอร์มสำหรับการเพิ่มพนักงานใหม่
บทสรุป
Java เป็นภาษาโปรแกรมที่ทรงพลังซึ่งมอบคุณประโยชน์มากมายให้กับนักพัฒนา วันนี้เราได้กล่าวถึงพื้นฐานของมัน รวมถึงโครงสร้างการควบคุม ชนิดข้อมูล และแนวคิดการเขียนโปรแกรมเชิงวัตถุ และได้พูดคุยถึงว่าทำไมการพัฒนา Java จึงมีความสำคัญ ด้วยการเรียนรู้ Java อย่างเชี่ยวชาญ นักพัฒนาสามารถปลดล็อกโอกาสมากมายและยกระดับทักษะของพวกเขาไปอีกระดับ
หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ Java มีแหล่งข้อมูลออนไลน์มากมาย เช่น บทช่วยสอน Java ของ Oracle, หลักสูตร Java ของ Udemy และชุมชน Java บน Reddit คุณยังสามารถอ้างถึงหนังสือและบล็อก เช่น Effective Java โดย Joshua Bloch และ Java Concurrency in Practice โดย Brian Goetz ด้วยทรัพยากรที่มีอยู่มากมาย คุณสามารถเดินทางต่อไปสู่การเรียนรู้ Java ได้อย่างเชี่ยวชาญ โดยไม่คำนึงถึงรูปแบบการเรียนรู้ที่คุณต้องการ ขอให้โชคดีและอย่าลืมสนุก!
สำหรับเนื้อหาเพิ่มเติม โปรดดูโพสต์อื่นๆ ของฉันและพิจารณาสมัครรับ รายชื่ออีเมลของฉัน! นอกจากนี้ ฉันชอบที่จะรู้จักเพื่อนใหม่และเราสามารถเชื่อมต่อผ่านโซเชียลหรือทางไปรษณีย์ :)
| DEV.to | แฮกเกอร์นิวส์ | อินดี้แฮกเกอร์ | กัมโรด | "สนับสนุนฉัน!" |
| GitHub | ทวิตเตอร์ | LinkedIn | เรดดิท | Pinterest | TikTok |
หากคุณพบว่าบทความนี้มีประโยชน์ โปรดแบ่งปันกับผู้อื่นที่อาจได้รับประโยชน์ ขอบคุณมากที่อ่านจนจบ คอยติดตาม! ฉันหวังว่าจะได้เชื่อมต่อกับคุณเร็วๆ นี้ ❤
