小开

方法是函数的面向对象单词。这几乎就是它的全部内容（即，没有真正的区别）。

不幸的是，我认为这里的很多答案都在延续或推进这样一种观点，即存在一些复杂而有意义的差异。

真的-没有那么多，只是同一事物的不同单词。

[后期添加]

事实上，正如brianneal在对这个问题的注释中指出的那样，C++标准在引用成员函数时从不使用术语“方法”。有些人可能认为这表明C++不是真正的面向对象语言；然而，我更愿意认为这表明一群相当聪明的人认为没有特别强烈的理由使用不同的术语。

小开

方法位于对象上或在类中是静态的。
函数独立于任何对象（并且在任何类之外）。

对于Java和C#，只有方法。
对于C，只有函数。

对于C++和Python，这取决于你是否在一个类中。
基本英语：

函数：独立的特性或功能。
方法：做某事的一种方式，它有不同的方法或方法，但与相同的方面（又名类）相关。

小开

方法是类的函数。在正常的行话中，人们到处交换方法和函数。基本上你可以把它们想象成一回事（不确定全局函数是否称为方法）。

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

小开

在我的理解中，方法是可以在类上执行的任何操作。它是编程中使用的通用术语。

在许多语言中，方法由函数和子例程表示。大多数语言用于这些的主要区别是函数可能会将值返回给调用者，而子例程可能不会。然而，许多现代语言只有函数，但这些函数可以选择不返回任何值。

例如，假设你想描述一只猫，你希望它能够打哈欠。你将创建一个Cat类，带有一个Yawn方法，它很可能是一个没有任何返回值的函数。

小开

假设一个函数是一个代码块（通常有自己的作用域，有时有自己的闭包），它可以接收一些参数，也可以返回结果。

方法是一个由对象拥有的函数（在一些面向对象的系统中，更正确的说法是它由类拥有）。被对象/类“拥有”意味着你通过对象/类引用方法；例如，在Java如果你想调用一个由对象“门”拥有的方法“open（）”，你需要写“door.open（）”。

通常方法还会获得一些额外的属性来描述它们在对象/类中的行为，例如：可见性（与面向对象的封装概念有关），它定义了可以从哪些对象（或类）调用方法。

在许多面向对象语言中，所有“函数”都属于某个对象（或类），因此在这些语言中没有不是方法的函数。

小开

在OO世界中，两者通常用于表示同样的事情。

从纯数学和计算机科学的角度来看，一个函数在使用相同的参数（f（x， y）=（x+y））调用时总是会返回相同的结果。另一方面，一个方法通常与一个类的实例相关联。不过，大多数现代OO语言在大多数情况下不再使用“函数”一词。许多静态方法可能很像函数，因为它们通常没有状态（并不总是真的）。

小开

类的方法作用于类的实例，称为对象。

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

小开

在诸如Object Pascal或C++之类的面向对象语言中，“方法”是与对象关联的函数。因此，例如，“Dog”对象可能具有“bark”函数，这将被视为“方法”。相比之下，“StrLen”函数独立存在（它提供作为参数提供的字符串长度）。因此只是是“函数”。Javascript在技术上也是面向对象的，但与C++，C#或Pascal等成熟的语言相比面临许多限制。尽管如此，这种区别应该仍然存在。

一些额外的事实：C#是完全面向对象的，所以你不能创建独立的“函数”。在C#中，每个函数都绑定到一个对象，因此在技术上是一个“方法”。关键是C#中很少有人将它们称为“方法”-他们只是使用术语“函数”，因为没有任何真正的区别。

最后-只是为了让任何Pascal大师不要在这里跳到我身上-Pascal还区分了“函数”（返回值）和“过程”（不返回值）。C#没有明确做出这种区分，尽管您可以选择返回值或不返回值。

小开

对于一阶近似，方法（在C++风格的OO中）是成员函数的另一个词，即属于类的函数。

在像C/C++这样的语言中，你可以拥有不是类成员的函数；你不能将与类无关的函数称为方法。

小开

最佳答案

函数是一段按名称调用的代码。它可以传递要操作的数据（即参数），也可以选择返回数据（返回值）。传递给函数的所有数据都会显式传递。

