Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Video Player
00:00
00:00
00:00
- 2x 2x
- 1.75x 1.75x
- 1.5x 1.5x
- 1.25x 1.25x
- 1.1x 1.1x
- 1x 1x
- 0.75x 0.75x
- 0.5x 0.5x
Say you have several types, all of which have the same methods. Say you want to create a method that calls the same set of methods on each of those types. Go's static typing requires that you create a separate method for each type you want to handle, even if the methods' logic is the same. Or does it? "Interfaces" can help with this sort of problem.
Sprintf
The fmt.Sprintf function takes a formatting string, inserts one or more formatted values into it, and returns the resulting string.
Interfaces
Here are Monitor, HardDrive, and Keyboard types, each of which has its own Specs and Price methods.
package parts
import "fmt"
type Monitor struct {
Resolution string
Connector string
Value float64
}
func (m Monitor) Specs() string {
return fmt.Sprintf("Monitor\nResolution: %s\nConnector: %s", m.Resolution, m.Connector)
}
func (m Monitor) Price() string {
return fmt.Sprintf("$%0.2f", m.Value)
}
type HardDrive struct {
Type string
Connector string
Value float64
}
func (h HardDrive) Specs() string {
return fmt.Sprintf("Hard Drive\nType: %s\nConnector: %s", h.Type, h.Connector)
}
func (h HardDrive) Price() string {
return fmt.Sprintf("$%0.2f", h.Value)
}
type Keyboard struct {
Keys int
Switches string
Value float64
}
func (k Keyboard) Specs() string {
return fmt.Sprintf("Keyboard\nKeys: %d\nSwitch Type: %s", k.Keys, k.Switches)
}
func (k Keyboard) Price() string {
return fmt.Sprintf("$%0.2f", k.Value)
}
This code creates a new interface using the Specs and Price methods:
type Part interface {
Specs() string
Price() string
}
Now that we have a Part interface, we can write a single method that takes a Part parameter. The method will be able to take a Monitor, a HardDrive, or a Keyboard as an argument, because all of those types fulfill the Part interface.
func Summary(part Part) string {
return part.Specs() + "\n" + part.Price()
}
We can also declare a slice that holds Part values, which will then be able to contain Monitor, HardDrive, AND Keyboard values:
catalog := []Part{}
catalog = append(catalog, parts.Monitor{"HDMI", "1080p", 249.99})
catalog = append(catalog, parts.HardDrive{"SSD", "SATA", 149.99})
catalog = append(catalog, parts.Keyboard{108, "Mechanical", 99.99})
for _, part := range catalog {
fmt.Println(Summary(part))
fmt.Println("------------------------")
}
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
Here we have a parts package that
includes our old Monitor struct type.
0:01
It also includes HardDrive and
Keyboard types.
0:05
Each of these three types have specs and
price methods.
0:13
And each of those methods
returns a formatted string.
0:19
By the way,
these methods all use the s print f
0:22
method from the format package
to create the formatted stream.
0:25
The details of s print off
aren't important right now, but
0:29
see the teacher's notes if
you'd like more info about it.
0:32
And here's some code that uses the
monitor, hard drive, and keyboard types.
0:35
We have a monitor summary
function that takes a monitor and
0:39
prints its specs and price.
0:43
A hard drive summary function that takes
a hard drive and prints its specs and
0:45
price, and a keyboard summary
function that takes a keyboard and
0:49
prints its specs and its price.
0:54
We can see in the output that all of
this works, but it's really repetitive.
0:56
We've got three different methods
that essentially do the same thing.
1:00
They take a computer part and
they print its specs and its price.
1:03
The only difference is the type
of part they take as a parameter.
1:07
All the types we've shown you thus
far have been concrete types.
1:11
When you have a concrete type, you know
exactly what it is and what it can do.
1:15
An interface [SOUND] is an abstract type.
1:19
[SOUND] When you have
a value of an interface type,
1:23
you have no idea what it is,
you only know what it can do.
1:25
[SOUND] That is,
you know a method set that it provides.
1:28
An interface type specifies a set of
methods that a concrete type must possess
1:32
to be considered an instance
of that interface.
1:36
A concrete type [SOUND] satisfies an
interface if it possesses all methods that
1:39
the interface requires.
1:44
So when I have a variable that holds
the four legged interface type.
1:46
I have no idea whether it contains a dog,
a cat or something else entirely.
1:49
All I know for sure is that it has [SOUND]
walk and sit methods that I can call.
1:54
Our monitor, hard drive and keyboard
types all have specs and price methods.
1:59
Let's see if we can use the specs and
price methods to declare an interface that
2:04
allows us to treat these
three types the same way.
2:08
First we need to declare an interface
type with all the methods we want
2:13
the type to have.
2:16
We don't have to do this
in the parts package,
2:18
we can do it right here
in the current package.
2:20
So we'll start with the type keyword.
2:23
And then we give it a name,
just like any other type.
2:26
We'll use the name Part.
2:28
We'll follow that with
the keyword interface.
2:31
Followed by curly braces.
2:34
And inside the curly braces,
we're going to include a list of methods.
2:37
For each method we want to include,
we're gonna need the method name, so
2:40
we'll start with specs,
parameters the method should take, if any.
2:44
Specs doesn't take any parameters,
so I'll just leave that blank.
2:48
And the return value, if any.
2:53
It returns a string, so
I'll provide the type string there.
2:56
Then we do the same for the price method.
3:01
We provide its name, any parameters
it takes which, again, it doesn't.
3:02
And the type of the return value,
which is a string.
3:07
In other object oriented languages, we
might have to go into the parts package,
3:11
and add an implements part marker on
the monitor, their hard drive and
3:15
keyboard types, not in go.
3:18
Any type that has the specified methods
automatically satisfies the interface.
3:21
That means, values with the appropriate
methods can now be used in any variable,
3:25
or parameter with a type of part.
3:29
Now that we have a part interface,
3:32
we can replace the monitor summary,
hard drive summary and
3:34
keyboard summary functions with a single
function that takes a part parameter.
3:37
We'll start with the func keyword,
and we'll name it just summary,
3:43
since it can take any type of part.
3:47
We'll take a parameter
which we'll name part.
3:50
And we'll give it a type of Part,
since we're using the Part interface.
3:52
And as before, our Summary
function's going to return a string.
3:58
Then just as we did in the MonitorSummary,
HardDriveSummary and
4:05
KeyboardSummary methods,
we will return a string.
4:09
Which simply consists of
calling the Specs method,
4:15
taking the string that returns, and
concatenating it together with a new
4:21
line and
the result of calling the Price method.
4:25
Then we'll go into the main method and
we use the new Summary method for
4:31
all the method calls.
4:34
So I'll replace the call to the old
MonitorSummary with just a call to
4:37
Summary, I'll replace the call
to the old HardDriveSummary
4:40
with just a call to Summary, and
I'll replace the call to the old
4:43
KeyboardSummary with
just a call to Summary.
4:47
The Summary method has no
problem accepting a monitor,
4:49
a hard drive or a keyboard.
4:53
Because all of those types have specs and
price methods and, therefore,
4:56
satisfy the part interface.
4:59
Let's try running this.
5:02
And we can see that everything
still works in the same way.
5:08
It prints out a monitor,
a hard drive and a keyboard, one by one.
5:11
You don't have to create
separate variables for
5:15
each of those different types either.
5:18
If we were to create a slice
with a type of part.
5:20
And assign that to a variable.
5:26
We'll call it catalog.
5:28
Then we can use that
slice to store values of
5:32
any type that satisfies
the part interface.
5:34
That includes monitors,
hard drives and keyboards.
5:37
So instead of creating a separate
monitor variable here,
5:40
I can just say append catalog.
5:43
So append to the catalog slice.
5:49
And we'll keep the definition of
the monitor value exactly as it is.
5:52
And of course, we need to assign
the result of append back
5:59
to the slice variable.
6:02
So we'll say catalog.
6:04
Equals append catalog,
6:06
Then likewise we'll say catalog = append
6:12
the catalog slice, a new hard drive
6:17
And catalog equals append to
6:25
the catalog slice a new Keyboard.
6:29
Then we can just use a for
6:36
range loop to pass each value in
the slice to the Summary method.
6:37
So we'll say for, we'll ignore the index.
6:41
Because we don't need to print that out.
6:45
And we'll just take
the values from the slice and
6:47
put them in a variable called part.
6:50
So, for range catalog.
6:53
The catalog slice.
6:57
So, for each of those parts,
we'll pass it to the summary function.
7:09
And then we'll print a little divider for
it.
7:14
Let's try saving this and running it.
7:17
And again it works the same way as before.
7:20
We were able to store all three of these
types in a single slice because they all
7:22
match the part interface.
7:27
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up