บางคนสามารถให้คำอธิบายง่ายๆเกี่ยวกับวิธีการเทียบกับฟังก์ชั่นในบริบทของ OOP ได้หรือไม่?

ฟังก์ชั่นเป็นชิ้นส่วนของรหัสที่เรียกตามชื่อ สามารถส่งผ่านข้อมูลเพื่อดำเนินการ (เช่นพารามิเตอร์) และสามารถเลือกส่งคืนข้อมูล (ค่าส่งคืน) ข้อมูลทั้งหมดที่ส่งผ่านไปยังฟังก์ชันจะถูกส่งผ่านอย่างชัดเจน

วิธีเป็นชิ้นส่วนของรหัสที่เรียกตามชื่อที่เกี่ยวข้องกับวัตถุ โดยส่วนใหญ่มันจะเหมือนกับฟังก์ชั่นยกเว้นความแตกต่างที่สำคัญสองประการ:

1. วิธีการจะผ่านวัตถุโดยปริยายซึ่งมันถูกเรียก
2. วิธีการสามารถดำเนินการกับข้อมูลที่มีอยู่ในชั้นเรียน (จำได้ว่าวัตถุเป็นตัวอย่างของคลาส - คลาสเป็นคำจำกัดความวัตถุเป็นตัวอย่างของข้อมูลนั้น)

(นี่เป็นคำอธิบายที่ง่ายขึ้นละเว้นปัญหาขอบเขตฯลฯ )

วิธีการอยู่บนวัตถุ
ฟังก์ชั่นเป็นอิสระจากวัตถุ

สำหรับ Java และ C # มีวิธีการเท่านั้น
สำหรับ C มีฟังก์ชั่นเท่านั้น

สำหรับ C ++ และ Python มันจะขึ้นอยู่กับว่าคุณอยู่ในชั้นเรียนหรือไม่

'วิธีการ'เป็นคำเชิงวัตถุสำหรับฟังก์ชั่น ' นั่นคือทั้งหมดที่มีอยู่ (เช่นไม่มีความแตกต่างที่แท้จริง)

น่าเสียดายที่ฉันคิดว่าคำตอบมากมายที่นี่ยืดเยื้อหรือทำให้ความคิดก้าวหน้าขึ้นว่ามีความแตกต่างที่ซับซ้อนและมีความหมาย

จริง ๆ - มีไม่มากไปแค่คำที่แตกต่างกันสำหรับสิ่งเดียวกัน

[ปลายสาย]

ในความเป็นจริงเป็นไบรอันโอนีชี้ให้เห็นในความคิดเห็นคำถามนี้มาตรฐาน C ++ ไม่เคยใช้คำว่า 'วิธี' เมื่ออ้างถึงฟังก์ชั่นสมาชิก บางคนอาจใช้เป็นข้อบ่งชี้ว่า C ++ ไม่ใช่ภาษาเชิงวัตถุ อย่างไรก็ตามฉันชอบที่จะใช้เป็นตัวบ่งชี้ว่าคนฉลาดกลุ่มสวยไม่คิดว่ามีเหตุผลที่ดีโดยเฉพาะอย่างยิ่งที่จะใช้คำที่แตกต่างกัน

โดยทั่วไป: เมธอดคือฟังก์ชันที่เป็นของคลาสฟังก์ชันสามารถอยู่ในขอบเขตอื่น ๆ ของรหัสเพื่อให้คุณสามารถระบุว่าวิธีการทั้งหมดเป็นฟังก์ชัน แต่ไม่ใช่ทุกฟังก์ชันที่เป็นวิธีการ:

ใช้ตัวอย่างไพ ธ อนต่อไปนี้:

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" สำหรับสิ่งที่ไม่ได้อยู่ในคลาสใด ๆ เนื่องจากทั้งมนุษย์และสุนัขสามารถเลี้ยงได้และคุณสามารถเรียกมันได้ว่าฟังก์ชั่นนั้นไม่ได้อยู่ในคลาสใดโดยเฉพาะ

วิธีง่ายๆในการจดจำ:

• F unction → F ree (ฟรีหมายถึงไม่ได้เป็นของวัตถุหรือคลาส)
• M ethod → M ember (สมาชิกของวัตถุหรือคลาส)

คำจำกัดความทั่วไปของความแตกต่างหลักระหว่างฟังก์ชั่นและวิธีการ :

