之间有什么差异的方法和功能？

Question

有人可以提供一个简单的解释 方法 与 功能 在面向对象的背景下?

Answer 1

功能是一段按名称调用的代码。它可以传递数据以进行操作（即参数），并且可以可选地返回数据（返回值）。传递给函数的所有数据都是显式传递的。

方法是由与对象关联的名称调用的一段代码。在大多数方面，除了两个主要区别外，它与功能相同：

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

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

Answer 2

方法在对象上。
函数独立于对象。

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

对于C ++，它取决于你是否在课堂上。

Answer 3

'方法'是'function'的面向对象字词。这就是它的全部内容（即没有真正的区别）。

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

真的 - 它没有那么多，只是同一个词的不同词语。

[后期补充]

---

事实上，正如 Brian Neal 在对这个问题，C ++在引用成员函数时，标准从不使用术语“方法”。有些人可能会认为这表明C ++并不是真正的面向对象语言;但是，我更愿意将其视为一个非常聪明的人群认为没有特别强烈的理由使用不同的术语。

Answer 4

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

采用以下python示例：

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

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

knock_door()

给出的示例显示了一个名为<！> quot; Door <！>的类;它有一个名为<！> quot; open <！>的方法或动作，它被称为方法，因为它是在一个类中声明的。还有另一部分代码带有<！> quot; def <！> quot;在下面定义一个函数，它是一个函数，因为它没有在类中声明，这个函数调用我们在类中定义的方法，你可以看到，最后函数被自己调用。

正如您所看到的，您可以在任何地方调用函数，但是如果要调用方法，则必须传递与声明方法的类相同类型的新对象（Class.method（object））或者您必须调用对象内部的方法（object.Method（）），至少在python中。

将方法看作只有一个实体可以做的事情，所以如果你有一个Dog类，那么只在该类中有一个bark函数是有意义的，那将是一个方法，如果你还有一个Person类，它可以有意义写一个函数<！> quot; feed <！> quot;因为它不属于任何类，因为人类和狗都可以被喂食，你可以称之为功能，因为它不属于任何类别。

Answer 5

功能与方法之间主要区别的一般定义：

  

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

Answer 6

简单的方式来记住：

• F基→ F稀土元素(免费的装置不属于一个象或类)
• Method→ M余烬(A件的对象或类)

Answer 7

如果你觉得读这里是"我的介绍，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文件，这些都是所谓的方法。

下面是一个以前的员工的对象。

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。例如一般.我希望它可以合理容易理解的方法对象中的在读这个。

注：代码是不是编的，只是作为一个例子。随时修改后，添加蟒蛇的例子。

Answer 8

在OO世界中，这两者通常用于表示相同的事物。

从纯数学和CS的角度来看，当使用相同的参数（f（x，y）=（x + y））调用时，函数将始终返回相同的结果。另一方面，方法通常与类的实例相关联。尽管如此，大多数现代OO语言不再使用术语<！> quot; function <！> quot;在大多数情况下。许多静态方法可能非常类似于函数，因为它们通常没有状态（并非总是如此）。

Answer 9

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

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

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

在许多面向对象的语言中，所有<！> quot; functions <！> quot;属于某个对象（或类），因此在这些语言中没有不是方法的函数。

Answer 10

方法是类的功能。在通常的行话中，人们互相交换方法和功能。基本上你可以认为它们是同一个东西（不确定全局函数是否被称为方法）。

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

Answer 11

功能是一种数学概念。例如：

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（）方法的隐式参数。

Answer 12

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

在 C 语言中使用术语函数。 Java <！> amp; C＃人们会说它是一种方法（在这种情况下，函数是在类/对象中定义的）。

C ++ 程序员可能会将其称为函数或有时称为方法（取决于它们是否正在编写程序样式的c ++代码，或者正在使用C ++的面向对象方式，也可能只是C / C ++程序员称之为函数是因为术语'方法'在C / C ++文献中较少使用。）

您可以通过调用它的名称来使用函数，例如，

result = mySum(num1, num2);

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

result = MyCalc.mySum(num1,num2);

Answer 13

历史上，<！> quot;方法<！>引用可能存在细微差别。是一个不返回值的东西，还有一个<！> quot; function <！> quot;每种语言都有自己的术语词汇，具有特殊含义。

在 <！>“C <！>”中，单词 <！>“; <！> 表示程序例程

在 Java 中，术语 <！> quot; function <！> quot; 没有任何特殊含义。而 <！> quot; method <！> <<; 表示构成类实现的一个例程。

在 C＃中将翻译为：

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

但实际上，我重申这两个概念确实没有区别。 如果您使用术语<！>“;函数<！>”;在关于Java的非正式讨论中，人们会认为你的意思是<！> quot; method <！> quot;继续不要在适当的文档或关于Java的演示文稿中使用它，否则你会看起来很傻。

Answer 14

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

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

Answer 15

在Object Pascal或C ++等OO语言中，<！> quot; method <！> quot;是与对象关联的函数。因此，例如，<！>“Dog <！>”;对象可能有一个<！> quot; bark <！> quot;函数，这将被视为<！>“方法<！>”。相反，<！>“StrLen <！>”;函数独立（它提供作为参数提供的字符串的长度）。因此只是一个<！>“函数。<！> Javascript在技术上也是面向对象的，但与C ++，C＃或Pascal等成熟语言相比，它面临着许多限制。尽管如此，这种区别仍应保持不变。

