Golang中面向对象的知识,包括接口的定义、多态的定义与实现、关于多态的应用案例、空接口、类型断言等等。
接口简介
概念:规定了要做哪些事,具体做什么,接口不管,把所有有共性的方法定义在一起,任何其他类型只要实现这些方法就是实现了这个接口。
接口的定义方式
只是和接口中的方法同名
//type 接口名字 interface{方法声明}
type Personer interface{//接口名+er
SayHello()
Say()
}
type Student struct{
}
func (s *Student) SayHello(){
fmt.Println("老师好")
}
type Teacher struct{
}
func (t *Teacher) SayHello(){
fmt.Println("学生好")
}
func main(){
//对象名.方法名
var stu Student
stu.SayHello()
var teacher Teacher
teacher.SayHello()
//通过接口变量调用,必须都实现接口中所声明的方法
var person Personer
person = &stu
person.SayHello()//调用的是student 实现的SayHello方法
person = &teacher
person.SayHello()//调用的是student 实现的SayHello方法
}
多态定义与实现
概念:指多种变现形式,同一个接口,使用不同的实例而执行 不同的操作。
//func 函数名(参数 接口类型){}
type Personer interface{//接口名+er
SayHello()
}
type Student struct{
}
func (s *Student) SayHello(){
fmt.Println("老师好")
}
type Teacher struct{
}
func (t *Teacher) SayHello(){
fmt.Println("学生好")
}
//多态
func WhoSayHi(h Personer){
h.SayHello()
}
func main(){
var stu Student
var teacher Teacher
WhoSayHi(&stu)
WhoSayHi(&teacher)
}
多态运用案例
计算器第一个版本
//1.第一个类
type Object struct{
}
//2.添加一个方法
func (o *Object) GetResult(numA int,numB int,op string){
//1.添加参数
//2.判断运算方式
switch op{
case "+":
result=numA+numB
case "-":
result=numA-numB
}
return result
}
func main(){
var obj Object
num := obj.GetResult(8,6,"+")
fmt.Println(num)
}
计算器第二个版本:改进提高安全性,运用接口
//加法类
type Add struct{
Object
}
func (a *Add) GetResult() int{//方法的实现要和接口中方法的声明保持一致
return a.sunA + a.numB
}
//减法类
type Sub struct{
Object
}
func (s *Sub) GetResult() int{//方法的实现要和接口中方法的声明保持一致
return s.sunA - s.numB
}
type Object struct{
numA int
numB int
}
type Resulter interface{
GetResult() int//有返回类型
}
func main(){
add := Add{Object{10,20}}
num := add.GetResult()
fmt.Println(num)
sub := Sub{Object{10,20}}
num := sub.GetResult()
fmt.Println(num)
}
计算器第三个版本:对象创建问题
//加法类
type Add struct{
Object
}
func (a *Add) GetResult() int{//方法的实现要和接口中方法的声明保持一致
return a.sunA + a.numB
}
//减法类
type Sub struct{
Object
}
func (s *Sub) GetResult() int{//方法的实现要和接口中方法的声明保持一致
return s.sunA - s.numB
}
type Object struct{
numA int
numB int
}
type Resulter interface{
GetResult() int//有返回类型
}
//定义一个新的类,创建一个方法,在该方法中完成对象的创建
type OperatoeFactory sturct{
}
func (o *OperatoeFactory) CreateOperator(op string,numA int,numB int) int{
switch op{
case "+":
add := Add{Object{numA,numB}}
return OperatorWho(&add)
case "-":
sub := Sub{Object{numA,numB}}
return OperatorWho(&sub)
default :
return 0
}
}
func OperatorWho(h Resulter) int{//多态
return h.GetResult()
}
func main(){
var operator OperatorFactory
num := operator.CreateOperator("+",20,10)
fmt.Println(num)
}
接口继承与转换
type Humaner interface{
SayHello()
}
type Personer interface{
Humaner//继承接口
Say()
}
type Student struct{
}
func (s *Student) SayHello(){
fmt.Println("大家好")
}
func (s *Student) Say(){
fmt.Println("你好")
}
func main(){
var stu Student
var per Personer
per = &stu
per.Say()
per.SayHello()//可以调用所继承的接口中的方法
//接口转换
var h Humaner
h = per
//per = h错误
h.SayHello()
}
空接口定义与使用
概念:不包括任何的方法,所有的类型都实现了空接口,因此空接口可以存储任意类型的数值。
func main(){
var i interface{}
i = 123
i = "abc"
fmt.Println(i)
//空接口类型切片
var s[]intterface{}
s = append(s,123,"abc",12.3)
for j:=0;j<len(s);j++{
fmt.Println(s[j])
}
}
类型断言
概念:可以判断空接口中存储的数据类型
语法:value,ok:=m.(T)
m:表示空接口类型变量
T:是断言的类型
value:变量m中的值
ok:布尔类型变量,如果断言成功为true,否则为false
func main(){
var i interface{}
i = 123
value,ok := i.(int)
if ok{
fmt.Println(value+10)
}else{
fmt.Println("类型推断错误")
}
}
空接口与类型断言综合应用
//加法类
type Add struct{
Object
}
func (a *Add) GetResult() int{//方法的实现要和接口中方法的声明保持一致
return a.sunA + a.numB
}
func (a *Add) SetData(data ...interface) bool{
//1.对数据的个数进行校验
var b bool = true
if len(data)>2{
fmt.Println("参数个数错误!")
b = false
}
value,ok := data[0].(int)
if !ok{
fmt.Println("第一个数类型错误!")
b = false
}
value1,ok1 := data[1].(int)
if !ok{
fmt.Println("第二个数类型错误!")
b = false
}
a.numA = value
a.numB = value1
//2.类型校验
reture b
}
//减法类
type Sub struct{
Object
}
func (s *Sub) GetResult() int{//方法的实现要和接口中方法的声明保持一致
return s.sunA - s.numB
}
func (s *Sub) SetData(data ...interface) bool{
//1.对数据的个数进行校验
var b bool = true
if len(data)>2{
fmt.Println("参数个数错误!")
b = false
}
value,ok := data[0].(int)
if !ok{
fmt.Println("第一个数类型错误!")
b = false
}
value1,ok1 := data[1].(int)
if !ok{
fmt.Println("第二个数类型错误!")
b = false
}
s.numA = value
s.numB = value1
//2.类型校验
reture b
}
//
type Object struct{
numA int
numB int
}
type Resulter interface{
GetResult() int//有返回类型
SetData(data ...interface{}) bool//完成参数运算的数据的类型校验
}
//定义一个新的类,创建一个方法,在该方法中完成对象的创建
type OperatoeFactory sturct{
}
func (o *OperatoeFactory) CreateOperator(op string) Resulter{
switch op{
case "+":
add := new(Add)
return add
case "-":
sub := new(Sub)
return sub
default :
return nil
}
}
func OperatorWho(h Resulter) int{//多态
return h.GetResult()
}
func main(){
var operator OperatorFactory
obj := num := operator.CreateOperator("+")
b := obj.SetData(30,10)
if b{
num := OperatorWho(obj)
fmt.Println(num)
}
}