Alguém pode fornecer uma explicação simples de métodos versus funções no contexto de POO?

Uma função é um pedaço de código chamado pelo nome. Podem ser transmitidos dados para operar (isto é, os parâmetros) e, opcionalmente, podem retornar dados (o valor retornado). Todos os dados que são passados ​​para uma função são explicitamente passados.

Um método é um pedaço de código chamado por um nome associado a um objeto. Na maioria dos aspectos, é idêntico a uma função, exceto por duas diferenças principais:

1. Um método é passado implicitamente no objeto no qual foi chamado.
2. Um método é capaz de operar com dados contidos na classe (lembrando que um objeto é uma instância de uma classe - a classe é a definição, o objeto é uma instância desses dados).

(esta é uma explicação simplificada, ignorando questões de escopo etc.)

Um método está em um objeto.
Uma função é independente de um objeto.

Para Java e C #, existem apenas métodos.
Para C, existem apenas funções.

Para C ++ e Python, isso dependeria de você estar ou não em uma classe.

'método' é a palavra orientada a objetos para 'função' . Isso é praticamente tudo o que existe (ou seja, não há diferença real).

Infelizmente, acho que muitas das respostas aqui estão perpetuando ou promovendo a ideia de que há alguma diferença complexa e significativa.

Realmente - não há muito, apenas palavras diferentes para a mesma coisa.

[adição tardia]

De fato, como Brian Neal apontou em um comentário para essa pergunta , o padrão C ++ nunca usa o termo 'método' quando se refere a funções-membro. Algumas pessoas podem considerar isso como uma indicação de que o C ++ não é realmente uma linguagem orientada a objetos; no entanto, prefiro tomá-lo como uma indicação de que um grupo bastante inteligente de pessoas não achou que havia uma razão particularmente forte para usar um termo diferente.

Em geral: métodos são funções que pertencem a uma classe, as funções podem estar em qualquer outro escopo do código, para que você possa afirmar que todos os métodos são funções, mas nem todas as funções são métodos:

Veja o seguinte exemplo de python:

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

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

knock_door()

O exemplo dado mostra uma classe chamada "Door", que possui um método ou ação chamada "open", é chamada de método porque foi declarada dentro de uma classe. Existe outra parte do código com "def" logo abaixo, que define uma função, é uma função porque não é declarada dentro de uma classe, essa função chama o método que definimos dentro de nossa classe como você pode ver e, finalmente, a função está sendo chamado por si só.

Como você pode ver, você pode chamar uma função em qualquer lugar, mas se você quiser chamar um método, você deve passar um novo objeto do mesmo tipo que a classe em que o método é declarado (Class.method (objeto)) ou você deve chamar o método dentro do objeto (object.Method ()), pelo menos em python.

Pense nos métodos como coisas que apenas uma entidade pode fazer; portanto, se você tiver uma classe Dog, faria sentido ter uma função de latido somente dentro dessa classe e isso seria um método; se você também tiver uma classe Person, faria sentido escreva uma função "feed" para que não pertença a nenhuma classe, pois humanos e cães podem ser alimentados e você poderia chamar isso de uma função, pois ela não pertence a nenhuma classe em particular.

Maneira simples de lembrar:

• F unção → F ree (Free não significa pertencer a um objeto ou classe)
• M é todo → M brasa (Um membro de um objecto ou classe)

Uma definição muito geral da principal diferença entre uma Função e um Método :

Funções são definidas fora das classes, enquanto Métodos são definidos dentro e parte das classes.

Se você quiser ler aqui, é "Minha introdução aos métodos OO"

A idéia por trás do paradigma Orientado a Objetos é "ameaçar" o software é composto de ... bem "objetos". Objetos no mundo real têm propriedades, por exemplo, se você tem um funcionário, o funcionário tem um nome, uma identificação de funcionário, uma posição, ele pertence a um departamento etc. etc.

O objeto também sabe como lidar com seus atributos e executar algumas operações neles. Digamos que, se quisermos saber o que um funcionário está fazendo agora, perguntaríamos a ele.

employe whatAreYouDoing.

