- Go provides object-oriented capabilities through struct types and interfaces without classes or inheritance. Structs can have methods defined on them to provide behaviors. - Go uses composition over inheritance by allowing structs to be embedded within other structs to reuse their fields and methods. This is how interfaces are implemented in Go through embedding. - Interfaces in Go provide polymorphism by defining a set of common methods. Any type that implements those methods can be used as that interface. This allows for broad interoperability between different types. - While Go does not have subtyping, embedded fields and methods can be "promoted" to outer structs to reuse functionality, providing some object-oriented capabilities without classes or inheritance.

1. Go for Object
Oriented Programmers
!
or
!
Object Oriented Programming
Without Objects

2. • Author of Hugo, Cobra,
Viper & More
• Chief Developer
Advocate for MongoDB
• Gopher
@spf13

3. — txxxxd
“Most of the appeal for me is not
the features that Go has, but
rather the features that have
been intentionally left out.”

4. — Rob Pike
“Why would you have a
language that is not
theoretically exciting?
Because it’s very useful.”

5. “Objects”
in Go

6. Does Go have Objects?
• Go lacks Classes
• Go lacks “Objects”

7. What is an
Object?

8. – Steve Francia
“An object is an
abstract data type that
has state (data) and
behavior (code).”

9. type Rect struct {
width int
height int
}
Type Declaration (Struct)

10. func (r *Rect) Area() int {
return r.width * r.height
}
Declaring a Method

11. func main() {
r := Rect{width: 10, height: 5}
fmt.Println("area: ", r.Area())
}
In Action

12. type Rects []Rect
Type Declaration (Slice)

13. func (rs Rects) Area() int {
var a int
for _, r := range rs {
a += r.Area()
}
return a
}
Declaring a Method

14. func main() {
r := Rect{width: 10, height: 5}
x := Rect{width: 7, height:10}
rs := Rects{r, x}
fmt.Println("r's area: ", r.Area())
fmt.Println("x's area: ", x.Area())
fmt.Println("total area: ", rs.Area())
}
In Action
http://play.golang.org/p/G1OWXPGvc3

15. type Foo func() int
Type Declaration (Func)

16. func (f Foo) Add(x int) int {
return f() + x
}
Declaring a Method

17. func main() {
var x Foo
!
x = func() int { return 1 }
!
fmt.Println(x())
fmt.Println(x.Add(3))
}
In Action
http://play.golang.org/p/YGrdCG3SlI

18. Go Has
“Objects”

19. “Object Oriented”
Go

20. – Wikipedia
A language is usually considered object-based
if it includes the basic capabilities for an
object: identity, properties, and attributes.
A language is considered object-oriented if it
is object-based and also has the capability of
polymorphism and inheritance.

21. Go is Object Based.
!
Is it OO?

22. Inheritance
• Provides reuse of objects
• Classes are created in hierarchies
• Inheritance lets the structure and
methods in one class pass down the
hierarchy

23. Go’s approach
• Go explicitly avoided inheritance
• Go strictly follows the composition over
inheritance principle
• Composition through embedded types

24. Composition
• Provides reuse of Objects
• One object is declared by including other
objects
• Composition lets the structure and methods
in one class be pulled into another

25. – Steve Francia
Inheritance passes “knowledge” down
!
Composition pulls “knowledge” up

26. type Person struct {
Name string
Address
}
!
!
type Address struct {
Number string
Street string
City string
State string
Zip string
}
Embedding Types
Inner Type

27. func (a *Address) String() string {
return a.Number+" "+a.Street+"n"+
a.City+", "+a.State+" "+a.Zip+"n"
}
Declaring a Method

28. func main() {
p := Person{
Name: "Steve",
Address: Address{
Number: "13",
Street: "Main",
City: "Gotham",
State: "NY",
Zip: "01313",
},
}
}
Declare using Composite Literal

