关于OOP：方法和函数有什么区别？


What's the difference between a method and a function?

有人能简单解释OOP上下文中的方法和函数吗？

相关讨论

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

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

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

    • (这是一个简化的解释，忽略了范围等问题。)

    相关讨论

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

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

    对于C++来说，这取决于你是否在一个类中。

    相关讨论

    "method"是"function"的面向对象词。这几乎就是它的全部(即，没有真正的区别)。

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

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

    [迟加]

    事实上，正如Brian Neal在对这个问题的评论中指出的，C++标准在引用成员函数时从不使用术语"方法"。有些人可能认为C++不是真正的面向对象语言，但是，我更喜欢把它看作是一个聪明的人认为使用一个不同的术语有一个特别有力的理由。

    相关讨论

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

    以下面的python示例为例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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))类型相同的新对象，或者至少在python中调用对象(object.method()中的方法。

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

    相关讨论

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

    Functions are defined outside of classes, while Methods are defined inside of and part of classes.

    简单的记忆方法：

    • 函数→自由(自由意味着不属于对象或类)
    • 方法→成员(对象或类的成员)

    如果你想在这里读"我对OO方法的介绍"

    面向对象范式背后的思想是"威胁"软件由..嗯，"物体"。现实世界中的对象具有属性，例如，如果您有一个雇员，该雇员有一个姓名、一个雇员ID、一个职位、他属于一个部门等。

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

    1
    employe whatAreYouDoing.

    "whatareyoudoing"是发送给对象的"消息"。对象知道如何回答这些问题，据说它有解决问题的"方法"。

    因此，对象必须公开其行为的方式称为方法。因此，方法是工件对象必须"做"的事情。

    其他可能的方法是

    1
    2
    employee whatIsYourName
    employee whatIsYourDepartmentsName

    等。

    另一方面，函数是编程语言计算某些数据的方式，例如，您可能拥有返回16的函数addvalues(8，8)

    1
    2
    3
    4
    5
    // 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中的前一个函数是：

    1
    2
    3
    4
    int addValues( int x, int y )
    {
       return x + y;
    }

    说一个对象有一个"功能"来执行某个动作并不是"自然"的，因为函数与数学事物更相关，而一个雇员对它的数学却很少，但是可以有与函数完全相同的方法，例如在Java中，这将是等价的ADDVALSE函数。

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

    看起来很熟悉？这是因为Java在C语言上有C++和C++的基础。

    最后只是一个概念，在实现中它们看起来可能是相同的，但是在OO文档中，这些称为方法。

    这里是Java中以前的雇员对象的一个例子。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    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()"，则需要编写"Toel.On())。

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

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

    相关讨论

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

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

    表示函数f()将返回添加到第二个参数的余弦的第一个参数的sin。只是数学而已。正如所发生的，sin()和cos()也是函数。一个函数还有另一个属性：对具有相同参数的函数的所有调用都应返回相同的结果。

    另一方面，方法是与面向对象语言中的对象相关的函数。它有一个隐式参数：被作用的对象(它的状态)。

    因此，如果您有一个对象z和一个方法g(x)，您可能会看到以下内容：

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

    在这种情况下，传入参数x，与前面的函数示例相同。但是，cos()的参数是一个存在于对象z.z内部的值，并且它内部的数据(z.y)是z的g()方法的隐式参数。

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

    在C语言中，使用了"函数"一词。Java和C语言的人会说它是一种方法(这种情况下的函数是在类/对象中定义的)。

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

    只需调用函数的名称，就可以使用函数，

    1
    result = mySum(num1, num2);

    < BR>您将首先通过引用方法的对象来调用方法，例如，

    1
    result = MyCalc.mySum(num1,num2);

    从历史上看，"方法"可能是不返回值的东西，而"函数"可能是不返回值的，每种语言都有它自己的有特殊意义的词汇。

    在"c"中，"函数"一词是指程序例行程序。

    在Java中，"函数"这个词没有任何特殊含义。而"方法"是指构成类实现的例程之一。

    在C中，这将翻译为：

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

    但实际上，我再次重申，这两个概念确实没有区别。如果你在Java的非正式讨论中使用"函数"一词，人们会认为你是指"方法"并继续进行。不要在正确的文档或演示文稿中使用Java，否则你会看起来很傻。

    相关讨论

    方法是类的函数。在正常的行话中，人们的交流方法和功能无处不在。基本上，您可以将它们视为相同的东西(不确定全局函数是否被调用方法)。

    http://en.wikipedia.org/wiki/method(计算机科学)

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

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    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"
       }
    }

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    # 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：唯一的区别是第一个参数的名称(在我称之为"greater"的函数中，在我称之为"self"的方法中)。因此，我可以使用greet方法，方法与使用greet_with_greeter函数的方法完全相同(使用"dot"语法获取它，因为我在类中定义了它)：

    1
    Greeter.greet(hello_greeter,"World")

    所以我有效地把一个方法变成了一个函数。我能把一个函数转换成一个方法吗？好吧，因为python允许您在定义类之后处理它们，所以让我们尝试：

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

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

    (OO纯粹主义者可能会争辩说，一个方法与一个函数是不同的，如果你进入高级Python、Ruby或Smalltalk！-你将开始了解他们的观点。还有一些语言赋予方法对对象位的特殊访问权。但主要的概念差异仍然是隐藏的额外参数。)

    在OO语言中，如对象Pascal或C++，"方法"是与对象相关联的函数。例如，一个"dog"对象可能有一个"bark"函数，这将被视为一个"方法"。相反，"strlen"函数是独立的(它提供作为参数提供的字符串的长度)。它只是一个"函数"。JavaScript在技术上也是面向对象的，但与C++、C**或Pascal等全面的语言相比，面临许多限制。尽管如此，这一区别仍然存在。

    另外还有几个事实：C是完全面向对象的，所以你不能创建独立的"函数"。在C中，每个函数都绑定到一个对象，因此，从技术上讲，是一个"方法"。更重要的是，C中很少有人将它们称为"方法"，他们只是使用"函数"一词，因为没有真正的区别。

    最后，就像所有的帕斯卡大师不会在这里跳到我身上一样，帕斯卡还区分了"函数"(返回值)和"过程"(不返回值)。C虽然您可以选择返回值或不返回值，但并没有明确地作出这种区分。

    为了我：如果我同意，方法和函数的函数是相同的：

    • 函数可以返回一个值
    • 可能需要参数

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

    在调用对象或其他代码的函数时，可能存在定义差异。但这不是语言差异的原因吗？这就是为什么人们会交换语言？上面提到的计算示例我会非常小心。因为我雇佣员工来做我的计算：

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

    通过这样做，我可以依靠一个负责计算的雇主。如果他想要更多的钱，我会让他自由，让卡巴基收集者处理未使用的员工的功能来做剩下的事情，然后找一个新的员工。

    即使认为一个方法是一个对象函数，而一个函数是不连接的，计算也帮不了我。函数描述符本身以及函数的文档将告诉我它需要什么以及可能返回什么。其余的，就像操纵某个对象的状态，对我来说并不是真正透明的。我确实希望函数和方法能够交付和操作它们声称的内容，而不需要详细了解它们是如何做到的。即使是纯计算函数也可能更改控制台的状态或附加到日志文件。

    对于一阶近似，一种方法(在C++风格OO中)是一个成员函数的另一个字，这是一个函数的一部分。

    在类似C/C++的语言中，你可以拥有不是类成员的函数；你不调用与A类方法无关的函数。

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

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

    例如，假设你想描述一只猫，你想让它能够打哈欠。您将使用yawn方法创建一个cat类，它很可能是一个没有任何返回值的函数。

    imho人们只是想发明一个新词，当他们想引用对象内部的函数时，可以更容易地在程序员之间进行通信。

    如果您说的是方法，那么您的意思是类内的函数。如果您说的是函数，那么您的意思只是在类之外的函数。

    事实上，这两个词都用来描述函数。即使你用错了，也不会有什么问题。这两个词都很好地描述了您想要在代码中实现的目标。

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

    它做同样的事情。这是同一件事。如果您想要非常精确并遵循约定，那么可以将方法作为对象内部的函数来调用。

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

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

    让我们不要过于复杂，什么应该是一个非常简单的答案。方法和函数是相同的。当函数在类外部时，将其调用为函数；当函数写入类内部时，将其调用为方法。

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

    方法是一个函数，它有一个已定义的接收器，就OOP而言，方法是一个对象实例上的函数。

    方法与功能的区别

    在Microsoft上阅读此文档

    Members that contain executable code are collectively known as the function members of a class. The preceding section describes methods, which are the primary kind of function members. This section describes the other kinds of function members supported by C#: constructors, properties, indexers, events, operators, and finalizers.

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

    相关讨论

    我不是专家，但我知道：

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

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

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

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

    • 下面是使用javascript示例对方法与函数的一些解释：

    test(20, 50);是函数定义和用于运行某些步骤或返回可以存储/使用的内容。

    You can reuse code: Define the code once and use it many times.

    You can use the same code many times with different arguments, to produce different results.

    1
    2
    3
    4
    5
    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();here test()可以是某个对象的方法，也可以是为内置对象自定义的原型，这里有更多的解释：

    JavaScript methods are the actions that can be performed on objects.

    A JavaScript method is a property containing a function definition.

    javascript中字符串的内置属性/方法：

    1
    2
    3
    var message ="Hello world!";
    var x = message.toUpperCase();
    //Output: HELLO WORLD!

    自定义示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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'

    您还可以为字符串、数组等定义属性，例如

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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对象方法，函数，更多关于原型的信息

    相关讨论

    函数-独立代码段中的一个函数，它包含一些逻辑，必须独立调用，并在类外部定义。

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

    在C++中，有时使用方法来反映类成员函数的概念。但是，最近我在书中发现了一个声明？C++程序设计语言第四版？第586页"派生类"

    A virtual function is sometimes called a method.

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

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

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

    现在类变成对象(没有构造函数)和；函数在对象上下文中称为方法。

    所以基本上

    类<==new==>对象

    函数<==new==>方法

    在Java中，通常被告知构造函数名称与类名相同，但实际上构造函数就像实例块和静态块，但具有用户定义的返回类型(即类类型)。

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

    方法是操作的名称。函数是方法的标识符。

    相关讨论