ฟังก์ชั่นถูกกำหนดไว้นอกชั้นเรียนในขณะที่วิธีการที่กำหนดไว้ภายในและเป็นส่วนหนึ่งของชั้นเรียน

หากคุณรู้สึกว่าการอ่านที่นี่คือ "การแนะนำวิธีการ 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 ()"

โดยปกติแล้ววิธีการยังได้รับคุณสมบัติพิเศษบางอย่างที่อธิบายพฤติกรรมของพวกเขาภายในวัตถุ / ชั้นเรียนเช่น: การมองเห็น (เกี่ยวข้องกับแนวคิดเชิงวัตถุของการห่อหุ้ม) ซึ่งกำหนดจากวัตถุ (หรือชั้นเรียน) วิธีการที่สามารถเรียก

ในภาษาเชิงวัตถุจำนวนมาก "ฟังก์ชั่น" ทั้งหมดเป็นของวัตถุ (หรือคลาส) ดังนั้นในภาษาเหล่านี้จึงไม่มีฟังก์ชั่นที่ไม่ใช่วิธีการ

เมธอดคือฟังก์ชันของคลาส ในศัพท์แสงปกติคนแลกเปลี่ยนวิธีการและฟังก์ชั่นทั่ว โดยพื้นฐานแล้วคุณสามารถนึกถึงสิ่งเหล่านี้ในลักษณะเดียวกัน (ไม่แน่ใจว่าฟังก์ชันระดับโลกเรียกว่าวิธีการ)

http://en.wikipedia.org/wiki/Method_(computer_science)

ฟังก์ชั่นเป็นแนวคิดทางคณิตศาสตร์ ตัวอย่างเช่น:

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 ไม่เช่นนั้นคุณจะดูงี่เง่า

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 ต้องการประดิษฐ์คำใหม่เพื่อการสื่อสารที่ง่ายขึ้นระหว่างโปรแกรมเมอร์เมื่อพวกเขาต้องการอ้างถึงฟังก์ชั่นภายในวัตถุ

หากคุณกำลังพูดถึงวิธีการที่คุณหมายถึงฟังก์ชั่นภายในชั้นเรียน หากคุณกำลังพูดฟังก์ชั่นคุณหมายถึงฟังก์ชั่นที่อยู่นอกชั้นเรียน

ความจริงก็คือคำทั้งสองนี้ใช้เพื่ออธิบายฟังก์ชั่น แม้ว่าคุณจะใช้มันผิดไม่มีอะไรผิดปกติเกิดขึ้น ทั้งสองคำอธิบายสิ่งที่คุณต้องการให้สำเร็จในโค้ดของคุณ

ฟังก์ชั่นเป็นรหัสที่มีบทบาท ( ฟังก์ชั่น ) ในการทำบางสิ่งบางอย่าง วิธีการเป็นวิธีการแก้ไขปัญหา

มันทำสิ่งเดียวกัน มันเป็นสิ่งเดียวกัน หากคุณต้องการความแม่นยำสูงสุดและไปพร้อมกับการประชุมคุณสามารถเรียกวิธีการเป็นฟังก์ชันภายในวัตถุ

ฉันไม่ใช่ผู้เชี่ยวชาญ แต่นี่คือสิ่งที่ฉันรู้:

1. ฟังก์ชั่นเป็นคำภาษา C มันหมายถึงชิ้นส่วนของรหัสและชื่อฟังก์ชั่นจะเป็นตัวระบุที่จะใช้ฟังก์ชั่นนี้

2. เมธอดคือเทอม OO โดยทั่วไปจะมีตัวชี้นี้ในพารามิเตอร์ฟังก์ชัน คุณไม่สามารถเรียกใช้รหัสชิ้นนี้เช่น C คุณต้องใช้วัตถุเพื่อเรียกใช้

3. วิธีการเรียกใช้ยังแตกต่างกัน ที่นี่เรียกใช้ความหมายเพื่อค้นหาที่อยู่ของรหัสชิ้นนี้ C / C ++, เวลาการเชื่อมโยงจะใช้สัญลักษณ์ฟังก์ชั่นเพื่อค้นหา

4. 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 ที่ทุกอย่าง (ยกเว้นแพ็คเกจและคำสั่งนำเข้า) จะต้องอยู่ในชั้นเรียนผู้คนมักจะอ้างถึงพวกเขาว่า "วิธีการ"