Que "whatAreYouDoing" é uma "mensagem" enviada ao objeto. O objeto sabe como responder a essas perguntas, diz-se que possui um "método" para resolver a questão.

Portanto, a maneira como os objetos precisam expor seu comportamento é chamada de método. Os métodos, portanto, são o objeto de artefato que precisam "fazer" alguma coisa.

Outros métodos possíveis são

employee whatIsYourName
employee whatIsYourDepartmentsName

etc.

As funções, por outro lado, são maneiras pelas quais uma linguagem de programação precisa computar alguns dados; por exemplo, você pode ter a função addValues ​​(8, 8) que retorna 16

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

Como as primeiras linguagens de programação populares (como fortran, c, pascal) não abordaram o paradigma OO, elas apenas chamam esses artefatos de "funções".

por exemplo, a função anterior em C seria:

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

Não é "natural" dizer que um objeto tem uma "função" para executar alguma ação, porque as funções estão mais relacionadas a coisas matemáticas, enquanto um Funcionário tem pouca matemática, mas você pode ter métodos que fazem exatamente o mesmo que funções, por exemplo, em Java, essa seria a função addValues ​​equivalente.

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

Parece familiar? Isso ocorre porque o Java tem suas raízes em C ++ e C ++ em C.

No final, é apenas um conceito; na implementação, eles podem ter a mesma aparência, mas na documentação do OO, eles são chamados de método.

Aqui está um exemplo do objeto Employee anteriormente em 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.

A diferença, então, está no "domínio" onde é aplicado.

AppleScript tem a idéia de "linguagem natural", que em algum momento o OO tinha. Por exemplo, Smalltalk. Espero que seja mais fácil entender métodos em objetos depois de ler isso.

NOTA: O código não deve ser compilado, apenas para servir como exemplo. Sinta-se livre para modificar a publicação e adicionar um exemplo de Python.

No mundo OO, os dois são comumente usados ​​para significar a mesma coisa.

De uma perspectiva pura de Matemática e CS, uma função sempre retornará o mesmo resultado quando chamada com os mesmos argumentos (f (x, y) = (x + y)). Um método, por outro lado, é normalmente associado a uma instância de uma classe. Novamente, porém, a maioria das linguagens OO modernas não usa mais o termo "função" na maior parte do tempo. Muitos métodos estáticos podem ser muito parecidos com funções, pois normalmente não têm estado (nem sempre verdadeiro).

Digamos que uma função seja um bloco de código (geralmente com seu próprio escopo e, às vezes, com seu próprio fechamento) que pode receber alguns argumentos e também retornar um resultado.

Um método é uma função que pertence a um objeto (em alguns sistemas orientados a objetos, é mais correto dizer que pertence a uma classe). Ser "possuído" por um objeto / classe significa que você se refere ao método por meio do objeto / classe; por exemplo, em Java, se você deseja chamar um método "open ()" pertencente a um objeto "door", é necessário escrever "door.open ()".

Geralmente, os métodos também ganham alguns atributos extras que descrevem seu comportamento no objeto / classe, por exemplo: visibilidade (relacionada ao conceito de encapsulamento orientado a objetos), que define a partir de quais objetos (ou classes) o método pode ser chamado.

Em muitas linguagens orientadas a objetos, todas as "funções" pertencem a algum objeto (ou classe) e, portanto, nessas linguagens não existem funções que não sejam métodos.

Métodos são funções de classes. No jargão normal, as pessoas trocam métodos e funções por toda parte. Basicamente, você pode pensar neles como a mesma coisa (não tenho certeza se funções globais são chamadas de métodos).

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

Uma função é um conceito matemático. Por exemplo:

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

diz que a função f () retornará o pecado do primeiro parâmetro adicionado ao cosseno do segundo parâmetro. É apenas matemática. Por acaso, sin () e cos () também são funções. Uma função possui outra propriedade: todas as chamadas para uma função com os mesmos parâmetros devem retornar o mesmo resultado.

Um método, por outro lado, é uma função relacionada a um objeto em uma linguagem orientada a objetos. Ele tem um parâmetro implícito: o objeto que está sendo acionado (e seu estado).