方法是一段由与对象关联的名称调用的代码。在大多数情况下，它与函数相同，除了两个关键区别：

方法隐式传递调用它的对象。
方法能够对包含在类中的数据进行操作（记住对象是类的实例-类是定义，对象是该数据的实例）。

（这是一个简化的解释，忽略了范围等问题）

小开

面向对象范式背后的思想是“对待”软件是由…以及“对象”组成的。现实世界中的对象具有属性，例如，如果你有一个员工，该员工有一个姓名、员工ID、职位、他属于一个部门等。

对象还知道如何处理其属性并对其执行一些操作。假设我们想知道员工现在在做什么，我们会问他。

employe whatAreYouDoing.

那个“WhatareYouDo”是发送给对象的“消息”。对象知道如何回答这些问题，据说它有一个“方法”来解决这个问题。

因此，对象必须暴露其行为的方式称为方法。因此，方法是工件对象必须“做”某事。

其他可能的方法是

employee whatIsYourNameemployee whatIsYourDepartmentsName

等

另一方面，函数是编程语言计算某些数据的方式，例如，您可能有函数addValue（8,8）返回16

// pseudo-codefunction addValues( int x, int y )  return x + y// call itresult = addValues( 8,8 )print result // output is 16...

由于第一个流行的编程语言（如fortran、c、pascal）没有涵盖OO范式，它们只调用这些工件的“函数”。

例如，C中的前一个函数将是：

int addValues( int x, int y ){return x + y;}

说一个对象有一个“函数”来执行某些操作是不“自然”的，因为函数与数学的东西更相关，而员工几乎没有数学，但是你可以有与函数完全相同的方法，例如在Java这将是等价的addValws函数。

public static int addValues( int x, int y ) {return x + y;}

眼熟？那是因为JavaC++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 completnesspublic 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示例。

小开

一般来说：方法是属于类的函数，函数可以在代码的任何其他范围内，因此您可以声明所有方法都是函数，但并非所有函数都是方法：

以下面的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（对象）），或者你必须调用对象内部的方法（对象.方法（）），至少在python中是这样。

把方法想象成只有一个实体可以做的事情，所以如果你有一个Dog类，那么只在该类中有一个树皮函数是有意义的，这将是一个方法，如果你也有一个Person类，那么写一个函数“feed”是有意义的，因为它不属于任何类，因为人类和狗都可以被喂养，你可以称之为函数，因为它不属于任何特定的类。

小开

函数是一个数学概念。例如：

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

表示函数f（）将返回第一个参数的sin添加到第二个参数的余弦。这只是数学。碰巧sin（）和cos（）也是函数。函数有另一个属性：对具有相同参数的函数的所有调用都应该返回相同的结果。

另一方面，方法是与面向对象语言中的对象相关的函数。它有一个隐式参数：被操作的对象（及其状态）。

因此，如果您有一个带有方法g（x）的对象Z，您可能会看到以下内容：

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

在这种情况下，参数x被传入，与前面的函数示例中相同。但是，cos（）的参数是位于对象Z内的值。Z和位于其中的数据（Z. y）是Z的g（）方法的隐式参数。

小开

既然你提到了Python，下面可能是大多数现代面向对象语言中方法和对象之间关系的有用说明。简而言之，他们所谓的“方法”只是一个传递额外参数的函数（正如其他答案所指出的那样），但Python比大多数语言更明确。

# perfectly normal functiondef 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_greeterclass 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 laterhello_greeter = Greeter("Hello")
# now all of the following print the same messagehello("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_greeterhello_greeter.greet2("World")

是的，函数greet_with_greeter现在也被称为方法greet2。这显示了方法和函数之间唯一真正的区别：当你通过调用object.method(args)“on”对象调用方法时，语言神奇地将其变成了method(object, args)。

（面向对象纯粹主义者可能会认为方法与函数不同，如果你学习高级Python或Ruby-或Smalltalk！-你会开始明白他们的观点。此外，一些语言赋予方法对对象位的特殊访问权限。但主要的概念差异仍然是隐藏的额外参数。）

小开

