Object oriented programming in go

Object-Oriented Programming in
Go
Go Seoul Meetup
24 January 2015
장재휴
Developer, Purpleworks

Who am I
Elandsystems ➜ purpleworks
Ruby, C#, Go

What is "Object Oriented" (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

What is an "Object" (wikipedia)
An object is an abstract data type that has state(data) and behavior(code)

Object in Go (via Custom Type & Method)
package main
import "fmt"
// Type Declaration
type Item struct {type Item struct {
name string
price float64
quantity int
}
// Method Declaration
func (t Item) Cost() float64 {func (t Item) Cost() float64 {
return t.price * float64(t.quantity)
}
// In Action
func main() {
shirt := Item{name: "Men's Slim-Fit Shirt", price: 25000, quantity: 3}
fmt.Println("cost: ", shirt.Cost())fmt.Println("cost: ", shirt.Cost())
} Run

Custom Type of built-in Type
// Type Declaration
type Items []Itemtype Items []Item
func (ts Items) Cost() float64 {func (ts Items) Cost() float64 {
var c float64
for _, t := range ts {
c += t.Cost()
}
return c
}
// In Action
func main() {
shoes := Item{name: "Sports Shoes", price: 30000, quantity: 2}
items := Items{shirt, shoes}
fmt.Println("cost of shirt: ", shirt.Cost())
fmt.Println("cost of shoes: ", shoes.Cost())
fmt.Println("total cost: ", items.Cost())
} Run

Go is Object-based
Via custom type and methods

Is Go Object-oriented Language?

What is "Inheritance" (wikipedia)
Provides reuse of existing objects
Classes are created in hierarchies
Inheritance passes knowledge down!

Inheritance is not good
In Java user group meeting,
James Gosling (Java’s inventor) says:
You should avoid implementation inheritance whenever possible.

Go's approach
Go avoided inheritance
Go strictly follows the Composition over inheritance principle

What is Composition
Provides reuse of Objects
One object is declared by containing other objects
Composition pulls knowledge into another

Composition in Go
// Type Declaration
type Item struct {
name string
price float64
quantity int
}
type DiscountItem struct {
ItemItem
discountRate float64
}
// In Action
func main() {
eventShoes := DiscountItem{eventShoes := DiscountItem{
Item{name: "Women's Walking Shoes", price: 50000, quantity: 3},Item{name: "Women's Walking Shoes", price: 50000, quantity: 3},
10.00,10.00,
}}
fmt.Println("shoes: ", shoes)
fmt.Println("eventShoes: ", eventShoes)
} Run

Call Method of Embedded Type
type DiscountItem struct {
Item
discountRate float64
}
func (t Item) Cost() float64 {func (t Item) Cost() float64 {
return t.price * float64(t.quantity)return t.price * float64(t.quantity)
}}
// In Action
func main() {
eventShoes := DiscountItem{
Item{name: "Women's Walking Shoes", price: 50000, quantity: 3},
10.00,
}
fmt.Println("cost of shoes: ", shoes.Cost())fmt.Println("cost of shoes: ", shoes.Cost())
fmt.Println("cost of eventShoes: ", eventShoes.Cost())fmt.Println("cost of eventShoes: ", eventShoes.Cost())
} Run

Method Overriding
func (t Item) Cost() float64 {
return t.price * float64(t.quantity)
}
func (t DiscountItem) Cost() float64 {func (t DiscountItem) Cost() float64 {
return t.Item.Cost() * (1.0 - t.discountRate/100)return t.Item.Cost() * (1.0 - t.discountRate/100)
}}
// In Action
func main() {
10.00,
}
fmt.Println("cost of eventShoes: ", eventShoes.Cost())
} Run

Composition in Go 2
// Type Declaration (embedded field)
type Order struct {
ItemsItems
taxRate float64
}
// Overriding Methods
func (o Order) Cost() float64 {func (o Order) Cost() float64 {
return o.Items.Cost() * (1.0 + o.taxRate/100)
}
func main() {
items := Items{shirt, shoes}
order := Order{Items: items, taxRate: 10.00}
fmt.Println("total cost(included Tax): ", order.Cost())
} Run

Composition in Go 3
func main() {
10.00,
}
items := Items{shirt, shoes, eventShoes}
} Run

Composition in Go 4
func main() {
10.00,
}
items := Items{shirt, shoes, eventShoes}
} Run

What is "Polymorphism" (wikipedia)
The provision of a single interface to entities of diﬀerent types
Via Generics, Overloading and/or Subtyping

Go’s approach
Go avoided subtyping & overloading
Go does not provide Generics
Polymorphism via interfaces

Interfaces in Go
Interfaces are just sets of methods
Interfaces deﬁne behavior (duck typing)
"If something can do this, then it can be used here”

Interfaces in Go
type Rental struct {
name string
feePerDay float64
periodLength int
RentalPeriod
}
type RentalPeriod int
const (
Days RentalPeriod = iota
Weeks
Months
)
func (p RentalPeriod) ToDays() int {
switch p {
case Weeks:
return 7
case Months:
return 30
default:
return 1
}
}

Interfaces in Go
func (r Rental) Cost() float64 {
return r.feePerDay * float64(r.ToDays()*r.periodLength)
}
// Interface Declaration
type Coster interface {type Coster interface {
Cost() float64Cost() float64
}}
func DisplayCost(c Coster) {func DisplayCost(c Coster) {
fmt.Println("cost: ", c.Cost())
}
// In Action
func main() {
video := Rental{"Interstellar", 1000, 3, Days}
fmt.Printf("[%v] ", shirt.name)
DisplayCost(shirt)DisplayCost(shirt)
fmt.Printf("[%v] ", video.name)
DisplayCost(video)DisplayCost(video)
} Run

Interfaces in Go 2
// Interface Declaration
type Coster interface {
Cost() float64
}
// Items
type Items []Costertype Items []Coster
func main() {
10.00,
}
items := Items{shirt, video, eventShoes}
DisplayCost(shirt)
DisplayCost(video)
DisplayCost(eventShoes)
DisplayCost(items)
DisplayCost(order)
}
Run

Satisfying Interface of Other Package
fmt.Println
func Println(a ...interface{}) (n int, err error) {
return Fprintln(os.Stdout, a...)
}
func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
...
// print using Stringer interface
...
return
}
fmt.Stringer
type Stringer interface {
String() string
}

// Stringer
func (t Item) String() string {
return fmt.Sprintf("[%s] %.0f", t.name, t.Cost())
}
func (t Rental) String() string {
return fmt.Sprintf("[%s] %.0f", t.name, t.Cost())
}
func (t DiscountItem) String() string {
return fmt.Sprintf("%s => %.0f(%.0f%s DC)", t.Item.String(), t.Cost(), t.discountRate, "%")
}
func (t Items) String() string {
return fmt.Sprintf("%d items. total: %.0f", len(t), t.Cost())
}
func (o Order) String() string {
return fmt.Sprintf("Include Tax: %.0f(tax rate: %.2f%s)", o.Cost(), o.taxRate, "%")
}

func main() {
10.00,
}
items := Items{shirt, video, eventShoes}
fmt.Println(shirt)
fmt.Println(video)
fmt.Println(eventShoes)
fmt.Println(items)
fmt.Println(order)
} Run