Portanto, se você tiver um objeto Z com o método g (x), poderá ver o seguinte:

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

Nesse caso, o parâmetro x é passado, o mesmo que no exemplo da função anterior. No entanto, o parâmetro para cos () é um valor que vive dentro do objeto Z. Z e os dados que vivem dentro dele (Zy) são parâmetros implícitos no método g () de Z.

Função ou método é um trecho de código que pode ser chamado, que executa algumas operações e, opcionalmente, retorna um valor.

Na linguagem C , o termo função é usado. As pessoas de Java e C # diriam que é um método (e uma função neste caso é definida dentro de uma classe / objeto).

Um programador de C ++ pode chamá-lo de função ou, às vezes, de método (dependendo se está escrevendo código c ++ de estilo procedural ou se está usando o C ++ orientado a objetos, também um programador de C / C ++ provavelmente chamaria de função porque o termo 'método' é usado com menos frequência na literatura C / C ++).

Você usa uma função apenas chamando seu nome como

result = mySum(num1, num2);

Você chamaria um método referenciando seu objeto primeiro como,

result = MyCalc.mySum(num1,num2);

Historicamente, pode ter havido uma diferença sutil com um "método" sendo algo que não retorna um valor e uma "função" que sim. Cada linguagem tem seu próprio léxico de termos com significado especial.

Em "C" , a palavra "função" significa uma rotina de programa .

Em Java , o termo "função" não tem nenhum significado especial. Enquanto "método" significa uma das rotinas que formam a implementação de uma classe.

Em C #, isso seria traduzido como:

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

Mas, na verdade, reitero que realmente não há diferença nos 2 conceitos. Se você usar o termo "função" em discussões informais sobre Java, as pessoas assumirão que você quis dizer "método" e continuarão. Não o utilize em documentos ou apresentações adequados sobre Java, ou você parecerá bobo.

Função é um conjunto de lógica que pode ser usado para manipular dados.

Enquanto, Method é uma função usada para manipular os dados do objeto ao qual ele pertence. Portanto, tecnicamente, se você tem uma função que não está completamente relacionada à sua classe, mas foi declarada na classe, não é um método; É chamado de design ruim.

Os métodos em uma classe atuam na instância da classe, chamada objeto.

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

Nas linguagens OO, como Object Pascal ou C ++, um "método" é uma função associada a um objeto. Assim, por exemplo, um objeto "Cão" pode ter uma função "casca" e isso seria considerado um "Método". Por outro lado, a função "StrLen" fica sozinha (fornece o comprimento de uma sequência fornecida como argumento). Portanto, é apenas uma "função". O Javascript também é tecnicamente orientado a objetos, mas enfrenta muitas limitações em comparação com uma linguagem completa como C ++, C # ou Pascal. No entanto, a distinção ainda deve se manter.

Alguns fatos adicionais: o C # é totalmente orientado a objetos, para que você não possa criar "funções" independentes. Em C #, toda função é vinculada a um objeto e, portanto, tecnicamente, é um "método". O ponto principal é que poucas pessoas em C # se referem a elas como "métodos" - elas apenas usam o termo "funções" porque não há nenhuma distinção real a ser feita.

Finalmente - apenas para que nenhum guru de Pascal pule sobre mim aqui - Pascal também diferencia entre "funções" (que retornam um valor) e "procedimentos" que não. O C # não faz essa distinção explicitamente, embora você possa, é claro, optar por retornar um valor ou não.

Desde que você mencionou o Python, o seguinte pode ser uma ilustração útil do relacionamento entre métodos e objetos na maioria das linguagens orientadas a objetos modernas. Em poucas palavras, o que eles chamam de "método" é apenas uma função que recebe um argumento extra (como outras respostas apontaram), mas o Python torna isso mais explícito do que a maioria das linguagens.

# 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")

