บางคนสามารถให้คำอธิบายง่ายๆเกี่ยวกับวิธีการเทียบกับฟังก์ชั่นในบริบทของ OOP ได้หรือไม่?
if(class(object)) { ... } else {stop()}
จะเทียบเท่ากับแนวคิดหรือไม่?
บางคนสามารถให้คำอธิบายง่ายๆเกี่ยวกับวิธีการเทียบกับฟังก์ชั่นในบริบทของ OOP ได้หรือไม่?
if(class(object)) { ... } else {stop()}
จะเทียบเท่ากับแนวคิดหรือไม่?
คำตอบ:
ฟังก์ชั่นเป็นชิ้นส่วนของรหัสที่เรียกตามชื่อ สามารถส่งผ่านข้อมูลเพื่อดำเนินการ (เช่นพารามิเตอร์) และสามารถเลือกส่งคืนข้อมูล (ค่าส่งคืน) ข้อมูลทั้งหมดที่ส่งผ่านไปยังฟังก์ชันจะถูกส่งผ่านอย่างชัดเจน
วิธีเป็นชิ้นส่วนของรหัสที่เรียกตามชื่อที่เกี่ยวข้องกับวัตถุ โดยส่วนใหญ่มันจะเหมือนกับฟังก์ชั่นยกเว้นความแตกต่างที่สำคัญสองประการ:
(นี่เป็นคำอธิบายที่ง่ายขึ้นละเว้นปัญหาขอบเขตฯลฯ )
วิธีการอยู่บนวัตถุ
ฟังก์ชั่นเป็นอิสระจากวัตถุ
สำหรับ Java และ C # มีวิธีการเท่านั้น
สำหรับ C มีฟังก์ชั่นเท่านั้น
สำหรับ C ++ และ Python มันจะขึ้นอยู่กับว่าคุณอยู่ในชั้นเรียนหรือไม่
'วิธีการ'เป็นคำเชิงวัตถุสำหรับฟังก์ชั่น ' นั่นคือทั้งหมดที่มีอยู่ (เช่นไม่มีความแตกต่างที่แท้จริง)
น่าเสียดายที่ฉันคิดว่าคำตอบมากมายที่นี่ยืดเยื้อหรือทำให้ความคิดก้าวหน้าขึ้นว่ามีความแตกต่างที่ซับซ้อนและมีความหมาย
จริง ๆ - มีไม่มากไปแค่คำที่แตกต่างกันสำหรับสิ่งเดียวกัน
[ปลายสาย]
ในความเป็นจริงเป็นไบรอันโอนีชี้ให้เห็นในความคิดเห็นคำถามนี้มาตรฐาน C ++ ไม่เคยใช้คำว่า 'วิธี' เมื่ออ้างถึงฟังก์ชั่นสมาชิก บางคนอาจใช้เป็นข้อบ่งชี้ว่า C ++ ไม่ใช่ภาษาเชิงวัตถุ อย่างไรก็ตามฉันชอบที่จะใช้เป็นตัวบ่งชี้ว่าคนฉลาดกลุ่มสวยไม่คิดว่ามีเหตุผลที่ดีโดยเฉพาะอย่างยิ่งที่จะใช้คำที่แตกต่างกัน
self
ข้อโต้แย้งนั้นชัดเจน และหลายภาษามีวิธีการคงที่ซึ่งไม่ได้ผ่านตัวอย่าง
this
หรือself
แต่โครงสร้างเหล่านั้นมักจะเรียกว่าฟังก์ชั่นมากกว่าวิธีการ
โดยทั่วไป: เมธอดคือฟังก์ชันที่เป็นของคลาสฟังก์ชันสามารถอยู่ในขอบเขตอื่น ๆ ของรหัสเพื่อให้คุณสามารถระบุว่าวิธีการทั้งหมดเป็นฟังก์ชัน แต่ไม่ใช่ทุกฟังก์ชันที่เป็นวิธีการ:
ใช้ตัวอย่างไพ ธ อนต่อไปนี้:
class Door:
def open(self):
print 'hello stranger'
def knock_door:
a_door = Door()
Door.open(a_door)
knock_door()
ตัวอย่างที่ให้ไว้จะแสดงคลาสที่เรียกว่า "ประตู" ซึ่งมีวิธีการหรือการกระทำที่เรียกว่า "เปิด" มันถูกเรียกว่าวิธีการเพราะมันถูกประกาศในชั้นเรียน มีอีกส่วนหนึ่งของรหัสด้วย "def" ด้านล่างซึ่งกำหนดฟังก์ชั่นมันเป็นฟังก์ชั่นเพราะมันไม่ได้ประกาศภายในชั้นเรียนฟังก์ชั่นนี้เรียกวิธีการที่เรากำหนดไว้ในชั้นเรียนของเราในขณะที่คุณสามารถเห็น เรียกตัวเอง
ตามที่คุณเห็นคุณสามารถเรียกใช้ฟังก์ชันได้ทุกที่ แต่ถ้าคุณต้องการเรียกใช้เมธอดคุณจะต้องผ่านวัตถุใหม่ชนิดเดียวกันกับคลาสที่มีการประกาศเมธอด (Class.method (object)) หรือคุณต้องเรียกใช้ วิธีการภายในวัตถุ (object.Method ()) อย่างน้อยในหลาม
คิดว่าวิธีการเป็นสิ่งเดียวที่สามารถทำได้ดังนั้นถ้าคุณมีคลาส Dog มันจะสมเหตุสมผลที่จะมีฟังก์ชั่นเปลือกเสียงเฉพาะในคลาสนั้นและนั่นจะเป็นวิธีการถ้าคุณมีคลาส Person ด้วย เขียนฟังก์ชั่น "feed" สำหรับสิ่งที่ไม่ได้อยู่ในคลาสใด ๆ เนื่องจากทั้งมนุษย์และสุนัขสามารถเลี้ยงได้และคุณสามารถเรียกมันได้ว่าฟังก์ชั่นนั้นไม่ได้อยู่ในคลาสใดโดยเฉพาะ
วิธีง่ายๆในการจดจำ:
คำจำกัดความทั่วไปของความแตกต่างหลักระหว่างฟังก์ชั่นและวิธีการ :
ฟังก์ชั่นถูกกำหนดไว้นอกชั้นเรียนในขณะที่วิธีการที่กำหนดไว้ภายในและเป็นส่วนหนึ่งของชั้นเรียน
หากคุณรู้สึกว่าการอ่านที่นี่คือ "การแนะนำวิธีการ OO ของฉัน"
แนวคิดที่อยู่เบื้องหลังกระบวนทัศน์เชิงวัตถุคือ "คุกคาม" ซอฟต์แวร์ประกอบด้วย .. วัตถุ "ดี" วัตถุในโลกแห่งความเป็นจริงมีคุณสมบัติเช่นถ้าคุณมีพนักงานพนักงานมีชื่อรหัสพนักงานตำแหน่งเขาเป็นของแผนก ฯลฯ
วัตถุยังรู้วิธีจัดการกับคุณลักษณะและดำเนินการบางอย่างกับพวกเขา ถ้าเราอยากรู้ว่าพนักงานทำอะไรอยู่ตอนนี้เราก็จะถามเขา
employe whatAreYouDoing.
"whatAreYouDoing" นั้นเป็น "ข้อความ" ที่ส่งไปยังวัตถุ วัตถุรู้วิธีตอบคำถามนั้นมีการกล่าวว่ามี "วิธีการ" เพื่อแก้ไขคำถาม
ดังนั้นวิธีที่วัตถุต้องเปิดเผยพฤติกรรมของมันจึงถูกเรียกว่าวิธีการ ดังนั้นวิธีการเป็นวัตถุสิ่งประดิษฐ์ต้อง "ทำ" บางสิ่งบางอย่าง
วิธีอื่น ๆ ที่เป็นไปได้คือ
employee whatIsYourName
employee whatIsYourDepartmentsName
เป็นต้น
ฟังก์ชั่นในทางกลับกันเป็นวิธีที่ภาษาการเขียนโปรแกรมมีการคำนวณข้อมูลบางอย่างเช่นคุณอาจมีฟังก์ชั่น addValues (8, 8) ที่ส่งกลับ 16
// pseudo-code
function addValues( int x, int y ) return x + y
// call it
result = addValues( 8,8 )
print result // output is 16...
ตั้งแต่ภาษาการเขียนโปรแกรมที่ได้รับความนิยมครั้งแรก (เช่น fortran, c, pascal) ไม่ครอบคลุมกระบวนทัศน์ OO พวกเขาเพียงเรียกสิ่งประดิษฐ์ "ฟังก์ชั่น" เหล่านี้เท่านั้น
เช่นฟังก์ชันก่อนหน้าใน C จะเป็น:
int addValues( int x, int y )
{
return x + y;
}
ไม่ใช่ "ธรรมชาติ" ที่จะบอกว่าวัตถุมี "ฟังก์ชั่น" ในการดำเนินการบางอย่างเนื่องจากฟังก์ชั่นจะเกี่ยวข้องกับสิ่งทางคณิตศาสตร์มากกว่าในขณะที่พนักงานมีคณิตศาสตร์อยู่เล็กน้อย แต่คุณสามารถมีวิธีการที่เหมือนกับฟังก์ชัน เช่นใน Java นี่จะเป็นฟังก์ชัน addValues ที่เทียบเท่ากัน
public static int addValues( int x, int y ) {
return x + y;
}
ดูคุ้น ๆ เหรอ? นั่นเป็นเพราะ Java มีรากฐานอยู่บน C ++ และ C ++ บน C
ในตอนท้ายเป็นเพียงแนวคิดในการดำเนินการพวกเขาอาจมีลักษณะเหมือนกัน แต่ในเอกสารประกอบ OO สิ่งเหล่านี้เรียกว่าวิธีการ
นี่คือตัวอย่างของวัตถุพนักงานก่อนหน้านี้ใน Java
public class Employee {
Department department;
String name;
public String whatsYourName(){
return this.name;
}
public String whatsYourDeparmentsName(){
return this.department.name();
}
public String whatAreYouDoing(){
return "nothing";
}
// Ignore the following, only set here for completness
public Employee( String name ) {
this.name = name;
}
}
// Usage sample.
Employee employee = new Employee( "John" ); // Creates an employee called John
// If I want to display what is this employee doing I could use its methods.
// to know it.
String name = employee.whatIsYourName():
String doingWhat = employee.whatAreYouDoint();
// Print the info to the console.
System.out.printf("Employee %s is doing: %s", name, doingWhat );
Output:
Employee John is doing nothing.
ความแตกต่างนั้นอยู่ใน "โดเมน" ที่มันถูกนำไปใช้
AppleScript มีความคิดเกี่ยวกับ "ภาษาธรรมชาติ" matphor ซึ่งในบางจุด OO มี เช่น Smalltalk ฉันหวังว่ามันอาจจะง่ายกว่าที่คุณจะเข้าใจวิธีการในวัตถุหลังจากอ่านข้อความนี้
หมายเหตุ: รหัสจะไม่ถูกรวบรวมเพียงเพื่อใช้เป็นตัวอย่าง อย่าลังเลที่จะแก้ไขโพสต์และเพิ่มตัวอย่าง Python
ในโลกของ OO ทั้งสองถูกใช้เพื่อหมายถึงสิ่งเดียวกัน
จากมุมมองทางคณิตศาสตร์และ CS ที่บริสุทธิ์ฟังก์ชันจะส่งกลับผลลัพธ์เดียวกันเสมอเมื่อถูกเรียกด้วยอาร์กิวเมนต์เดียวกัน (f (x, y) = (x + y) ในทางกลับกันวิธีการมักจะเกี่ยวข้องกับอินสแตนซ์ของคลาส แม้ว่าภาษา OO สมัยใหม่ส่วนใหญ่จะไม่ใช้คำว่า "ฟังก์ชัน" อีกต่อไป วิธีการคงที่จำนวนมากสามารถค่อนข้างฟังก์ชั่นเพราะพวกเขามักจะไม่มีสถานะ (ไม่จริงเสมอไป)
สมมติว่าฟังก์ชั่นเป็นบล็อกของรหัส (โดยปกติจะมีขอบเขตของตัวเองและบางครั้งมีการปิดของตัวเอง) ที่อาจได้รับข้อโต้แย้งบางอย่างและอาจส่งกลับผลลัพธ์
วิธีการเป็นฟังก์ชั่นที่เป็นเจ้าของโดยวัตถุ (ในบางระบบเชิงวัตถุมันถูกต้องมากขึ้นที่จะบอกว่ามันเป็นของชั้นเรียน) การเป็น "เจ้าของ" โดยวัตถุ / คลาสหมายความว่าคุณอ้างถึงวิธีการผ่านวัตถุ / คลาส ตัวอย่างเช่นใน Java หากคุณต้องการเรียกใช้เมธอด "open ()" ที่เป็นเจ้าของโดยวัตถุ "door" คุณต้องเขียน "door.open ()"
โดยปกติแล้ววิธีการยังได้รับคุณสมบัติพิเศษบางอย่างที่อธิบายพฤติกรรมของพวกเขาภายในวัตถุ / ชั้นเรียนเช่น: การมองเห็น (เกี่ยวข้องกับแนวคิดเชิงวัตถุของการห่อหุ้ม) ซึ่งกำหนดจากวัตถุ (หรือชั้นเรียน) วิธีการที่สามารถเรียก
ในภาษาเชิงวัตถุจำนวนมาก "ฟังก์ชั่น" ทั้งหมดเป็นของวัตถุ (หรือคลาส) ดังนั้นในภาษาเหล่านี้จึงไม่มีฟังก์ชั่นที่ไม่ใช่วิธีการ
เมธอดคือฟังก์ชันของคลาส ในศัพท์แสงปกติคนแลกเปลี่ยนวิธีการและฟังก์ชั่นทั่ว โดยพื้นฐานแล้วคุณสามารถนึกถึงสิ่งเหล่านี้ในลักษณะเดียวกัน (ไม่แน่ใจว่าฟังก์ชันระดับโลกเรียกว่าวิธีการ)
ฟังก์ชั่นเป็นแนวคิดทางคณิตศาสตร์ ตัวอย่างเช่น:
f(x,y) = sin(x) + cos(y)
บอกว่าฟังก์ชั่น f () จะคืนค่าบาปของพารามิเตอร์แรกที่เพิ่มเข้ากับโคไซน์ของพารามิเตอร์ที่สอง มันเป็นแค่คณิตศาสตร์ เมื่อมันเกิดขึ้น sin () และ cos () ก็มีฟังก์ชั่นเช่นกัน ฟังก์ชั่นมีคุณสมบัติอื่น: การเรียกฟังก์ชั่นทั้งหมดที่มีพารามิเตอร์เดียวกันควรส่งคืนผลลัพธ์เดียวกัน
ในทางกลับกันเมธอดคือฟังก์ชันที่เกี่ยวข้องกับวัตถุในภาษาเชิงวัตถุ มันมีพารามิเตอร์หนึ่งนัย: วัตถุถูกดำเนินการตาม (และเป็นรัฐ)
ดังนั้นถ้าคุณมีวัตถุ Z ที่มีเมธอด g (x) คุณอาจเห็นสิ่งต่อไปนี้:
Z.g(x) = sin(x) + cos(Z.y)
ในกรณีนี้พารามิเตอร์ x จะถูกส่งผ่านเหมือนกับในตัวอย่างฟังก์ชันก่อนหน้านี้ อย่างไรก็ตามพารามิเตอร์ to cos () เป็นค่าที่อาศัยอยู่ภายในวัตถุ Z. Z และข้อมูลที่อยู่ภายใน (Zy) เป็นพารามิเตอร์โดยนัยถึงวิธีการของ g ()
ฟังก์ชั่นหรือวิธีการเป็นส่วนที่เรียกชื่อของรหัสซึ่งดำเนินการบางอย่างและเลือกที่จะส่งกลับค่า
ในภาษาC มีการใช้คำว่า function Java & C #คนจะบอกว่ามันเป็นวิธีการ (และฟังก์ชั่นในกรณีนี้ถูกกำหนดไว้ในชั้นเรียน / วัตถุ)
c ++โปรแกรมเมอร์อาจเรียกว่าฟังก์ชั่นหรือบางครั้งวิธีการ (ขึ้นอยู่กับว่าพวกเขากำลังเขียนรูปแบบกระบวนการรหัส c ++ หรือกำลังทำวิธีเชิงวัตถุของ C ++ ยังมี C / C ++ เท่านั้นโปรแกรมเมอร์มีแนวโน้มที่จะเรียกมันว่าฟังก์ชั่นเพราะคำว่า 'วิธีการ' เป็น ใช้บ่อยใน C / C ++ วรรณกรรม)
คุณใช้ฟังก์ชั่นเพียงแค่เรียกชื่อมันว่า
result = mySum(num1, num2);
คุณจะเรียกวิธีการโดยอ้างอิงวัตถุก่อน
result = MyCalc.mySum(num1,num2);
ในอดีตอาจมีความแตกต่างเล็กน้อยกับ "วิธีการ" เป็นสิ่งที่ไม่ได้ส่งกลับค่าและ "ฟังก์ชั่น" หนึ่งซึ่งไม่ภาษาแต่ละภาษามีคำศัพท์ที่มีความหมายพิเศษของตัวเอง
ใน"C"คำว่า"ฟังก์ชั่น"หมายถึงประจำโปรแกรม
ในJavaคำว่า"function"ไม่มีความหมายพิเศษใด ๆ ในขณะที่"เมธอด"หมายถึงหนึ่งในรูทีนที่สร้างการใช้งานคลาส
ในC #ที่จะแปลว่า:
public void DoSomething() {} // method
public int DoSomethingAndReturnMeANumber(){} // function
แต่จริงๆแล้วฉันขอย้ำอีกครั้งว่าไม่มีความแตกต่างในแนวคิดทั้งสอง หากคุณใช้คำว่า "ฟังก์ชั่น" ในการสนทนาอย่างไม่เป็นทางการเกี่ยวกับ Java คนจะถือว่าคุณหมายถึง "วิธี" และดำเนินการต่อไป อย่าใช้มันในเอกสารหรืองานนำเสนอที่เหมาะสมเกี่ยวกับ Java ไม่เช่นนั้นคุณจะดูงี่เง่า
method
... หรือฉันจะเรียกมันและprocedure
function
Function คือชุดของตรรกะที่สามารถใช้เพื่อจัดการข้อมูล
ในขณะที่วิธีการฟังก์ชั่นที่ใช้ในการจัดการข้อมูลของวัตถุที่มันเป็น ดังนั้นในทางเทคนิคหากคุณมีฟังก์ชั่นที่ไม่เกี่ยวข้องกับคลาสของคุณอย่างสมบูรณ์ แต่ถูกประกาศในคลาสนั่นไม่ใช่วิธีการ มันเรียกว่าการออกแบบที่ไม่ดี
วิธีการในชั้นเรียนกระทำกับตัวอย่างของชั้นเรียนที่เรียกว่าวัตถุ
class Example
{
public int data = 0; // Each instance of Example holds its internal data. This is a "field", or "member variable".
public void UpdateData() // .. and manipulates it (This is a method by the way)
{
data = data + 1;
}
public void PrintData() // This is also a method
{
Console.WriteLine(data);
}
}
class Program
{
public static void Main()
{
Example exampleObject1 = new Example();
Example exampleObject2 = new Example();
exampleObject1.UpdateData();
exampleObject1.UpdateData();
exampleObject2.UpdateData();
exampleObject1.PrintData(); // Prints "2"
exampleObject2.PrintData(); // Prints "1"
}
}
ในภาษา OO เช่น Object Pascal หรือ C ++, "method" เป็นฟังก์ชั่นที่เกี่ยวข้องกับวัตถุ ตัวอย่างเช่นวัตถุ "Dog" อาจมีฟังก์ชั่น "เปลือกไม้" และสิ่งนี้จะถือเป็น "วิธีการ" ในทางตรงกันข้ามฟังก์ชั่น "StrLen" ยืนอยู่คนเดียว (มันให้ความยาวของสตริงที่ให้ไว้เป็นอาร์กิวเมนต์) มันจึงเป็นแค่ "ฟังก์ชั่น" Javascript นั้นใช้เทคนิคเชิงวัตถุเช่นกัน แต่ต้องเผชิญกับข้อ จำกัด มากมายเมื่อเทียบกับภาษาที่มีการใช้งานเต็มรูปแบบเช่น C ++, C # หรือ Pascal อย่างไรก็ตามความแตกต่างควรจะยังคงอยู่
ข้อเท็จจริงเพิ่มเติมสองสามข้อ: C # เป็นเชิงวัตถุอย่างสมบูรณ์ดังนั้นคุณจึงไม่สามารถสร้าง "ฟังก์ชัน" แบบสแตนด์อโลนได้ ใน C # ทุกฟังก์ชั่นถูกผูกไว้กับวัตถุและดังนั้นในทางเทคนิค "วิธีการ" นักเตะคือคนไม่กี่คนใน C # อ้างถึงพวกเขาว่า "วิธีการ" - พวกเขาใช้คำว่า "ฟังก์ชั่น" เพราะไม่มีความแตกต่างที่แท้จริง
ในที่สุด - เพื่อปรมาจารย์ปาสกาลใด ๆ จะไม่กระโดดกับฉันที่นี่ - ปาสกาลยังแยกความแตกต่างระหว่าง "ฟังก์ชั่น" (ซึ่งคืนค่า) และ "ขั้นตอน" ซึ่งไม่ได้ C # ไม่ได้แยกความแตกต่างนี้อย่างชัดเจนแม้ว่าคุณสามารถเลือกที่จะส่งคืนค่าได้หรือไม่
เนื่องจากคุณกล่าวถึง Python ดังต่อไปนี้อาจเป็นภาพประกอบที่มีประโยชน์เกี่ยวกับความสัมพันธ์ระหว่างวิธีการและวัตถุในภาษาเชิงวัตถุที่ทันสมัยที่สุด โดยสรุปสิ่งที่พวกเขาเรียกว่า "วิธีการ" เป็นเพียงฟังก์ชั่นที่ได้รับการผ่านการโต้แย้งพิเศษ (ตามคำตอบอื่น ๆ ได้ชี้ให้เห็น) แต่งูหลามทำให้ชัดเจนกว่าภาษาส่วนใหญ่
# perfectly normal function
def hello(greetee):
print "Hello", greetee
# generalise a bit (still a function though)
def greet(greeting, greetee):
print greeting, greetee
# hide the greeting behind a layer of abstraction (still a function!)
def greet_with_greeter(greeter, greetee):
print greeter.greeting, greetee
# very simple class we can pass to greet_with_greeter
class Greeter(object):
def __init__(self, greeting):
self.greeting = greeting
# while we're at it, here's a method that uses self.greeting...
def greet(self, greetee):
print self.greeting, greetee
# save an object of class Greeter for later
hello_greeter = Greeter("Hello")
# now all of the following print the same message
hello("World")
greet("Hello", "World")
greet_with_greeter(hello_greeter, "World")
hello_greeter.greet("World")
ตอนนี้เปรียบเทียบฟังก์ชั่นgreet_with_greeter
และวิธีการgreet
: ความแตกต่างเพียงอย่างเดียวคือชื่อของพารามิเตอร์แรก (ในฟังก์ชั่นที่ฉันเรียกว่า "greeter" ในวิธีที่ฉันเรียกมันว่า "ตัวเอง") ดังนั้นฉันสามารถใช้greet
วิธีการในลักษณะเดียวกับที่ฉันใช้greet_with_greeter
ฟังก์ชั่น (ใช้ไวยากรณ์ "จุด" เพื่อรับมันตั้งแต่ฉันกำหนดไว้ในชั้นเรียน):
Greeter.greet(hello_greeter, "World")
ดังนั้นฉันจึงเปลี่ยนวิธีเป็นฟังก์ชันได้อย่างมีประสิทธิภาพ ฉันสามารถเปลี่ยนฟังก์ชั่นเป็นวิธีการได้หรือไม่? Python ช่วยให้คุณสามารถยุ่งกับคลาสหลังจากที่กำหนดไว้แล้วลองทำดู:
Greeter.greet2 = greet_with_greeter
hello_greeter.greet2("World")
ใช่ฟังก์ชั่นอยู่ในขณะนี้ยังเป็นที่รู้จักวิธีการgreet_with_greeter
greet2
นี้แสดงให้เห็นความแตกต่างเพียงจริงระหว่างวิธีการและฟังก์ชั่น: เมื่อคุณเรียกวิธีการ "กับ" วัตถุโดยการเรียกภาษาที่น่าอัศจรรย์เปลี่ยนมันเป็นobject.method(args)
method(object, args)
(OO purists อาจแย้งว่าเมธอดเป็นสิ่งที่แตกต่างจากฟังก์ชั่นและถ้าคุณเข้าสู่ Python หรือ Ruby ขั้นสูง - หรือ Smalltalk! - คุณจะเริ่มเห็นประเด็นของพวกเขานอกจากนี้บางภาษาให้วิธีการเข้าถึงบิตของวัตถุเป็นพิเศษ ความแตกต่างทางแนวคิดหลักยังคงเป็นพารามิเตอร์พิเศษที่ซ่อนอยู่)
สำหรับฉัน: ฟังก์ชั่นของวิธีการและฟังก์ชั่นจะเหมือนกันถ้าฉันยอมรับว่า:
เช่นเดียวกับรหัสชิ้นใด ๆ ที่คุณอาจมีวัตถุที่คุณใส่และคุณอาจมีวัตถุที่เป็นผลมา ในระหว่างการทำเช่นนั้นพวกเขาอาจเปลี่ยนสถานะของวัตถุ แต่จะไม่เปลี่ยนการทำงานพื้นฐานของพวกเขาสำหรับฉัน
อาจมีคำจำกัดความที่แตกต่างกันในการเรียกใช้ฟังก์ชันของวัตถุหรือรหัสอื่น ๆ แต่นั่นไม่ใช่สิ่งที่ทำให้เกิดความแตกต่างด้วยวาจาและนั่นคือสาเหตุที่ผู้คนแลกเปลี่ยนกัน ตัวอย่างที่กล่าวถึงการคำนวณที่ฉันจะระวังด้วย เพราะฉันจ้างพนักงานทำการคำนวณของฉัน:
new Employer().calculateSum( 8, 8 );
ด้วยการทำเช่นนั้นฉันสามารถวางใจนายจ้างที่รับผิดชอบการคำนวณได้ หากเขาต้องการเงินมากขึ้นฉันจะปล่อยให้เขาเป็นอิสระและปล่อยให้หน้าที่ของตัวเก็บรวบรวมขยะในการกำจัดพนักงานที่ไม่ได้ใช้ทำส่วนที่เหลือและรับพนักงานใหม่
แม้การโต้เถียงว่าวิธีการเป็นฟังก์ชั่นวัตถุและฟังก์ชั่นไม่ได้คำนวณการเชื่อมต่อจะไม่ช่วยฉัน ตัวบ่งชี้ฟังก์ชันเองและเอกสารของฟังก์ชันจะบอกฉันว่ามันต้องการอะไรและมันจะกลับมาอย่างไร ส่วนที่เหลือเช่นการจัดการสถานะของวัตถุบางอย่างไม่โปร่งใสสำหรับฉัน ฉันคาดหวังว่าทั้งฟังก์ชั่นและวิธีการในการส่งมอบและจัดการสิ่งที่พวกเขาเรียกร้องโดยไม่จำเป็นต้องรู้รายละเอียดวิธีการที่พวกเขาทำมัน แม้แต่ฟังก์ชั่นการคำนวณล้วนๆก็อาจเปลี่ยนสถานะของคอนโซลหรือผนวกเข้ากับล็อกไฟล์
อย่าไปยุ่งกับสิ่งที่ควรเป็นคำตอบที่ง่ายมาก วิธีการและฟังก์ชั่นเป็นสิ่งเดียวกัน คุณเรียกใช้ฟังก์ชันเป็นฟังก์ชันเมื่ออยู่นอกคลาสและคุณเรียกใช้ฟังก์ชันเมื่อมีการเขียนฟังก์ชันภายในคลาส
จากความเข้าใจของฉันวิธีการคือการดำเนินการใด ๆ ที่สามารถทำได้ในชั้นเรียน มันเป็นคำทั่วไปที่ใช้ในการเขียนโปรแกรม
ในหลายภาษาวิธีแสดงโดยฟังก์ชั่นและรูทีนย่อย ความแตกต่างหลักที่ภาษาส่วนใหญ่ใช้สำหรับสิ่งเหล่านี้คือฟังก์ชั่นอาจคืนค่ากลับไปยังผู้โทรและรูทีนย่อยอาจไม่ อย่างไรก็ตามภาษาสมัยใหม่จำนวนมากมีฟังก์ชั่นเท่านั้น แต่สิ่งเหล่านี้สามารถเลือกที่จะไม่คืนค่าใด ๆ
ตัวอย่างเช่นสมมติว่าคุณต้องการอธิบายแมวและคุณต้องการให้หาวได้ คุณจะสร้างคลาส Cat ด้วยเมธอด Yawn ซึ่งส่วนใหญ่จะเป็นฟังก์ชันโดยไม่มีค่าส่งคืน
ในการประมาณคำสั่งแรกวิธีการ (ใน C ++ style OO) เป็นคำอื่นสำหรับฟังก์ชันสมาชิกนั่นคือฟังก์ชันที่เป็นส่วนหนึ่งของคลาส
ในภาษาอย่าง C / C ++ คุณสามารถมีฟังก์ชั่นที่ไม่ใช่สมาชิกของคลาสได้ คุณไม่เรียกใช้ฟังก์ชันที่ไม่เกี่ยวข้องกับคลาสในเมธอด
ฟังก์ชั่นเป็นแนวคิดส่วนใหญ่เป็นของการเขียนโปรแกรมเชิงขั้นตอนที่ฟังก์ชั่นเป็นนิติบุคคลที่สามารถประมวลผลข้อมูลและส่งกลับคุณค่าของคุณ
เมธอดคือแนวคิดของการเขียนโปรแกรม Object Orientedโดยที่เมธอดเป็นสมาชิกของคลาสซึ่งส่วนใหญ่ทำการประมวลผลกับสมาชิกคลาส
ผู้คน IMHO ต้องการประดิษฐ์คำใหม่เพื่อการสื่อสารที่ง่ายขึ้นระหว่างโปรแกรมเมอร์เมื่อพวกเขาต้องการอ้างถึงฟังก์ชั่นภายในวัตถุ
หากคุณกำลังพูดถึงวิธีการที่คุณหมายถึงฟังก์ชั่นภายในชั้นเรียน หากคุณกำลังพูดฟังก์ชั่นคุณหมายถึงฟังก์ชั่นที่อยู่นอกชั้นเรียน
ความจริงก็คือคำทั้งสองนี้ใช้เพื่ออธิบายฟังก์ชั่น แม้ว่าคุณจะใช้มันผิดไม่มีอะไรผิดปกติเกิดขึ้น ทั้งสองคำอธิบายสิ่งที่คุณต้องการให้สำเร็จในโค้ดของคุณ
ฟังก์ชั่นเป็นรหัสที่มีบทบาท ( ฟังก์ชั่น ) ในการทำบางสิ่งบางอย่าง วิธีการเป็นวิธีการแก้ไขปัญหา
มันทำสิ่งเดียวกัน มันเป็นสิ่งเดียวกัน หากคุณต้องการความแม่นยำสูงสุดและไปพร้อมกับการประชุมคุณสามารถเรียกวิธีการเป็นฟังก์ชันภายในวัตถุ
ฉันไม่ใช่ผู้เชี่ยวชาญ แต่นี่คือสิ่งที่ฉันรู้:
ฟังก์ชั่นเป็นคำภาษา C มันหมายถึงชิ้นส่วนของรหัสและชื่อฟังก์ชั่นจะเป็นตัวระบุที่จะใช้ฟังก์ชั่นนี้
เมธอดคือเทอม OO โดยทั่วไปจะมีตัวชี้นี้ในพารามิเตอร์ฟังก์ชัน คุณไม่สามารถเรียกใช้รหัสชิ้นนี้เช่น C คุณต้องใช้วัตถุเพื่อเรียกใช้
วิธีการเรียกใช้ยังแตกต่างกัน ที่นี่เรียกใช้ความหมายเพื่อค้นหาที่อยู่ของรหัสชิ้นนี้ C / C ++, เวลาการเชื่อมโยงจะใช้สัญลักษณ์ฟังก์ชั่นเพื่อค้นหา
Objecive-C นั้นแตกต่างกัน เรียกใช้หมายถึงฟังก์ชั่น C เพื่อใช้โครงสร้างข้อมูลเพื่อค้นหาที่อยู่ มันหมายความว่าทุกอย่างเป็นที่รู้จักในเวลาทำงาน
ฉันรู้ว่าคนอื่น ๆ ตอบแล้ว แต่ฉันพบว่าการตอบกลับเป็นคำตอบบรรทัดเดียวที่เรียบง่ายและมีประสิทธิภาพ แม้ว่ามันจะดูไม่ดีกว่าคำตอบของคนอื่นที่นี่ แต่ถ้าคุณอ่านอย่างระมัดระวังมันก็มีทุกสิ่งที่คุณจำเป็นต้องรู้เกี่ยวกับเมธอด vs ฟังก์ชั่น
วิธีการคือฟังก์ชั่นที่มีผู้รับที่กำหนดไว้ในเงื่อนไข OOP วิธีการคือฟังก์ชั่นในอินสแตนซ์ของวัตถุ
จากการอ่านเอกสารนี้บน Microsoft
สมาชิกที่มีรหัสที่สามารถเรียกใช้งานได้นั้นเป็นที่รู้จักกันในชื่อฟังก์ชั่นสมาชิกของคลาส ส่วนก่อนหน้านี้จะอธิบายวิธีการต่างๆซึ่งเป็นสมาชิกฟังก์ชันประเภทหลัก ส่วนนี้อธิบายถึงสมาชิกฟังก์ชันประเภทอื่น ๆ ที่สนับสนุนโดย C #: constructors, คุณสมบัติ, indexers, events, operator และ finalizers
ดังนั้นเมธอดจึงเป็นเซตย่อยของฟังก์ชัน ทุกวิธีเป็นฟังก์ชั่น แต่ไม่ใช่ทุกฟังก์ชั่นเป็นวิธีตัวอย่างเช่นconstructor
ไม่สามารถพูดได้ว่าเป็นวิธีการแต่เป็นฟังก์ชั่น
ฟังก์ชั่น - ฟังก์ชั่นในส่วนที่เป็นอิสระของรหัสซึ่งรวมถึงตรรกะบางอย่างและจะต้องเรียกว่าเป็นอิสระ และมีการกำหนดนอกชั้นเรียน
วิธีการ - วิธีการคือชิ้นส่วนอิสระของรหัสที่เรียกว่าในการอ้างอิงถึงวัตถุบางอย่างและมีการกำหนดไว้ในชั้นเรียน
นี่คือคำอธิบายสำหรับวิธีการและฟังก์ชั่นโดยใช้ตัวอย่าง JavaScript:
test(20, 50);
ฟังก์ชั่นกำหนดและใช้เพื่อเรียกใช้บางขั้นตอนหรือคืนบางสิ่งบางอย่างกลับที่สามารถเก็บ / ใช้ที่ไหนสักแห่ง
คุณสามารถใช้รหัสซ้ำได้: กำหนดรหัสหนึ่งครั้งและใช้หลายครั้ง
คุณสามารถใช้รหัสเดียวกันหลาย ๆ ครั้งด้วยอาร์กิวเมนต์ที่ต่างกันเพื่อให้ได้ผลลัพธ์ที่แตกต่างกัน
var x = myFunction(4, 3); // Function is called, return value will end up in x
function myFunction(a, b) {
return a * b; // Function returns the product of a and b
}
var test = something.test();
ทดสอบที่นี่ () สามารถเป็นวิธีการของวัตถุบางอย่างหรือกำหนดเองต้นแบบสำหรับวัตถุ inbuilt นี่คือคำอธิบายเพิ่มเติม:
วิธีการจาวาสคริปต์คือการกระทำที่สามารถดำเนินการกับวัตถุ
เมธอด JavaScript เป็นคุณสมบัติที่มีนิยามฟังก์ชัน
คุณสมบัติ / วิธีการสำหรับสตริงใน javascript:
var message = "Hello world!";
var x = message.toUpperCase();
//Output: HELLO WORLD!
ตัวอย่างที่กำหนดเอง:
function person(firstName, lastName, age, eyeColor) {
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
this.eyeColor = eyeColor;
this.changeName = function (name) {
this.lastName = name;
};
}
something.changeName("SomeName"); //This will change 'something' objject's name to 'SomeName'
คุณสามารถกำหนดคุณสมบัติสำหรับ String, Array และอื่น ๆ ได้เช่นกัน
String.prototype.distance = function (char) {
var index = this.indexOf(char);
if (index === -1) {
console.log(char + " does not appear in " + this);
} else {
console.log(char + " is " + (this.length - index) + " characters from the end of the string!");
}
};
var something = "ThisIsSomeString"
// now use distance like this, run and check console log
something.distance("m");
บางอ้างอิง: วิธีวัตถุ Javascript , ฟังก์ชั่น , ข้อมูลเพิ่มเติมเกี่ยวกับต้นแบบ
TL; DR
ฟังก์ชั่นเป็นส่วนหนึ่งของรหัสที่จะเรียกใช้
วิธีการคือฟังก์ชั่นภายในวัตถุ
ตัวอย่างของฟังก์ชั่น:
function sum(){
console.log("sum")l
}
ตัวอย่างของวิธีการ:
const obj = {
a:1,
b:2,
sum(){
}
}
ดังนั้นทำไมเราบอกว่าคำสำคัญ "นี่" ในฟังก์ชั่นไม่ได้มีประโยชน์มากถ้าเราใช้กับการโทร, ใช้หรือผูก .. เพราะการโทร, ใช้, ผูกจะเรียกว่าฟังก์ชั่นเป็นวิธีการภายในวัตถุ ==> โดยทั่วไปมัน แปลงฟังก์ชั่นเป็นวิธีการ
พวกเขามักจะใช้แทนกันได้ แต่วิธีการมักจะหมายถึงรูทีนย่อยในชั้นเรียนและฟังก์ชั่นมักจะหมายถึงรูทีนย่อยนอกชั้นเรียน ตัวอย่างเช่นใน Ruby:
# function
def putSqr(a)
puts a ** 2
end
class Math2
# method
def putSqr(a)
puts a ** 2
end
end
ใน Java ที่ทุกอย่าง (ยกเว้นแพ็คเกจและคำสั่งนำเข้า) จะต้องอยู่ในชั้นเรียนผู้คนมักจะอ้างถึงพวกเขาว่า "วิธีการ"