有人可以在OOP上下文中提供方法與功能的簡單說明嗎？

#1樓

對我來說：如果我同意：方法的功能和函數的功能是相同的：

一個函數可能傳回一個值
可能期望參數

就像任何一段代碼一樣，您可能要放入對象，結果可能會有對象。在這樣做的過程中，它們可能會更改對象的狀态，但不會更改它們的基本功能。

對象或其他代碼的調用函數可能存在定義差異。但這不是語言差別的原因，這就是人們互換它們的原因嗎？我會小心地提到計算示例。因為我雇用了員工來進行計算：

new Employer().calculateSum( 8, 8 );

通過這種方式，我可以依靠雇主負責計算。如果他想要更多的錢，我就釋放他，讓垃圾收集員處理未使用的雇員的職能剩下來，然後再找一個新雇員。

即使争論一個方法是一個對象函數而一個函數是未連接配接的計算對我也沒有幫助。函數描述符本身以及理想情況下的函數文檔将告訴我它需要什麼以及它可能傳回什麼。其餘的，比如操縱某些對象的狀态，對我來說并不是真正透明的。我确實希望函數和方法都可以傳遞和操縱他們所要求的内容，而無需詳細了解他們是如何做到的。即使是純計算功能也可能會更改控制台的狀态或附加到日志檔案。

#2樓

“方法”是“功能”的面向對象的單詞。這幾乎就是它的全部（即，沒有真正的差別）。

不幸的是，我認為這裡的許多答案可以使存在某些複雜的，有意義的差異的想法永存或發展。

真的-沒有太多的東西，隻是同一件事的不同詞。

[後期補充]

實際上，正如Brian Neal在對此問題的評論中指出的那樣，C ++标準在引用成員函數時從不使用術語“方法”。有人可能會認為這表明C ++并不是真正的面向對象的語言。但是，我更傾向于将其作為一種訓示，即相當聰明的一群人認為沒有特别強烈的理由使用另一個術語。

#3樓

方法在對象上。

功能獨立于對象。

對于Java，隻有方法。

對于C，隻有功能。

對于C ++，這取決于您是否在課堂上。

#4樓

方法是類的功能。用普通的術語來說，人們總是在交換方法和功能。基本上，您可以将它們視為同一件事（不确定全局函數是否稱為方法）。

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

#5樓

根據我的了解，方法是可以在類上執行的任何操作。它是程式設計中的通用術語。

在許多語言中，方法由函數和子例程表示。大多數語言為此使用的主要差別在于，函數可以将值傳回給調用者，而子例程則不能。但是，許多現代語言僅具有函數，但是這些函數可以選擇不傳回任何值。

例如，假設您想描述一隻貓，并且希望它能打哈欠。您将建立一個帶有Yawn方法的Cat類，該方法很可能是沒有任何傳回值的函數。

#6樓

假設一個函數是一塊代碼塊（通常具有自己的作用域，有時帶有自己的閉包），可以接收一些自變量并且還可以傳回結果。

方法是對象所擁有的功能（在某些面向對象的系統中，更确切地說它是類所擁有的）。被對象/類“擁有”意味着您通過對象/類來引用該方法。例如，在Java中，如果要調用對象“門”擁有的方法“ open（）”，則需要編寫“ door.open（）”。

通常，方法還會獲得一些額外的屬性來描述它們在對象/類中的行為，例如：可見性（與封裝的面向對象概念有關），它定義了可以從哪些對象（或類）中調用該方法。

在許多面向對象的語言中，所有“功能”都屬于某個對象（或類），是以在這些語言中，沒有不屬于方法的功能。

#7樓

在OO世界中，兩者通常用來表示同一件事。

從純Math和CS的角度來看，使用相同的參數（f（x，y）=（x + y））調用時，函數将始終傳回相同的結果。另一方面，方法通常與類的執行個體相關聯。同樣，大多數現代的OO語言在大多數情況下不再使用術語“功能”。許多靜态方法可以像函數一樣，因為它們通常沒有狀态（并不總是為真）。

