The object reference this

• Sometimes an object wants to refer to itself, i.e.:
  • within a constructor, refer to the object that is being constructed, or
  • within an instance method, refer to the object that is running the method
• Refer to it using this
  • this is a local variable
  • but it is automatically declared in every constructor and instance method
  • it is automatically initialized to refer to the current object
  • (There is another separate use of this. Don't confuse them)

BankAccount again

• We will rewrite the BankAccount class definition to use this
  A reminder of its interface:
  • public BankAccount(String name)
  • public void deposit(int amount)
  • public void withdraw(int amount)
  • public int getBalance()
  • public int getNumTransactions()
  • public String toString()
  • public void transfer(int amount, BankAccount destination)

Object-oriented programming in Python

• Python uses self in a similar way to how Java uses this
• But, as we have seen with BankAccount, in Java use of this is not necessary
  • unless local variables/formal parameters have the same name as instance variables
• But in Python, since variables are not declared, the only way Python can distinguish instance variables from local variables/formal parameters is use of self
  • so it is not optional, and
  • you are required to make it explicit when defining functions and constructors

Compare and contrast

class Dog :
 
 
 
 
 
    def __init__(self, name, age, breed) :
        self.name = name
        self.age = age
        self.breed = breed
  
    
    def bark(self) :
        print("Ruff ruff!")
  
    
    def setName(self, name) :
        self.name = name
  
    
    def setAge(self, age) :
        self.age = age
  
    
    def setBreed(self, breed) :
        self.breed = breed
  
    
    def getName(self) :
        return self.name
  
    
    def getAge(self) :
        return self.age
  
    
    def getBreed(self) :
        return self.breed
  
    
    def __str__(self) :
        return self.name + " is a " + 
            str(self.age) + " year old " + 
            self.breed
            
            

class Dog {

    private String name;
    private int age;
    private String breed;
    
    public Dog(String name, int age, String breed) {
        this.name = name;
        this.age = age;
        this.breed = breed;
    }
    
    public void bark() {
        System.out.println("Ruff ruff!");
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public void setBreed(String breed) {
        this.breed = breed;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public String getBreed() {
        return breed;
    }
    
    public String toString() {
        return name + " is a " + 
            age + " year old " + breed;
    }

}

Compare and contrast

from dog import Dog
 
 
d1 = Dog("Charles", 2, "Charlywawa")
d2 = Dog("Colin", 7, "Colombian Drug Lord")
        
d1.bark()
        
d2.setAge(8)
        
print(d2)
 
 

class DogTester {

   public static void main(String[] args) {
      Dog d1 = new Dog("Charles", 2, "Charlywawa");
      Dog d2 = new Dog("Colin", 7, "Colombian Drug Lord");
        
      d1.bark();
        
      d2.setAge(8);
        
      System.out.println(d2);
    }
}

Nothing is private in Python

• Python does not have Java's visibility modifiers
• So,
  • we cannot make the instance variables private
  • 'clients' of a class can access all its instance variables and all its methods
  • we cannot 'hide' the implementation – we don't have proper encapsulation
• Python programmers have adopted a convention
  • for instance variables, they use names that start with underscore
  • they use self-discipline to never use a variable whose name begins with underscore in 'client' code