Agora compare a função greet_with_greetere o método greet: a única diferença é o nome do primeiro parâmetro (na função eu chamei de "greeter", no método eu chamei de "self"). Então, eu posso usar o greetmétodo exatamente da mesma maneira que uso a greet_with_greeterfunção (usando a sintaxe "ponto" para obtê-lo, pois o defini dentro de uma classe):

Greeter.greet(hello_greeter, "World")

Então, eu efetivamente transformei um método em uma função. Posso transformar uma função em um método? Bem, como o Python permite que você mexa com as classes depois de definidas, vamos tentar:

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

Sim, a função greet_with_greeteragora também é conhecida como método greet2. Isso mostra a única diferença real entre um método e uma função: quando você chama um método "ligando" um objeto ao chamar object.method(args), o idioma o transforma magicamente method(object, args).

(Os puristas do OO podem argumentar que um método é algo diferente de uma função, e se você entrar em Python avançado ou Ruby - ou Smalltalk! - você começará a entender o ponto. Também algumas linguagens dão aos métodos acesso especial aos bits de um objeto. a principal diferença conceitual ainda é o parâmetro extra oculto.)

para mim: a função de um método e uma função é a mesma se eu concordar que:

• uma função pode retornar um valor
• pode esperar parâmetros

Assim como qualquer pedaço de código, você pode ter objetos inseridos e um objeto que é o resultado disso. Durante o processo, eles podem alterar o estado de um objeto, mas isso não altera seu funcionamento básico para mim.

Pode haver uma definição diferenciada na chamada de funções de objetos ou outros códigos. Mas isso não é algo para diferenciações verbais e é por isso que as pessoas as trocam? O exemplo menciona o cálculo com o qual eu teria cuidado. porque eu contratar funcionários para fazer meus cálculos:

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

Fazendo dessa maneira, posso confiar que um empregador é responsável pelos cálculos. Se ele quer mais dinheiro, eu o liberto e deixo que a função do coletor de lixo de destituir funcionários não utilizados faça o resto e consiga um novo funcionário.

Mesmo argumentar que um método é uma função de objetos e uma função é uma computação desconectada não vai me ajudar. O próprio descritor da função e, idealmente, a documentação da função me dirão o que precisa e o que pode retornar. O resto, como manipular o estado de algum objeto, não é realmente transparente para mim. Espero que as funções e os métodos entreguem e manipulem o que afirmam sem precisar saber em detalhes como o fazem. Mesmo uma função computacional pura pode alterar o estado do console ou anexar a um arquivo de log.

Não vamos complicar o que deveria ser uma resposta muito simples. Métodos e funções são a mesma coisa. Você chama uma função de função quando está fora de uma classe e chama uma função de método quando é gravada dentro de uma classe.

Pelo meu entendimento, um método é qualquer operação que possa ser executada em uma classe. É um termo geral usado em programação.

Em muitos idiomas, os métodos são representados por funções e sub-rotinas. A principal distinção que a maioria dos idiomas usa para isso é que as funções podem retornar um valor para o chamador e uma sub-rotina não. No entanto, muitas linguagens modernas têm apenas funções, mas, opcionalmente, elas não podem retornar nenhum valor.

Por exemplo, digamos que você queira descrever um gato e gostaria que ele pudesse bocejar. Você criaria uma classe Cat, com um método Yawn, que provavelmente seria uma função sem nenhum valor de retorno.

Para uma aproximação de primeira ordem, um método (no estilo C ++ OO) é outra palavra para uma função de membro, que é uma função que faz parte de uma classe.

Em linguagens como C / C ++, você pode ter funções que não são membros de uma classe; você não chama uma função não associada a uma classe de método.

Função é o conceito que pertence principalmente à programação orientada a procedimentos, onde uma função é uma entidade que pode processar dados e retornar seu valor

Método é o conceito de programação Orientada a Objetos, em que um método é membro de uma classe que processa principalmente nos membros da classe.

As pessoas do IMHO só queriam inventar uma nova palavra para facilitar a comunicação entre os programadores quando queriam se referir às funções dentro dos objetos.

Se você está dizendo métodos, você quer dizer funções dentro da classe. Se você está dizendo funções, significa simplesmente funções fora da classe.