其他一些事实：C＃完全面向对象，因此您无法创建独立的<！>“函数。<！>在C＃中，每个函数都绑定到一个对象，因此从技术上讲，它是一个<！>方法。<！>踢球者是C＃中很少有人将它们称为<！> quot; methods <！> quot; - 他们只使用术语<！> quot; functions <！> quot;因为没有任何真正的区别。

最后 - 所以任何Pascal大师都不会在这里跳过我--Pascal也区分<！> quot; functions <！> quot; （返回值）和<！> quot; procedures <！> quot;哪个没有。虽然您可以选择返回值，但C＃并未明确区分。

Answer 16

由于您提到了Python，以下内容可能是大多数现代面向对象语言中方法和对象之间关系的有用说明。简而言之，他们称之为<！> quot;方法<！>只是一个传递额外参数的函数（正如其他答案所指出的那样），但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 <！>”，在方法I中称之为<！>“self <！>”;）。所以我可以使用greet2方法，就像我使用object.method(args)函数一样（使用<！> quot; dot <！>;语法来获取它，因为我在类中定义了它） ：

Greeter.greet(hello_greeter, "World")

所以我有效地将一个方法变成了一个函数。我可以将函数转换为方法吗？好吧，因为Python允许你在定义类之后搞乱它们，让我们试试：

Greeter.greet2 = greet_with_greeter
hello_greeter.greet2("World")

是的，函数method(object, args)现在也称为方法<=>。这显示了方法和函数之间唯一真正的区别：当你在<！>上调用方法<！>时;通过调用<=>对象，该语言神奇地将其转换为<=>。

（OO纯粹主义者可能认为一种方法与函数不同，如果你进入高级Python或Ruby - 或Smalltalk！ - 你会开始看到他们的观点。还有一些语言给方法特殊的访问权限。但主要的概念差异仍然是隐藏的额外参数。）

Answer 17

功能是一组可用于操纵数据的逻辑。

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

Answer 18

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

• 功能可以返回值
• 可以预计参数

就像任何一段代码你可能有的对象，你和你可能有一个对象结果。在这样做，他们可能会改变对象的状态，但这不会改变其基本运作对我来说。

可能有一个定义的差异在叫功能的对象或其他密码。但不是那东西，一个口头differenciations这就是为什么人们交换？所提到的例子计算，我会小心的。因为我雇的员工做好我的计算：

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

通过这样做，我可以依靠雇主负责计算。如果他想要更多的钱，我自由了他和我们的carbage器的功能处理未使用的雇员的休息和获得新的员工。

甚至争辩说，一个方法是物体的功能和功能是互不连接的计算不会帮助我。功能描述本身和理想的功能的文件将告诉我需要什么以及什么可以返回。其他的，像操纵一些目的国并不是真正透明的给我。我期望两者的功能和方法，以提供和操纵他们的权利要求，而无需详细地知道他们是如何做到这一点。甚至一种纯粹的计算功能可能会改变的控制状态或追加一个日志文件。

Answer 19

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

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

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

Answer 20

对于一阶近似，方法（在C ++样式OO中）是成员函数的另一个单词，即作为类的一部分的函数。

在像C / C ++这样的语言中，你可以拥有不属于类的成员;你不要调用一个与类不相关的函数。

Answer 21

恕我直言的人们只是想在程序员想要引用对象内部的函数时发明新词，以便更容易地进行通信。

如果你说方法意味着课堂内的功能。 如果你说的是函数，那么你的意思就是在课堂外起作用。

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

功能是一个必须扮演某个角色（一个功能）的代码。 方法方法来解决问题。

它做同样的事情。这是一回事。如果你想要超精确并遵循惯例，你可以将方法称为对象内的函数。

Answer 22

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

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

Answer 23

让我们不要过分复杂应该是一个非常简单的答案。方法和功能是一回事。当函数在类之外时，可以将函数作为函数调用，并且当函数写入类时，可以将函数作为方法调用。

Answer 24

我不是专家，但这就是我所知道的：

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

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

3. 调用方法也不同。这里调用意义来查找这段代码的地址。 C / C ++，链接时间将使用函数符号来定位。

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

Answer 25

我知道很多人已经回答了，但我发现以下是一个简单但有效的单行答案。虽然它看起来并不比其他人的答案好很多，但是如果你仔细阅读它，它就拥有你需要了解的方法与功能的一切。

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

Answer 26

方法和函数之间的差异

阅读关于Microsoft的此文档

  

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

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

Answer 27

以下是使用JavaScript示例的方法与功能的一些解释：

test(20, 50);是函数define并用于运行某些步骤或返回可以在某处存储/使用的东西。

  

您可以重复使用代码：定义代码一次并多次使用。

     

您可以使用不同的参数多次使用相同的代码，以产生不同的结果。

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对象方法，功能，有关原型的更多信息

Answer 28

功能 - 包含某些逻辑和的独立代码中的函数必须独立调用 并在类外定义。

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

Answer 29

在C ++中，有时候，方法用于反映类的成员函数的概念。但是，最近我在书中找到了一个声明<！>＃171; C ++编程语言第4版<！>＃187;，第586页<！>“派生类<！>”

  

虚函数有时称为方法。

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

Answer 30

一个类是一些数据和函数的集合，可选地带有构造函数。

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

现在该类成为对象（没有构造函数） <！>安培; 函数在对象上下文中称为方法。

所以基本上

Class <！> lt; == new == <！> gt; Object

功能<！> lt; == new == <！> gt;方法

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

虽然类可以有静态块，实例块，构造函数，函数 该对象通常只有数据<！>放大器;方法