函数是一组可用于操作数据的逻辑。

虽然，方法是用于操作它所属对象的数据的函数。所以从技术上讲，如果你有一个与你的类不完全相关但在类中声明的函数，它就不是一个方法；它被称为糟糕的设计。

小开

对我来说：方法和函数的函数是相同的，如果我同意：

一个函数可以返回一个值
可能期望参数

就像任何一段代码一样，你可能有你放入的对象，你可能会有一个结果出现的对象。在这样做的过程中，他们可能会改变对象的状态，但这不会改变他们对我的基本功能。

在调用对象或其他代码的函数时可能会有定义差异。但这不是口头差异的东西，这就是人们交换它们的原因吗？提到计算的例子我会小心的。因为我雇佣员工来做我的计算：

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

通过这样做，我可以依靠一个负责计算的雇主。如果他想要更多的钱，我就释放他，让垃圾收集者处理闲置员工的职能来做剩下的事情，并获得一个新员工。

即使争论一个方法是一个对象函数，一个函数是不连接的计算也帮不了我。函数描述符本身，理想情况下函数的留档会告诉我它需要什么和它可能返回什么。其余的，比如操纵一些对象的状态对我来说并不是很透明。我确实希望函数和方法都能传递和操纵他们声称的东西，而不需要详细知道它们是如何做到的。即使是纯计算函数也可能会更改控制台的状态或附加到日志文件中。

小开

我不是专家，但我知道：

函数是C语言术语，它指的是一段代码，函数名称将是使用该函数的标识符。

方法是OO术语，通常它在函数参数中有一个this指针。你不能像C一样调用这段代码，你需要使用对象来调用它。

调用方法也不同。这里调用的意思是找到这段代码的地址。C/C++，链接时将使用函数符号进行定位。

Objecive-C不同。调用意味着C函数使用数据结构来查找地址。这意味着在运行时一切都是已知的。

小开

函数或方法是一段命名的可调用代码，它执行一些操作并可选择返回一个值。

在C语言中使用术语函数。Java和c#人们会说它是一个方法（在这种情况下，函数是在类/对象中定义的）。

C++程序员可能会称它为函数或方法（取决于他们是编写过程风格c++代码还是以面向对象的方式C++，只有C/C++程序员可能会称它为函数，因为术语“方法”在C/C++文献中不太常用）。

你可以通过调用一个函数的名字来使用它，比如

result = mySum(num1, num2);

您可以通过首先引用其对象来调用方法，例如

result = MyCalc.mySum(num1,num2);

小开

函数和方法之间的主要区别的一个非常一般的定义：

函数在类之外定义，而方法在类内部和类的一部分中定义。

小开

恕我直言，当人们想要引用对象内部的函数时，他们只是想发明一个新词来方便程序员之间的交流。

如果你说的是方法，你的意思是类中的函数。如果你说的是函数，你的意思只是类之外的函数。

事实是，这两个词都用于描述函数。即使您使用错误，也不会发生任何错误。这两个词都很好地描述了您想在代码中实现的目标。

函数是一个必须扮演做某事的角色（一个函数）的代码。方法是一种方法来解决问题。

它做同样的事情。这是同样的事情。如果你想超级精确并遵循惯例，你可以调用方法作为对象内部的函数。

小开

函数是主要属于面向过程的程序设计的概念，其中函数是一个可以处理数据并返回值的实体

方法是面向对象编程的概念，其中方法是主要对类成员进行处理的类的成员。

小开

从历史上看，可能存在细微的差异，“方法”是不返回值的东西，而“函数”是返回值的东西。每种语言都有自己的词汇，具有特殊的含义。

在“C”中，单词“功能”表示一个程序例程。

在Java中，术语“功能”没有任何特殊含义。而“方法”表示形成类实现的例程之一。

在c#中，这将翻译为：

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

但实际上，我重申这两个概念真的没有区别。如果你在关于Java的非正式讨论中使用“函数”这个词，人们会认为你的意思是“方法”，然后继续。不要在关于Java的适当文档或演示中使用它，否则你会看起来很傻。

小开