Deep into Go's Standard Library
io.Writer interface
// http://godoc.org/io#Writer
type Writer interface {
Write(p []byte) (n int, err os.Error)
}
fmt.Fprintln function
func Fprintln(w io.Writer, a ...interface{}) (n int, err error)

The Power of Interfaces
In handle function, just write to io.Writer object
func handle(w io.Writer, msg string) {
fmt.Fprintln(w, msg)
}
The os.Stdout can be used for io.Writer.
func main() {
msg := []string{"hello", "world", "this", "is", "an", "example", "of", "io.Writer"}
for _, s := range msg {
time.Sleep(100 * time.Millisecond)
handle(os.Stdout, s)handle(os.Stdout, s)
}
} Run

The Power of Interfaces
The http.ResponseWriter can be used for io.Writer.
localhost:4000/hello-world(http://localhost:4000/hello-world)
localhost:4000/this-is-an-example-of-io.Writer(http://localhost:4000/this-is-an-example-of-io.Writer)
func handle(w io.Writer, msg string) {
fmt.Fprintln(w, msg)
}
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
handle(w, r.URL.Path[1:])handle(w, r.URL.Path[1:])
})
fmt.Println("start listening on port 4000")
http.ListenAndServe(":4000", nil)
} Run

Thank you
장재휴
Developer, Purpleworks
jaehue@jang.io(mailto:jaehue@jang.io)

Object oriented programming in go

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Object oriented programming in go

Ähnlich wie Object oriented programming in go (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Object oriented programming in go