A verdade é que ambas as palavras são usadas para descrever funções. Mesmo que você tenha usado errado, nada de errado acontece. Ambas as palavras descrevem bem o que você deseja alcançar no seu código.

Função é um código que deve desempenhar um papel ( uma função ) de fazer alguma coisa. Método é um método para resolver o problema.

Faz a mesma coisa. É a mesma coisa. Se você quiser ser super preciso e seguir a convenção, poderá chamar métodos como funções dentro dos objetos.

Não sou especialista, mas é isso que sei:

1. Função é um termo da linguagem C, refere-se a um trecho de código e o nome da função será o identificador para usar essa função.

2. Método é o termo OO, normalmente possui um ponteiro this no parâmetro de função. Você não pode invocar esse código como C, é necessário usar o objeto para invocá-lo.

3. Os métodos de chamada também são diferentes. Aqui, invoque um significado para encontrar o endereço desse pedaço de código. C / C ++, o tempo de vinculação usará o símbolo da função para localizar.

4. Objetivo-C é diferente. Invoque o significado de uma função C para usar a estrutura de dados para encontrar o endereço. Isso significa que tudo é conhecido em tempo de execução.

Sei que muitos outros já responderam, mas achei que a seguir é uma resposta de linha única simples, porém eficaz. Embora não pareça muito melhor do que outras respostas aqui, mas se você a ler com atenção, ela terá tudo o que você precisa saber sobre o método vs a função.

Um método é uma função que possui um receptor definido, em termos de POO, um método é uma função na instância de um objeto.

Diferença entre métodos e funções

De ler este documento na Microsoft

Os membros que contêm código executável são coletivamente conhecidos como membros da função de uma classe. A seção anterior descreve métodos, que são o tipo principal de membros da função. Esta seção descreve os outros tipos de membros da função suportados pelo C #: construtores, propriedades, indexadores, eventos, operadores e finalizadores.

Portanto, os métodos são o subconjunto das funções. Todo método é uma função, mas nem toda função é um método, por exemplo, um constructornão pode ser dito como um método, mas é uma função.

Função - Uma função em um trecho de código independente que inclui alguma lógica e deve ser chamada de forma independente e definida fora da classe.

Método - Um método é um trecho de código independente que é chamado em referência a algum objeto e é definido dentro da classe.

Aqui está uma explicação para o método versus função usando exemplos de JavaScript:

test(20, 50); Esta função define e usa para executar algumas etapas ou retornar algo que pode ser armazenado / usado em algum lugar.

Você pode reutilizar o código: defina o código uma vez e use-o várias vezes.

Você pode usar o mesmo código várias vezes com argumentos diferentes, para produzir resultados diferentes.

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(); aqui test () pode ser um método para algum objeto ou um protótipo definido para objetos embutidos, aqui está mais explicação:

Métodos JavaScript são as ações que podem ser executadas nos objetos.

Um método JavaScript é uma propriedade que contém uma definição de função.

Propriedade / método interno para strings em javascript:

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

Exemplo personalizado:

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'

Você pode definir propriedades para String, Array, etc., bem como por exemplo

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");

Algumas referências: Javascript Object Method , Functions , Mais informações sobre prototype

TL; DR

Uma função é um pedaço de código para executar.
Um método é uma função dentro de um objeto.

Exemplo de uma função:

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

Exemplo de um método:

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

É por isso que dizemos que uma palavra-chave "this" dentro de uma Function não é muito útil, a menos que a utilize com call, apply ou bind .. porque call, apply, bind chamará essa função como um método dentro do objeto ==> basicamente converte função em método

Eles geralmente são intercambiáveis, mas um método geralmente se refere a uma sub-rotina dentro de uma classe e uma função geralmente se refere a uma sub-rotina fora da classe. por exemplo, em Ruby:

# function
def putSqr(a)
   puts a ** 2
end


class Math2
   # method
   def putSqr(a)
      puts a ** 2
   end
end

Em Java, onde tudo (exceto instruções de pacote e importação) deve estar dentro da classe, as pessoas quase sempre se referem a elas como "métodos".