我知道很多人已经回答了，但我发现下面是一个简单但有效的单行答案。虽然它看起来并不比这里的其他答案好多少，但如果你仔细阅读，它包含了你需要知道的关于方法与函数的一切。

方法是具有定义接收器的函数，在OOP术语中，方法是对象实例上的函数。

小开

在C++，有时，方法被用来反映类的成员函数的概念。然而，最近我在《C++编程语言第四版》一书中找到了一条语句，在第586页“派生类”

虚函数有时称为方法。

这有点令人困惑，但他说有时，所以它大致是有道理的，C++创建者倾向于将方法视为可以在对象上调用的函数，并且可以表现为多态。

小开

以下是使用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等定义属性，例如

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对象方法、函数、关于原型的更多信息

小开

简单的方法来记住：

Function→Free（Free意味着它可以在任何地方，不需要在对象或类中）
Method→Member（对象或类的成员）

小开

方法和函数是一样的。当一个函数在类之外时，你称它为函数，当它写在类内部时，你称它为方法。

小开

方法和函数的区别

在Microsoft上阅读本文档

包含执行代码的成员统称为类的函数成员。上一节描述了方法，它们是函数成员的主要类型。本节描述C#支持的其他类型的函数成员：构造函数、属性、索引器、事件、运算符和终结器。

所以方法是函数的子集。每个方法都是函数，但不是每个函数都是方法，例如，constructor不能说成方法，但它是一个函数。

小开

类是一些数据和函数的集合，可以选择使用构造函数。

当您创建该特定类的实例（复制、复制）时，构造函数初始化该类并返回一个对象。

现在类成为对象（没有构造函数）&函数在对象上下文中称为方法。

所以基本上

Class<==new==>对象

函数<==new==>方法

在java中，通常被告知构造函数名称与类名相同，但实际上构造函数类似于实例块和静态块，但具有用户定义的返回类型（即类类型）

虽然类可以有静态块、实例块、构造函数、函数对象通常只有数据和方法。

小开

函数-独立代码中的函数，其中包括一些逻辑和必须独立调用并在类之外定义。

方法-一个方法是一段独立的代码，它是在引用某个对象时调用，并在类内定义。

小开

它们通常可以互换，但方法通常指类内的子例程，函数通常指类外的子例程。例如，在Ruby中：

# functiondef putSqr(a)puts a ** 2end

class Math2# methoddef putSqr(a)puts a ** 2endend

在Java，所有东西（除了包和导入语句）都必须在类内部，人们几乎总是将它们称为“方法”。

小开

太长别读

函数是要运行的一段代码。
方法是对象内部的函数。

函数示例：

function sum(){console.log("sum")l}

方法示例：

const obj = {a:1,b:2,sum(){}}

所以这就是为什么我们说函数中的“this”关键字不是很有用，除非我们将其与call、应用或绑定一起使用…因为call、应用、绑定将调用该函数作为对象内的方法==>基本上它将函数转换为方法

小开

简而言之：非静态（“实例”）方法采用一个隐藏的指针指向“this”（作为它们的第一个参数），这是您调用方法的对象。

这是与常规独立功能的唯一区别，尽管动态调度。

如果您有兴趣，请阅读下面的详细信息。

我会尽量简短，并以C++为例，尽管我所说的几乎可以应用于每种语言。

对于您的CPU，函数和方法都只是代码片段。结束。
因此，当调用函数/方法时，它们可以采取参数

好吧，我说没有实际的区别。让我们再深入一点：

有两种方法：静态和非静态
静态方法类似于常规函数，但在类内声明，其行为仅像命名空间
非静态（“实例”）方法采用指向“this”的隐藏指针。这是与常规独立函数的唯一区别。

抛开动态调度不谈，这意味着它就这么简单：

