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 the 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 define 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 extensibility and compos-ability for Go applications. Interface types express generalizations or abstractions about the behaviors of other types.
Here the key features of Go Lang:
- Code transparency: With Go, you will know exactly with the code is doing and will be able to accurately estimate how much time and memory it is utilizing. Go Lang follows a standard code format generated by the FMT tool automatically.
- Minimalist language: Go is a simple language that follows a minimalistic approach. Thereby, for new developers the learning curve to not too steep. A few basic, orthogonal features compose the core Go language that can be combined in a relatively limited number of ways. This makes learning the language and reading and writing programs simpler. Expert programmers can learn the language from the specifications themselves and Go provides automatically generated documentation keeping the interface minimal with very little to learn.
- Better Performance: The performance of Go Lang is enhanced by its standard libraries that provide optimized code derived from efficient algorithms. It stands against any memory leads with the garbage collected feature. Just like C or C++, go does not need any interpretation as it is a compiled language and by doing away with an interpreted your Go-built app will be more error-free. In terms of system requirements, this language is not very demanding, this means that users with older devices can also access your application.
- Supports Testing: Go Lang combines unit testing and coding. It offers an easy mechanism for writing your unit tests with your code in parallel. The tool also assists in interpreting the code coverage through your tests, benchmarking tests, and writing sample code used to produce your code documentation.
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
Stay connected