29. func main() {
p := Person{
Name: "Steve",
Address: Address{
Number: "13",
Street: "Main",
City: "Gotham",
State: "NY",
Zip: "01313",
},
}
fmt.Println(p.String())
In Action
http://play.golang.org/p/9beVY9jNlW

30. Promotion
• Promotion looks to see if a single inner type can
satisify the request and “promotes” it
• Embedded fields & methods are “promoted”
• Promotion only occurs during usage, not declaration
• Promoted methods are considered for interface
adherance

31. func (a *Address) String() string {
return a.Number+" "+a.Street+"n"+
a.City+", "+a.State+" "+a.Zip+"n"
}
!
func (p *Person) String() string {
return p.Name + "n" + p.Address.String()
}
Not Overloading

32. func main() {
p := Person{
Name: "Steve",
Address: Address{
Number: "13",
Street: "Main",
City: "Gotham",
State: "NY",
Zip: "01313",
},
}
!
fmt.Println(p.String())
fmt.Println(p.Address.String())
}
Both Methods Available
http://play.golang.org/p/Aui0nGa5Xi

33. func isValidAddress(a *Address) bool {
return a.Street != ""
}
!
func main() {
p := Person{ Name: "Steve", Address: Address{ Number: "13", Street:
"Main", City: "Gotham", State: "NY", Zip: "01313"}}
!
fmt.Println(isValidAddress(p))
// cannot use p (type Person) as type Address
// in argument to isValidAddress
fmt.Println(isValidAddress(p.Address))
}
Types Remain Distinct
http://play.golang.org/p/KYjXZxNBcQ

34. Promotion is
NOT Subtyping

35. Polymorphism
• “The provision of a single interface to
entities of different types”
• Typically implmented via Generics,
Overloading and/or Subtyping

36. Go’s approach
• Go explicitly avoided subtyping &
overloading
• Go does not provide Generics (yet)
• Go’s interface provide polymorphic
capabilities

37. Interfaces
• A list of required methods
• Structural vs Nominal typing
• ‘‘If something can do this, then it can be
used here”
• Convention is call it a Something-er

38. type Shaper interface {
Area() int
}
Interface Declaration

39. func Describe(s Shaper) {
fmt.Println("Area is:", s.Area())
}
Using Interface as Param Type

40. func main() {
r := &Rect{width: 10, height: 5}
x := &Rect{width: 7, height: 10}
rs := &Rects{r, x}
Describe(r)
Describe(x)
Describe(rs)
}
In Action
http://play.golang.org/p/WL77LihUwi

41. –James Gosling (creator of Java)
“If you could do Java over again, what would you
change?” “I’d leave out classes,” he replied. After the
laughter died down, he explained that the real
problem wasn’t classes per se, but rather
implementation inheritance (the extends
relationship). Interface inheritance (the implements
relationship) is preferable. You should avoid
implementation inheritance whenever possible.

42. Go Interfaces are
based on
implementation,
not declaration

43. The Power of
Interfaces

44. type Reader interface {
Read(p []byte) (n int, err error)
}
io.Reader

45. io.Reader
• Interface
• Read reads up to len(p) bytes into p
• Returns the # of bytes read & any error
• Does not dictate how Read() is implemented
• Used by os.File, bytes.Buffer, net.Conn,
http.Request.Body, loads more

46. type Writer interface {
Write(p []byte) (n int, err error)
}
io.Writer

47. io.Writer
• Interface
• Write writes up to len(p) bytes into p
• Returns the # of bytes written & any error
• Does not dictate how Write() is implemented
• Used by os.File, bytes.Buffer, net.Conn,
http.Response.Body, loads more

48. func MarshalGzippedJSON(r io.Reader,
v interface{}) error {
raw, err := gzip.NewReader(r)
if err != nil {
return err
}
return json.NewDecoder(raw).Decode(&v)
}
io.Reader in Action

49. f, err := os.Open("myfile.json.gz")
if err != nil {
log.Fatalln(err)
}
defer f.Close()
m = make(map[string]interface{})
MarshalGzippedJSON(f, &m)
Reading a json.gz file

50. Practical Interoperability
• Gzip.NewReader(io.Reader)
• Works on files, http requests, byte buffers,
network connections, …anything you create
• Nothing special needed in gzip to be able to
do this… Simply call Read(n) and leave the
abstracting to the implementor

51. func main() {
resp, err := http.Get("...")
if err != nil {
log.Fatalln(err)
}
defer resp.Body.Close()
out, err := os.Create("filename.ext")
if err != nil {
log.Fatalln(err)
}
defer out.Close()
io.Copy(out, resp.Body) // out io.Writer, resp.Body io.Reader
}
Pipe http response to file

52. Go

53. — Steve Jobs
Simple can be harder than
complex: You have to work hard
to get your thinking clean to
make it simple. But it's worth it
in the end because once you get
there, you can move mountains.

54. Go is simple,
pratical &
wonderful

55. Go build
something
great

56. Thank You