#8樓

類上的方法作用于該類的執行個體（稱為對象）。

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"
   }
}

#9樓

在諸如對象Pascal或C ++之類的OO語言中，“方法”是與對象關聯的功能。是以，例如，“狗”對象可能具有“吠叫”功能，是以将其視為“方法”。相反，“ StrLen”函數是單獨存在的（它提供了作為參數提供的字元串的長度）。是以，它隻是一個“功能”。從技術上講，JavaScript也是面向對象的，但是與成熟的語言（如C ++，C＃或Pascal）相比，JavaScript面臨許多限制。盡管如此，差別仍然應保持。

還有兩個事實：C＃是完全面向對象的，是以您不能建立獨立的“函數”。在C＃中，每個函數都綁定到一個對象，是以從技術上講，它是一種“方法”。更重要的是，在C＃中很少有人将它們稱為“方法”，他們隻是使用“函數”一詞，因為沒有任何真正的差別。

最後，Pascal專家也區分了“函數”（傳回值）和“過程”（沒有傳回值），是以，任何Pascal專家都不會在這裡碰到我。盡管您可以選擇是否傳回值，但是C＃并未明确區分這種差別。

#10樓

對于一階近似而言，方法（C ++樣式OO）是成員函數的另一個詞，該成員函數是類的一部分。

在像C / C ++這樣的語言中，您可以具有一些不是類成員的函數；您不會将與類無關的函數稱為方法。

#11樓

函數是按名稱調用的一段代碼。可以傳遞資料以對其進行操作（即參數），還可以選擇傳回資料（傳回值）。傳遞給函數的所有資料都被顯式傳遞。

方法是一段與對象關聯的名稱所調用的代碼。在大多數方面，它與功能相同，但有兩個主要差別：

方法被隐式傳遞給調用該方法的對象。
方法能夠對類中包含的資料進行操作（記住，對象是類的執行個體-類是定義，對象是該資料的執行個體）。

（這是一個簡化的解釋，忽略了範圍問題等。）

#12樓

如果您想在這裡閱讀“我對OO方法的介紹”

面向對象範例背後的思想是“威脅”該軟體由..好“對象”組成。現實世界中的對象具有屬性，例如，如果您有一個Employee，該雇員具有姓名，雇員ID，職位，他屬于部門等，等等。

該對象還知道如何處理其屬性并對其執行一些操作。假設我們想知道某個員工現在在做什麼，我們會問他。

employe whatAreYouDoing.

“ whatAreYouDoing”是發送給對象的“消息”。對象知道如何回答該問題，據說它具有解決該問題的“方法”。

是以，對象必須公開其行為的方式稱為方法。是以，方法是工件對象必須“做”某事。

其他可能的方法是

employee whatIsYourName
employee whatIsYourDepartmentsName

等等

另一方面，函數是程式設計語言計算某些資料的方式，例如，您可能具有傳回16的函數addValues（8，8）

// 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中以前的Employee對象的示例。

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具有“自然語言”的概念，這在OO上已經有了。例如Smalltalk。我希望您閱讀此書後，可能更容易了解對象中的方法。

注意：該代碼不是要編譯，僅作為示例。随時修改文章并添加Python示例。

#13樓

通常，方法是屬于類的函數，函數可以在代碼的任何其他範圍内，是以您可以聲明所有方法都是函數，但并非所有函數都是方法：

以以下python示例為例：

class Door:
  def open(self):
    print 'hello stranger'

def knock_door:
  a_door = Door()
  Door.open(a_door)

knock_door()

給定的示例向您顯示了一個名為“ Door”的類，該類具有一個稱為“ open”的方法或動作，由于其在類内聲明，是以被稱為“方法”。在代碼的下面還有另一部分“ def”定義了一個函數，它是一個函數，因為它沒有在類中聲明，您可以看到該函數調用在類中定義的方法，最後該函數被自己叫。

如您所見，您可以在任何地方調用函數，但如果要調用方法，則必須傳遞與聲明該方法的類相同類型的新對象（Class.method（object）），或者必須調用對象内部的方法（object.Method（）），至少在python中。