class User {public string name; // I made it public intentionally
// Each instance method takes a hidden reference to "this"public void printName(/*User & this*/) {cout << this.name << endl;}};

相当于

public getName(User & user) {// No syntactic sugar, passing a reference explicitlycout << user.name << endl;}

所以，本质上，user->printName()只是getName(user)的语法糖。

如果你不使用动态调度，这就是全部。如果它是被使用，那么它会更复杂一点，但编译器仍然会发出看起来像一个以this为第一个参数的函数。

小开

函数和方法看起来非常相似。它们也有输入和返回输出。区别在于方法在类内部而函数在类之外。

小开

方法和函数之间有明显的区别：

函数是一段独立的代码，您可以通过使用给定参数提及它的名称在任何地方调用，就像大多数过程语言一样，例如C++和python

方法专门与一个对象相关联，意味着您只能通过在其前面使用点（.）符号提及它的对象来调用方法，就像在C#和java等专门纯面向对象的语言中一样。

小开

一般答案是：

method有对象上下文（this或类实例引用），

function没有上下文（null、全局或静态）。

但问题的答案取决于你使用的语言术语。

在JavaScript（ES 6）中，您可以自由选择任何您想要的，通常必须链接到（this）对象实例上下文。
在Java世界里你总是听到“只有OOP类/对象，没有函数”，但是如果你详细观察Java中的static methods，它们实际上是在全局/空上下文（或类的上下文，没有实例化）中，所以只是函数没有对象。Java老师可以告诉你，那functions were rudiment of C in C++ and dropped in Java，但他们告诉你是为了简化历史和避免新手不必要的问题。如果你看到Java7版本后，你可以找到许多纯函数编程的元素（即使不是来自C，但从1988年开始 Lisp）用于简化并行计算，它不是OOP类风格。
在C++和D世界中，事情更强大，您将功能和带有方法和字段的对象分开。但在实践中，您再次看到函数without this和方法whith this（带有对象上下文）。
在FreePascal/Lazarus和Borland Pascal/Delphi中，函数和对象（变量和字段）的分离项通常类似于C++。
Objective-C来自C世界，因此您必须使用方法插件分隔C函数和Objective-C对象。
C#与Java非常相似，但有许多C++优点。

小开

Amethod是任何对象或类的成员。function是独立的。

但是在Javascript的情况下，function和method是可以互换的。

小开

使用C#术语，函数和方法之间存在区别。术语功能成员不仅包括方法，还包括其他非数据成员，例如索引器、运算符、构造函数、析构函数和属性-所有包含执行代码的成员。

专业C#和. NET 2021版-由Christina Nagel编写

小开

方法和函数有什么区别？

Python的官方留档是这样定义的（感谢@凯利·邦迪！）：

函数
向调用者返回某个值的一系列语句。它也可以传递零个或多个参数，这些参数可用于主体的执行。另请参阅参数、方法和函数定义部分

方法
在类体内定义的函数。如果作为该类实例的属性调用，该方法将获得实例对象作为其第一个论点（通常称为self）。参见函数和嵌套作用域。

正方形是矩形，但并非所有矩形都是正方形。我解释世界的方式，方法是函数，但并非所有函数都是方法。方法的独特之处在于它是一个特殊类型的函数，它也与类关联并可以访问类成员变量。

另见：

[我的朋友]Hasattr被称为方法，但它看起来像一个函数

小开

OOP是一种设计理念。在这种情况下，“方法”是“行动”，对象的“行为”，“操作”，对象所做的事情。右键单击鼠标对象是一个动作。这种动作或行为在实现OOP设计的几种语言中称为“方法”。
“功能”仅与C和Pascal等过程语言相关，与OOP哲学无关，即使在技术上实现类似于方法。“功能”是C等过程语言中的代码块，具有定义的目的，隔离和定义的功能，也可以返回结果。"程序"也是一个不返回结果的函数，但它只是技术差异。

小开

函数是执行特定任务的一组指令或过程。它可用于将代码拆分为易于理解的部分，也可以调用或重用。

方法是可以在对象上执行的操作。它也被称为存储为对象属性的函数。

主要区别：函数不需要任何对象并且是独立的，而方法是一个函数，它与任何对象链接。

//firstName() is the function
function firstName(){cosole.log('John');}
firstName() //Invoked without any object

const person = {firstName: "John",lastName: "Doe",id: 5566,};
//person.name is the methodperson.name = function() {return this.firstName + " " + this.lastName;};
document.getElementById("demo").innerHTML ="My father is " + person.name() //performs action on object;