#include <string>
#include <iostream>

class person
{
   // These are things no one else
   // can touch directly.  They're in
   // the "box".
   private:
      std::string name;

   // Things the outside world can
   // interact with.
   public:
      // A construct which accepts
      // a string.  The string initializes
      // the name, but in the interface
      // we don't care about the name
      // of the parameter.
      person(std::string);

      // Since our name is hidden away
      // we need an "accessor" to get
      // to it, preventing direct access.
      std::string get_name() const;

      // We give ourperson the ability
      // to say hello to another person.
      void say_hello_to(const person&) const;

      // You'll notice the use of "const".
      // This can be used by any action
      // that doesn't change the inner state
      // of our object.

      // Overload the << operator to make
      // it easy to output the person's name.
      friend std::ostream& operator<<(std::ostream&, const person&);
};

int main()
{
   person bob("Bob"), john("John");

   bob.say_hello_to(john);
   john.say_hello_to(bob);

   return 0;
}

// Now we can define "how"
// our class does what it does.
person::person(std::string init_name) : name(init_name) { }

std::string person::get_name() const
{
   return name;
}

void person::say_hello_to(const person& p) const
{
   std::cout << "Hi, " << p << "!  My name is " << *this << std::endl;
}

std::ostream& operator<<(std::ostream& out, const person& p)
{
   return out << p.name;
}

// in Objective-C

#import <objc/Object.h>
#import <string.h>
#import <stdio.h>

@interface Person : Object
{
        @private
                char * name;
}
- initWithName: (const char *) initName;
- (char *) getName;
- (void) sayHelloTo: (Person *) p;
@end

int main()
{
        Person * bob  = [[Person alloc] initWithName: "Bob" ];
        Person * john = [[Person alloc] initWithName: "John"];
       
        [bob sayHelloTo: john];
        [john sayHelloTo: bob];
       
        return 0;
}

@implementation Person
- initWithName: (const char *) initName
{
        [super init];
        name = (char *)malloc(sizeof(char *));
        strcpy(name, initName);
        return self;
}
- (char *) getName
{
        return name;
}
- (void) sayHelloTo: (Person *) p
{
        printf("Hi, %s! My name is %s\n", [p getName], [self getName]);
}
@end

// in Java

import java.lang.*;
import java.io.*;

public class MyProgram {
        private class Person {
                private String name;
               
                public Person(String initName) {
                        name = initName;
                }
               
                public String getName() {
                        return name;
                }
               
                public void sayHelloTo(Person p) {
                        System.out.println("Hi, " + p.getName() + "! My name is " + getName());
                }
        }
       
        public static void main(String[] args) {
                Person bob  = new Person("Bob");
                Person john = new Person("John");
               
                bob.sayHelloTo(john);
                john.sayHelloTo(bob);
        }
}

# in Python

class Person:
        def __init__(self, initName):
                self.__name = initName
        def getName(self):
                return self.__name
        def sayHelloTo(self, p):
                print "Hi, " + p.getName() + "! My name is " + self.getName()
               
bob = Person("Bob")
john = Person("John")

bob.sayHelloTo(john)
john.sayHelloTo(bob)

# in Ruby

class Person
        private
        attr_writer :name
       
        public
        attr_reader :name
       
        def initialize(name)
                @name = name
        end
       
        def say_hello_to(p)
                puts "Hi, " + p.name + "! My name is " + name
        end
end

bob = Person.new("Bob")
john = Person.new("John")

bob.say_hello_to(john)
john.say_hello_to(bob)

-- in Eiffel

class PERSON
creation with_name
feature { NONE } name : STRING
feature { ANY }
        with_name(init_name : STRING) is
                do
                        name := init_name
                end
        get_name : STRING is
                do
                        Result := name
                end
        say_hello_to(p : PERSON) is
                do
                        std_output.put_string("Hi, " + p.get_name + "! My name is " + name)
                        std_output.put_new_line
                end
end

class TEST
creation make
feature { ANY }
        make is
                local
                        bob, john : PERSON
                do
                        create bob.with_name("Bob")
                        create john.with_name("John")
                       
                        bob.say_hello_to(john)
                        john.say_hello_to(bob)
                end
end

# in Perl 5

package Person;

sub new {
        my $class = shift;
        my $name  = shift || "";
        my $self  = {"name" => $name};
       
        bless $self, $class
}

sub name
{
        my $self = shift;
       
        return $self->{"name"}
}

sub say_hello_to {
        my $self = shift;
        my $p    = shift;
       
        print "Hi, ${$p->name}! My name is ${$self->name}\n"
}

package main;

my $bob  = Person->new("Bob");
my $john = Person->new("John");

$bob->say_hello_to($john);
$john->say_hello_to($bob);