将方法視為隻有一個實體可以做的事情，是以，如果您有一個Dog類，則僅在該類内部具有樹皮函數是有意義的，那将是一種方法；如果您也具有Person類，則對編寫一個不屬于任何類别的函數“ feed”，因為人類和狗都可以被喂食，您可以調用該函數，因為它特别不屬于任何類别。

#14樓

函數是數學概念。例如：

f(x,y) = sin(x) + cos(y)

表示函數f（）将傳回添加到第二個參數餘弦的第一個參數的正弦值。這隻是數學。碰巧sin（）和cos（）也是函數。函數具有另一個屬性：對具有相同參數的函數的所有調用應傳回相同的結果。

另一方面，方法是與面向對象語言中的對象相關的功能。它有一個隐式參數：作用于對象（及其狀态）。

是以，如果您的對象Z具有方法g（x），則可能會看到以下内容：

Z.g(x) = sin(x) + cos(Z.y)

在這種情況下，與前面的函數示例相同，将傳入參數x。但是，cos（）的參數是一個位于對象Z内的值。Z和其内的資料（Zy）是Z的g（）方法的隐式參數。

#15樓

自從您提到Python之後，以下内容可能是大多數現代面向對象語言中方法與對象之間關系的有用說明。簡而言之，他們所謂的“方法”隻是一個傳遞了額外參數的函數（正如其他答案所指出的那樣），但是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”，在方法中我稱為“ self”）。是以，我可以使用與

greet_with_greeter

函數完全相同的方法來使用

greet

方法（因為我在類中定義了它，是以使用了“點”文法）：

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純粹主義者可能會認為方法與函數有些不同，如果您使用進階Python或Ruby或Smalltalk ！，您将開始明白它們的用處。某些語言還使方法可以對對象的某些位進行特殊通路。但是主要的概念差異仍然是隐藏的多餘參數。）

#16樓

我不是專家，但這是我所知道的：

函數是C語言術語，指的是一段代碼，函數名稱将是使用此函數的辨別符。
方法是OO術語，通常在功能參數中具有this指針。您不能像C那樣調用這段代碼，需要使用object來調用它。
調用方法也不同。在這裡調用含義來找到這段代碼的位址。 C / C ++，連結時間将使用功能符号定位。
Objecive-C是不同的。調用的含義是C函數使用資料結構查找位址。這意味着在運作時一切都是已知的。

#17樓

函數或方法是一段可命名的可調用代碼，它執行一些操作并有選擇地傳回一個值。

在C語言中，使用術語功能。 Java和C＃人們會說它是一種方法（在這種情況下，一個函數是在類/對象中定義的）。

C ++程式員可能将其稱為函數或方法（取決于他們是編寫程式樣式的c ++代碼還是采用面向對象的C ++方式，而且僅C / C ++的程式員也可能将其稱為函數，因為術語“方法”是在C / C ++文獻中較少使用）。

您可以通過調用函數的名稱來使用它，例如，

result = mySum(num1, num2);

您可以通過先引用對象來調用方法，例如，

result = MyCalc.mySum(num1,num2);

#18樓

關于函數和方法之間主要差別的一個非常籠統的定義：

函數是在類外部定義的，而方法是在類内部和部分的内部定義的。

#19樓

恕我直言，人們隻是想發明一個新詞來簡化程式員在引用對象内部函數時的通信。

如果您說的是方法，則意味着在類内部使用函數。如果您說的是函數，則意味着僅是課堂外的函數。

事實是兩個詞都用來描述功能。即使您錯誤地使用了它，也不會發生任何錯誤。這兩個詞很好地描述了您想要在代碼中實作的目标。

函數是一種代碼，它必須起某些作用（一個函數）。方法是解決問題的一種方法。

它做同樣的事情。是同一回事。如果您想超精确并遵守約定，則可以将方法作為對象内部的函數來調用。

#20樓

