สวัสดีทุกคน สมาชิกฟอรั่ม!
ฉันเข้าใจรูปแบบนี้อย่างละเอียดถี่ถ้วนแล้ว (สำหรับฉัน)
Command
และอยากลองพูดถึงมัน "ด้วยคำพูดของฉันเอง"
![รูปแบบคำสั่งด้วยคำพูดของคุณเอง - 1]()
จากวิกิพีเดีย เราพบว่าจุดประสงค์ของมันคือ
การสร้างโครงสร้างที่คลาสผู้ส่งและคลาสผู้รับไม่ได้ขึ้นอยู่กับแต่ละคลาสโดยตรง จัดระเบียบการโทร กลับ
ไปยังชั้นเรียนที่มีคลาสผู้ส่ง โดยหลักการแล้วเขียนไว้ชัดเจนและถูกต้องแต่เป็นในทางทฤษฎี วิธีการทำเช่นนี้? ปัญหาจึงเริ่มต้นขึ้นเพราะว่า... คำอธิบายไม่ชัดเจนและชัดเจนอีกต่อไป ดังนั้นฉันจึงคิดออกฉันตัดสินใจบอกคุณว่าฉันเข้าใจมันได้อย่างไรบางทีมันอาจจะเป็นประโยชน์กับใครบางคน: ตามคำอธิบายวัตถุประสงค์ของรูปแบบนี้ฉันจะรวมคำอธิบายเข้ากับโค้ดเพื่อให้ชัดเจนยิ่งขึ้น เพราะ ในวิกิพีเดียเดียวกันพวกเขาสรุปเป็นภาษาต่างๆ มากมาย ดังนั้นคำอธิบายจึงแยกออกจากตัวอย่าง มีคำศัพท์อยู่สี่คำในรูปแบบนี้ ตอนนี้ขอทำความเข้าใจไว้ก่อน: commands(
command
), command receiver(
receiver
), command caller(
invoker
) และ client(
client
) ฉันจะยกตัวอย่างจากวิกิพีเดียเดียวกันซึ่งค่อนข้างทนได้
งานนี้ เป็นชั้นเรียน
Light
ที่ทำสองสิ่งได้ คือ เปิดไฟและปิดไฟ ในส่วนของรูปแบบจะเป็น “ตัวรับคำสั่ง (
receiver
)”
public class Light{
public Light(){ }
public void turnOn(){
System.out.println("The light is on");
}
public void turnOff(){
System.out.println("The light is off");
}
}
มาสร้างอินเทอร์เฟซด้วยวิธีการหนึ่ง
execute()
ที่จะดำเนินการและเรียกว่าในรูปแบบ "คำสั่ง (
command
)"
public interface Command{
void execute();
}
มีความจำเป็นต้องสรุปการดำเนินการของทักษะในชั้น
Light
เรียน ในการทำเช่นนี้ เราจะสร้างคลาส
TurnOnLightCommand
และ
TurnOffLightCommand
ใช้อินเทอร์เฟซและ
Command
จะยอมรับคลาสอ็อบเจ็กต์ในตัวสร้าง
Light
และแต่ละคนจะดำเนินการเพียงครั้งเดียวเท่านั้น อันหนึ่งจะเรียกเมธอด
turnOn()
และอีกอันจะ
turnOff()
เรียก
public class TurnOnLightCommand implements Command{
private Light theLight;
public TurnOnLightCommand(Light light){
this.theLight=light;
}
public void execute(){
theLight.turnOn();
}
}
public class TurnOffLightCommand implements Command{
private Light theLight;
public TurnOffLightCommand(Light light){
this.theLight=light;
}
public void execute(){
theLight.turnOff();
}
}
ตอนนี้ได้เวลาสร้างวัตถุที่ยอมรับวิธีการวัตถุแบบห่อหุ้มเหล่า
Light
นี้ ในแง่ของรูปแบบ เรียกว่าผู้เรียกคำสั่ง (ผู้เรียกใช้) ลองเรียกมัน
Switch
แล้วปล่อยให้มันยอมรับตัวแปรในตัวสร้าง
Command
ที่จะใช้ในวิธีการที่สร้างขึ้น
flipUp()
และ
flipDown()
public class Switch {
private Command flipUpCommand;
private Command flipDownCommand;
public Switch(Command flipUpCommand,Command flipDownCommand){
this.flipUpCommand=flipUpCommand;
this.flipDownCommand=flipDownCommand;
}
public void flipUp(){
flipUpCommand.execute();
}
public void flipDown(){
flipDownCommand.execute();
}
}
และแน่นอน เราจะสร้างชั้นเรียนที่จะใช้เพื่อทำความเข้าใจสิ่งที่เกิดขึ้นโดยทั่วไป จะเรียกว่าวิธีการหลักซึ่งการดำเนินการทั้งหมดจะเกิดขึ้น:
public class TestCommand{
public static void main(String[] args){
Light l=new Light();
Command switchUp=new TurnOnLightCommand(l);
Command switchDown=new TurnOffLightCommand(l);
Switch s=new Switch(switchUp,switchDown);
s.flipUp();
s.flipDown();
}
}
ผลลัพธ์จะเป็นดังนี้:
"The light is on"
"The light is off"
สิ่งนี้ใช้ที่ไหน?
วัตถุประสงค์ชัดเจนว่าอะไรและเพราะเหตุใดจึงจำเป็น กล่าวคือ ในสถานการณ์ที่คุณต้องแยกการดำเนินการเฉพาะออกไป วิธีนี้จะสะดวกมาก เพื่อให้การใช้งานบางฟังก์ชั่นไม่ขึ้นอยู่กับการใช้งานเฉพาะและสามารถเปลี่ยนแปลงได้โดยไม่ทำให้ระบบเสียหาย อะไรประมาณนี้...) เขียนความคิดเห็น มาพูดคุยกัน บางทีอะไรๆ อาจจะทำให้ง่ายขึ้นและบอกได้ดีขึ้น เราจะแก้ไขทุกอย่างถ้าจำเป็น) เพื่อว่าสำหรับคนที่อ่านครั้งแรกจะได้ชัดเจนที่สุด ใครก็ตามที่ชอบบทความนี้ให้ใส่ "+" ไว้ :) สิ่งนี้สำคัญสำหรับฉัน) เมื่อเวลาผ่านไปฉันอยากจะเขียนเพิ่มเติมเกี่ยวกับ
Builder
และ
Singleton
เรื่องอื่น ๆ
ดูบทความอื่น ๆ ของฉันด้วย:
GO TO FULL VERSION