Object Model Comparisons

Transcription

1 Object Model Comparisons 1 Languages are designed, just like programs Someone decides what the language is for Someone decides what features it's going to have Can't really understand a language until you have seen at least two Java and Python have more similarities than differences But the differences help explain why each language is the way it is 2 Java uses strong typing Type of each variable must be declared Variable X of type T can only refer to instances of that type (or derived types) Allows method overloading on argument type Python uses untyped variables and typed values Eliminates need for type declarations But makes overloading on argument type impossible Have to switch on type instead which is harder to extend 3 Both languages distinguish between primitive types and reference types Distinction made for performance reasons Primitive types: Simple data values (e.g. integer) without methods Immutable: Cannot be changed Reference types: Dynamically allocated and referenceable Have methods 4

2 In Smalltalk and Ruby, everything is a firstclass object with methods For example, a number is an object with methods: 5.upto(10) 5 In C++, objects can be on the stack, or on the heap If they are on the stack, they are automatically destroyed when the declaring method returns, which opens up a ton of security holes class C { public C() { x = 0; public int x; C *good() { return new C(); C *bad() { C onstack; return &onstack; 6 Do memory model drawing Python "objects" are dictionaries Syntax is a little different The notation x.y means (something like) x["y"] Can access this dictionary directly as x. dict Can add new members/methods on the fly Just as you do in a Python constructor Very handy But can easily yield unmaintainable code 7 class Pair: def init (self, left, right): self.left = left self.right = right p1 = Pair("a", "b") print p1. dict 'left': 'a' # {'right': 'b', p1.middle = "hello" print p1.middle # hello print p1. class. dict {' module ': ' main ', ' doc ': None, ' init ': <function init at 0x00867FB8> 8

3 Java's object model is static Methods are compiled to create blocks of code Once loaded, code cannot be modified New code cannot be generated on the fly Except by writing text, compiling it, and loading result Python's object model is dynamic Code is compiled as it is seen New methods can be loaded on top of old ones Methods can be added to classes after they have been created 9 class C: def init (self): self.value = 0 def method(self, arg): self.value += arg def str (self): return `self.value` obj = C() obj.method(5) print obj def func(self, arg): self.value -= arg C.func = func obj.func(2) print obj Every programming system turns text into instructions, then executes the instructions In Java and C++, done by by compiler and runtime In Python, done by the interpreter So why not compile, load, and execute code within a running program? Allows programs to add new code to themselves This is how import works Allows users to enter commands on the fly Opens up a ton of security holes 11 import sys x = 1 y = 2 z = eval("x + y") print z # 3 line = sys.stdin.readline() # user enters "print x + y + z" eval(line) # 6 12

4 Java classes can extend one parent, and implement zero or more interfaces Python has no notion of an "interface" Methods are looked up at runtime So X and Y are interchangeable if their methods have the same names and number of arguments No common ancestors required Python classes can extend any number of parents Multiple inheritance 13 class Divider: def init (self, val): self.div = val def dodiv(self, input): return input / self.div class Multiplier: def init (self, val): self.mul = val def domul(self, input): return input * self.mul f = Factor(2, 5) print f.dodiv(4) print f.domul(3) 2 15 class Factor(Divider, Multiplier): def init (self, d, m): Divider. init (self, d) Multiplier. init (self, m) 14 Multiple inheritance obviously useful But how to handle collisions? Any useful programming language contains a certain amount of grit You can move it around, but you can't get rid of it How to handle collisions? Outlaw multiple inheritance Require users to resolve collisions when declaring derived classes Specify a search order 15 inherits x defines y B : x y A : x defines x C : x z inherits x defines z D : x y z Whose x is this? or are there two? 16

5 There are many other ways to implement inheritance E.g. JavaScript has no classes Add members and methods to one object Then clone it to create new instances A prototype-based language Inheritance implemented by: Cloning the parent Adding/changing members and methods Using the modified child as a new prototype 17 C++ supports generic programming using templates. (Java 1.5, Java 6 does too, somewhat similarly.) Don t specify types when defining classes instead use type variables Then instantiate that class by filling in those placeholders with actual types Compiler can often do this automatically Allows programmers to express patterns that cut across type hierarchies E.g. swap, min, max, etc. 18 class Pair<T> { public Pair(T a, T b) { x = a; y = b; public T x; public T y; public class Example { public static <T> void swap(pair<t> p) { T tmp = p.x; p.x = p.y; p.y = tmp; There is no such thing as "the best language C++ is faster than Java, but permits errors that Java doesn't Multiple inheritance allows reuse, but complicates maintenance But some are better than others E.g. Python is more readable than Perl Each one is a vehicle for expressing certain patterns The patterns are what matters 20