函數是主要屬于面向過程的程式設計的概念，其中函數是可以處理資料并傳回值的實體

方法是面向對象程式設計的概念，其中方法是類的成員，該類主要對類成員進行處理。

#21樓

函數是一組可用于處理資料的邏輯。

而Method是用于處理其所屬對象的資料的函數。從技術上講，如果您有一個與您的類不完全相關但在類中聲明的函數，則它不是方法；這稱為不良設計。

#22樓

從曆史上看，“方法”是不傳回值的東西，而“功能”是不傳回值的東西，可能會有細微的差别。每種語言都有其自己的具有特殊含義的術語詞典。

在“ C”中，單詞“功能”表示程式例程。

在Java中，術語“函數”沒有任何特殊含義。而“方法”是指構成類的實作的例程之一。

在C＃中，它将轉換為：

public void DoSomething() {} // method
public int DoSomethingAndReturnMeANumber(){} // function

但實際上，我重申，這兩個概念确實沒有差別。如果您在有關Java的非正式讨論中使用“功能”一詞，人們會認為您的意思是“方法”并繼續下去。不要在有關Java的适當文檔或示範文稿中使用它，否則會顯得很傻。

#23樓

我知道許多其他人已經回答了，但是我發現以下是一個簡單而有效的單行答案。盡管它看起來并不比其他答案好很多，但是如果您仔細閱讀它，就可以了解方法與函數的所有知識。

方法是具有定義的接收方的函數，按OOP術語，方法是對象執行個體上的函數。

#24樓

在C ++中，有時，方法用于反映類的成員函數的概念。但是，最近我在第586頁“派生類”的《 C ++程式設計語言第四版》一書中找到了一條聲明。

虛函數有時稱為方法。

這有點令人困惑，但是他有時說，是以這很有意義，C ++建立者傾向于看到方法，因為函數可以在對象上調用并且可以表現為多态。

#25樓

這是一些使用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();

這裡的test（）可以是某些對象的方法，也可以是自定義定義内置對象的原型的方法，這裡有更多說明：

JavaScript方法是可以對對象執行的操作。

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等的屬性

一些參考： Javascript對象方法，函數，有關原型的更多資訊

#26樓

記住的簡單方法：

˚F油膏→˚FREE（免費意味着不屬于一個對象或類）
中号 ethod→M餘燼（對象或類的一個成員）

#27樓

讓我們不要過于複雜，這應該是一個非常簡單的答案。方法和功能是同一回事。當函數在類外部時，可以将其稱為函數，而在類内部寫入函數時，可以将其稱為方法。

#28樓

方法和功能之間的差異

通過閱讀有關Microsoft的文檔

包含可執行代碼的成員統稱為類的函數成員。上一節介紹了方法，它們是函數成員的主要種類。本節描述了C＃支援的其他類型的函數成員：構造函數，屬性，索引器，事件，運算符和終結器。

是以，方法是功能的子集。每個方法都是一個函數，但并非每個函數都是一個方法，例如，不能将

constructor

稱為方法，而是一個函數。

#29樓

類是一些資料和函數的集合，可以選擇使用構造函數。

在建立該特定類的執行個體（副本，複制）時，構造函數将初始化該類并傳回一個對象。

現在，該類成為對象（沒有構造函數），而函數在對象上下文中稱為方法。

是以基本上

類<== new ==> Object

函數<== new ==>方法

在Java中，通常将其告知構造函數名稱與類名稱相同，但實際上，構造函數就像執行個體塊和靜态塊一樣，但是需要使用者定義傳回類型（即Class類型）

雖然類可以具有靜态塊，執行個體塊，構造函數，函數，但對象通常僅具有資料和方法。

#30樓

函數-獨立代碼中的函數，其中包含一些邏輯，必須獨立調用并在類外部定義。

方法-方法是一段獨立的代碼，它參考某個對象而調用，并在類内部定義。

方法和函數有什麼差別？ 方法和功能之間的差異

#1樓

#2樓

#3樓

#4樓

#5樓

#6樓

#7樓

#8樓

#9樓