Go is a programming language created at Google in 2009 by Robert Griesemer, Rob Pike, and Ken Thompson. It’s very easy to learn, and yet incredibly powerful, especially for concurrency. Apps built on this language can perform better than most of the other languages for similar purpose especially against dynamically typed language like PHP, ruby, python.,
Go is a decent choice for writing servers that handle thousands of queries per second with latencies of a few milliseconds.
Since Go as a programming language is a great choice to learn but the concept of object-oriented programming is revisited in Golang. Go language does not have the concept of class(instead it contain Struct), does not have support for inheritance(instead of support composition). Go language has been criticised for lack of generic support.
Go doesn’t have classic Object Oriented concept of classes and inheritance. Interfaces in Go provide a way to specify the behavior of an object: do like this and reuse it.
In Go programming language Interfaces are types that just defines a set of methods (the method set), but these methods do not contain code. This method is never implemented by the interface type directly. Also, an interface cannot contain variables. Go’s interface type provides a lot of extensible and compos-ability for Go applications. Interface types express generalizations or abstractions about the behaviors of other types.
Comparing instance of Java with Go lang, Java interface must be explicitly implemented by Java-like shown below:
public class Foo implements InterfaceName{
}
In Golang, the interface is not implemented explicitly like java but satisfied by type method.
Go also doesn’t have the typical class-like inheritance you’re normally used to, but it does have a couple of things that are pretty close.
# interface_demo.go
package main
import "fmt"
type Foo struct {
}
func (f Foo) String() string {
return fmt.Sprintf("Empty Foo")
}
func main() {
f := Foo{}
fmt.Println(f)
}
When I run above code with the command `go run interface_demo.go`, it will print `Empty Foo`
As I have already mentioned that Golang does not class instead it has type and struct. On above example, method ‘string’ added to Foo struct. ‘String()’ method is defined inside stringer interface defined in Golang. fmt.Printf calls the String method if available (checks if the provided variable satisfies Stringer interface).
Now we are going see(below code) how to duck type one subtype into superclass. We can substitute the struct variable with `interface` variable since all struct implements interface defined function.
package main
import "fmt"
type Animal interface{
walk()
}
type Human struct {
}
type Dog struct {
}
func (Human) walk(){
fmt.Println("its human walking")
}
func (Dog) walk(){
fmt.Println("its Dog walking")
}
func printall_walker(a [] Animal){
for _, a := range a {
a.walk()
}
}
func main() {
printall_walker([] Animal{Human{}, Dog{}})
}
As seen above, Animal is an interface where method `walk` has been defined. Human and Dog struct added walk method, its mean implicitly implemented `Animal` interface. As we can see, now Human and Dog can be passed into Animal interface object.
Originally published in https://narutosanjiv.wordpress.com
Related posts
Leave a Reply Cancel reply
Twitter Feed
Did you know? 44% of in-app defects are found by users. #Applications need to be maintained and upgraded regularly.… https://t.co/TLS313QTJJ
FollowHere are the Digital Transformation Tips that will transform your strategy in 2021: . . #DigitalTransformation … https://t.co/YTFuYziRqq
FollowLearn all about these top 5 web design trends of 2021 @ https://t.co/s6QxRfQty7 . . . . #WebDesignTrends #WebDesignTrends … https://t.co/s6QxRfQty7
FollowAccording to Statista, more than 100,000 new applications are released on google play every month. . . . . . . .… https://t.co/XYx0JVdxYO
Follow
Stay connected