留乘船
留乘船

go的面向对象学习

文章目录

    • 面向对象编程(上)
      • 1.问题与解决思路
      • 2.结构体
        • 1》Golang语言面向对象编程说明
        • 2》结构体与结构体变量(实例/对象)的关系的示意图
        • 3》入门案例(using struct to solve the problem of cat growing)
      • 3.结构体的具体应用
      • 4.创建结构体变量和访问结构体字段
      • 5.struct类型的内存分配机制
      • 6.结构体的注意事项和使用细节
        • 1）结构体的所有字段在内存中是连续的
      • 7.方法
        • 1)基本介绍：
        • 2）方法的声明和调用
        • 3）对上面的代码总结和说明
        • 4）方法的快速入门
        • 6）方法的调用和传参机制原理(vital)
        • 7）方法的声明(定义)
        • 8）方法注意事项和细节讨论
        • 9）有关方法的课外习题
        • 10）方法和函数的区别
      • 8.面向对象编程的应用实例
    • 面向对象编程（下）
      • 1.创建结构体变量时指定字段值
      • 2.工厂模式
      • 3.vscode快捷键
      • 4.面向对象编程的三大特性
        • 1）基本介绍
        • 2）面向对象编程思想--抽象
        • 3）面向对象编程思想-封装
          • &1介绍
          • &封装的理解和好处
          • &如何实现封装
          • &案例入门
          • &练习：
        • 4）面向对象编程思想-继承
          • &1.为什么需要继承
          • &2继承的基本介绍和示意图
          • &3.嵌套匿名结构体的基本语法
          • &4.课堂练习
          • &5.多重继承
          • &6.多重继承细节说明
          • &4.课堂练习
          • &5.多重继承
          • &6.多重继承细节说明

面向对象编程(上)

1.问题与解决思路

问题：

张老太养了两只猫，一个名字叫小白，今年3岁，白色。还有一只叫小花，今年100岁，花色。请编写一个程序。当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示张老太没有这只小猫

使用现有的技术来解决这个问题

1）单独的定义变量解决

代码演示

//1.使用变量的处理方式
	var cat1Name string = "小白"
	var cat1Age int = 3
	var cat1Color string = "白色"
    
	var cat2Name string = "小化"
	var cat2Age int = 100
	var cat2Color string = "花色"

2）使用数组解决

代码演示

//2.使用数组来解决
	var catNames [2]string = [...]string{"小白","小花"}
    var catAges [2]int = [...]int{3,100}
	var catColor [2]string = [...]string{"白色","花色"}
	//

现有的技术解决的缺点分析

  • 使用变量或者数组来解决养猫的问题，不利于数据的管理和维护。因为名字，年龄，颜色都是属于一只猫，但是这里分开保存
  • 如果我们希望对一只猫的属性（名字、年龄、颜色）绑定方法也不好处理
  • 引出讲解的知识点结构体

2.结构体

一个程序就是一个世界，有很多对象（变量）

1》Golang语言面向对象编程说明

1）Golang也支持面向对象编程(OOP),但是和传统的面向对象编程有区别，并不是纯粹的面向对象语言。所以我们说Golang支持面向对象编程的特性是比较准确的

2）Golang没有类（class），go语言的结构体(struct)和其他编程语言的类(class)有同等的地位，你可以理解Golang是基于struct来实现OOP特性的

3）Golang面向对象编程非常简洁，去掉了传统OOP语言的继承，方法重载、构造函数和析构函数、隐藏的this指针等等

4）Golang仍然有面向对象编程的继承，封装和多态的特性，只是实现的方式和其他的OOP语言不一样，比如继承：Golang没有extends关键字，继承是通过匿名字段来实现

5）Golang面向对象(OOP)很优雅，OOP本身就是语言类型系统(type system)的一部分，通过接口(interface)关联，耦合性低，也非常灵活。后面学习就可以体会到了，也就是说在Golang中面向接口编程是非常重要的特性

2》结构体与结构体变量(实例/对象)的关系的示意图

go的面向对象学习_第1张图片

简单来说就是类似与java的类和对象

对上图的说明

1）将一类事物的特性提取出来（比如猫类），形成一个新的数据类型，就是结构体

2）通过这个结构体，我们可以创建多个变量（实例对象）

3）事物可以是猫类，也可以是Person,Fish或是某个工具类

特征对象抽取图：

go的面向对象学习_第2张图片

3》入门案例(using struct to solve the problem of cat growing)
package main
import (
	"fmt"
)
/*
张老太养了两只猫，一个名字叫小白，今年3岁，白色。
还有一只叫小花，今年100岁，花色。请编写一个程序。
当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。
如果用户输入的小猫名错误，则显示张老太没有这只小猫

*/

// func vars(){
// 	//1.使用变量的处理方式
// 	var cat1Name string = "小白"
// 	var cat1Age int = 3
// 	var cat1Color string = "白色"
    
// 	var cat2Name string = "小化"
// 	var cat2Age int = 100
// 	var cat2Color string = "花色"
// 	//2.使用数组来解决
// 	var catNames [2]string = [...]string{"小白","小花"}
//     var catAges [2]int = [...]int{3,100}
// 	var catColor [2]string = [...]string{"白色","花色"}
// 	//
// }

//定义一个cat结构体,将cat的各个字段/属性放入cat结构体进行管理
type Cat struct {
	Name string
	Age int
	Color string
	Hobby string
}



func main() {
//创建一个cat结构体变量
var cat1  Cat  //类似于var a int
cat1.Name = "小白"
cat1.Age = 3
cat1.Color = "白色"
cat1.Hobby = "吃<.))>>>"
fmt.Println("cat1=",cat1)

fmt.Println("猫猫的信息如下：")
fmt.Println("name=",cat1.Name,"Age=",cat1.Age,"Color=",cat1.Color)
fmt.Println("cat1.Hobby",cat1.Hobby)
//输出结果如下：
/*cat1= {小白 3 白色}
猫猫的信息如下：
name= 小白 Age= 3 Color= 白色
*/
}

4》结构体和结构体变量(实例)的区别和联系

通过上面的案例和讲解我们可以看出

1）结构体是自定义的数据类型。代表一类事物

2）结构体变量(实例)是具体的，实际的，代表一个具体变量

5》结构体变量（实例）在内存中存在的布局

var cat1 Cat
cat1.Age = 3
cat1.Color = "白色"

画出示意图

go的面向对象学习_第3张图片

3.结构体的具体应用

1)结构体的声明

type 结构体名称 struct {
   filed1 type
   filed2 type
}

//举例
//如果结构体的名称首字母为大大写，那就意味着该结构体可以被其他包使用
type Student struct {
    Name string
    Age int
    Socre float32
}

2）字段/属性

基本介绍：

（1）从概念或叫法上看，结构体字段=属性=filed（集授课中，统一叫字段）

（2）字段是结构体的一一个组成部分，一般是基本数据类型、数组。比如我们前面定义猫结构体的Name string就是属性

3）字段和属性的细节说明

1、字段声明语法同变量，示例：字段名 字段类型

2、字段的类型可以为：基本类型、数组或引用类型

3、在创建一个结构体变量后，如果没有给字段赋值，都对应一个零值（默认值），规则同前面讲的一样

布尔类型 false,整型是0 ，字符是 " "

数组类型的默认值和它的元素类型相关,比如score [3]int的默认值是[0 0 0]

指针，slice和map的零值都是nil即没有分配空间（需要用make进行分配空间的操作）

package main
import (
	"fmt"
)
//指针，slice和map的零值都是nil即没有分配空间
//如果结构体的字段类型是这些，需要先make后才可以使用
type Person struct {
	Name string
	Age int
	scores [5]float64
	ptr *int //指针
    slice []int//切片
	map1 map[string]string//切片
}

func main() {

	//定义结构体变量
	var p1 Person
	fmt.Println(p1) //未赋值之前输出的是{ 0 [0 0 0 0 0]  [] map[]}
    
	if p1.ptr == nil {
		fmt.Println("ok1")
	}

	if p1.slice == nil {
		fmt.Println("ok2")
	}

	if p1.map1 == nil {
		fmt.Println("ok3")
	}

	//使用slice,之前一定要make
	p1.slice = make([]int,10)
	p1.slice[0] = 100 

	//使用map也一定先要make操作
    p1.map1 = make(map[string]string)
	p1.map1["key1"] = "tom"
	fmt.Println(p1)
}

4）不同结构体变量的字段是独立的，互不影响，一个结构体变量字段的更改，不影响另一个。结构体是值类型

//不同结构体变量的字段是独立的，互不影响，
	// 一个结构体变量字段的更改，不影响另一个。结构体是值类型
    var monster1 Monster
	monster1.Name = "牛魔王"
	monster1.Age = 500

	monster2 := monster1//默认结构体是值类型，值拷贝
	monster2.Name = "青牛精"
	fmt.Println("monster1=",monster1)//monster1= {牛魔王 500}
	fmt.Println("monster2=",monster2)//monster2= {青牛精 500}
	

}

示意图

go的面向对象学习_第4张图片

4.创建结构体变量和访问结构体字段

1）方式1-直接声明

案例演示：var person Person

2)方式2-{}

案例演示：var person Person = Person{}

//方式2
	p2 := Person{"mary",20}
	// p2.Name = "Tom"
	// p2.Age = 18
	fmt.Println(p2)

3）方式3

案例：var person *Person = new (Person)

//方式3-8
	//案例：var person *Person = new (Person)

	var p3 *Person= new(Person)
	//因为p3是一个指针，因此标准的给字段赋值方式
	//(*p3).Name = "smith"也可以这样写 p3.Name = "smith"
	//原因是go的设计者为了程序员使用方便，在底层会对p3.Name = "smith"进行优化
	//底层会给p3加上取值运算 (*p3).Name = "smith"
	(*p3).Name = "smith"
	p3.Name = "jhon"
	(*p3).Age = 30
	fmt.Println(*p3)//{jhon 30}

4）方式4-{}

案例：var person *Person = &Person{}
//var person *Person = &Person{"jerry",60}写成这种形式也是对的

//方式4-{}案例：var person *Person = &Person{}
	var person *Person = &Person{}
	//因为person是一个指针，因此标准的访问其字段的方法是
    //(*peron).Name = "scott"
	//go的设计者为了方便,也可以person.Name = "scott"
	//底层会进行优化操作
	(*person).Name = "scott"
	(*person).Age= 30
	fmt.Println(*person)

说明

  1. 第三种和第四种方式返回的是结构体指针
  2. 结构体指针访问字段的标准方式应该是：(*结构体指针).字段名，比如(*Person).Name = “tom”
  3. 但go做了一个简化，也支持 结构体指针.字段名,比如1perosn.Name = “tom”.更加符合程序员使用的习惯，go编译器底层对person.Name做了转化(*Person).Name

5.struct类型的内存分配机制

看看结构体在内存中的存在形式

var p4 Person
	p4.Name= "小明"
	p4.Age = 23
	var p5 *Person = &p4
    //fmt.Println(*p5.Age)这种用法是错误的
    //需要将*号包起来，因为.的优先级比*的优先级更高
	fmt.Println((*p5).Age)//10
	fmt.Println(p5.Age) //10

	p5.Name = "tom~"
	fmt.Printf("p5.Name=%v p4.Name=%v \n",p5.Name,p4.Name)
	fmt.Printf("p5.Name=%v p4.Name=%v \n",(*p5).Name,p4.Name)
	/*
	输出结果如下所示
	p5.Name=tom~ p4.Name=tom~
    p5.Name=tom~ p4.Name=tom~

	*/
fmt.Printf("p4的地址是%p\n",&p4)
	//p4的地址是0xc042056420
	
	fmt.Printf("p5的地址是%p p5的值是%p\n",&p5,p5)
	//p5的地址是0xc04207a020 p5的值是0xc042056420

其内存图分析如下

go的面向对象学习_第5张图片

6.结构体的注意事项和使用细节

1）结构体的所有字段在内存中是连续的
package main
import (
	"fmt"
)

//结构体
type Point struct {
	 x int
	 y int
}
//结构体
type Rect struct {
	leftup,rightDown Point
}

func main (){
    
	r1 := Rect{Point{1,2},Point{3,4}}

	//r1有4个int,在内存中连续分布
	//打印地址
	fmt.Printf("r1.leftup.x 地址=%p r1.leftup.y 地址=%p r1.rightDown.x 地址=%p r1.rightDown.y 地址=%p\n",
    &r1.leftup.x,&r1.leftup.y,&r1.rightDown.x,&r1.rightDown.y)
	//输出结果如下
	//r1.leftup.x 地址=0xc04200a2c0 r1.leftup.y 地址=0xc04200a2c8 
	// r1.rightDown.x 地址=0xc04200a2d0 r1.rightDown.y 地址=0xc04200a2d8

    //r2有两个*Point类型，这两个*Point类型的本身地址也是连续的
	//但是他们指向的地址不一定是连续的
    
	r2 := Rect2{&Point{10,20}, &Point{30,40}}
	fmt.Printf("r2.leftup本身地址=%p  r2.rightDown 本身地址=%p \n",
    &r2.leftup,&r2.rightDown)
	//输出结果为:r2.leftup本身地址=0xc0420421c0  r2.rightDown 本身地址=0xc0420421c8
    
	//他们指向的地址不一定是连续的 这个要看编译器或系统运行时而定
	fmt.Printf("r2.leftup指向地址=%p  r2.rightDown 指向地址=%p \n",
    r2.leftup,r2.rightDown)
	//r2.leftup指向地址=0xc0420120b0  r2.rightDown 指向地址=0xc0420120c0


}

内存图

go的面向对象学习_第6张图片

go的面向对象学习_第7张图片

2）结构体是用户单独定义的类型，和其他类型进行转换时需要有完全相同的字段（名字，个数和类型要完全一致）

type A struct{
    Num int
}
type B struct{
   Num int
}
func main(){
   var a A
   var b B
  fmt.Println(a,b)
   //a=b两个不同类型的结构体不能相互赋值操作
   //进行强制转换
   a = A(b) //成功，前提是两个结构体的字段名称
   //，字段类型是一模一样的，其中一个不一样都不可以
   fmt.Println(a,b)
}

3）结构体进行type重新定义（相当于取别名），Golang认为是新的数据类型，但是相互可以强转

type Student struct{
	Name string
	Age int
}
type Stu Student

func main(){
 
   var stu1 Student
   var stu2 Stu
 //stu2 = stu1 //正确吗？会报错，可以这样修改 stu2=Stu(stu1)
   stu2=Stu(stu1)
   fmt.Println(stu1,stu2)
}

type integer int
func main(){
var i integer = 10
var j int = 20
//j = i //正确吗？ 也不可以的如果要就必须强制进行转换
j = int(i)
fmt.Println(i,j)
}

4）struct的每个字段上，可以写一个tag,该tag可以通过反射机制获取，常见的使用场景就是序列号和反序列化

举例：

package main
import (
	"fmt"
	"encoding/json"
)
type Monster struct {
	Name string `json:"name"`
	Age int `json:"age"`
	Skill string `json:"skill"`
}
func main(){
//1.创建一个Monster变量
   monster :=Monster{"牛魔王",500,"芭蕉扇"}

   //2.将monster变量序列化为json格式的字符串
    //json.Marshal函数中使用反射
   jsonStr, err:= json.Marshal(monster)
   if err !=nil{
	fmt.Println("json处理错误",err)
   }
   fmt.Println("jsonStr",string(jsonStr))
   //输出如下：jsonStr {"Name":"牛魔王","Age":500,"Skill":"芭蕉扇"}
   //在字段后面加上json序列化后：
   //jsonStr {"name":"牛魔王","age":500,"skill":"芭蕉扇"}
}

序列化的应用场景：

go的面向对象学习_第8张图片

7.方法

1)基本介绍：

在某些情况下，我们需要声明(定义)方法，比如Person结构体，除了有一些字段外(年龄，姓名…)Person结构体还有一些行为比如：可以说话、跑步。。通过学习，还可以做算术题，这时要使用方法才可以完成

Golang中的方法是作用在指定的数据类型上的（即。和指定的数据类型绑定）因此自定义类型都可以有方法，而不仅仅是struct

2）方法的声明和调用
type A struct{
    Num int
}
func (a A)test(){
    fmt.Println(a.Num)
}

对上面的语法的说明

  • func (a A) test(){} 表示A结构体有一方法，方法名为test
  • (a A ) 体现test方法是和A类型绑定的

举例说明：

package main
import (
	"fmt"
)

type Person struct{
	Name string
}

//给A类型绑定一个方法
func (p Person) test() {
    p.Name = "jack"
	fmt.Println("test()",p.Name) //jack
}

func main(){
	//定义一个Person实例
	var p Person
	p.Name = "小红"
	p.test() //调用方法
    fmt.Println("main()",p.Name) //小红，这里不会因为test()方法中的操作而改变，因为struct不是引用传递而是值传递还是小红
}
3）对上面的代码总结和说明

  1. test方法和Person类型绑定

  2. test方法只能通过Person类型的变量来调用，而不能直接调用，也不能使用其他类型变量来调用

    下面的使用方式都是错误的
var dog Dog
dog.test()
test()

  3. func (p Person) test() {}…p表示哪个Person变量调用，这个p就是它的副本，这点和函数传参非常相似

  4. p这个·名字，是可以有程序员指定，不是固定的，比如修改成person也是可以的

4）方法的快速入门

（1）给Person结构体添加speak方法，输出xxx是一个好人

func (p Person) speak(){
	fmt.Printf("%v是一个好人\n",p.Name)
}

（2）给Person结构体添加jisuan方法，可以计算从1+…+1000的结果

func (p Person) jisuan() {
	var sum int = 0
	for i :=1;i <=1000;i++{
		sum += i
	}
	fmt.Printf("1+..+1000的结果是%v\n",sum)
}

（3）给Person结构体添加jisuan2方法,该方法可以接收一个数n，计算从1+…n的结果

func (p Person) jisuan2(n int) {
    var sum int = 0
	for i :=1;i <=n;i++{
		sum += i
	}
	fmt.Printf("1+..+%v的结果是%v\n",n,sum)
}

（4）给Person结构体添加getSum方法,可以计算两个数的和并返回结果。

func (p Person) getsum(n1 int,n2 int) int{
     return n1 + n2
}

（5）方法的调用

    p.speak()
	p.jisuan()
	p.jisuan2(10000)
	res := p.getsum(10,20)
	fmt.Println("res=",res)
6）方法的调用和传参机制原理(vital)

说明：方法的调用和传参机制和函数基本不一样，不一样的地方是方法调用时，会将调用方法的变量，当做实参也传递给方法。

案例1：画出前面getSum()方法的执行过程+说明

go的面向对象学习_第9张图片

说明：

  1. 在通过一个变量去调用方法时，其调用机制和函数一样
  2. 不一样的地方是，变量调用方法时，该变量本身也会作为一个参数传递到方法(如果变量是值类型，则进行值拷贝，如果变量是引用类型则进行地址拷贝)

案例2：请编写一个程序，要求如下

  1. 声明一个结构体Circle，字段为radius
  2. 声明一个方法area和CIrcle绑定，可以返回面积
  3. 提示画出area执行过程+说明
package main
import (
	"fmt"
)
/*
案例2：请编写一个程序，要求如下

1. 声明一个结构体Circle，字段为radius
2. 声明一个方法area和CIrcle绑定，可以返回面积
3. 提示画出area执行过程+说明
*/
type Circle struct {
	radius float64
}

func (c Circle) area() float64 {
    return 3.14 * c.radius * c.radius
}

func main(){
	//创建一个结构体
	var c Circle
	c.radius = 4.0
	area := c.area()
    fmt.Printf("圆的面积为%v\n",area)
}

执行内存图：

go的面向对象学习_第10张图片

其实这样的效率非常慢，会一对一进行值拷贝，用指针可以直接修改它就更快

7）方法的声明(定义)
func (recevier type) methodName (参数列表) (返回值列表){
         方法体
         return 返回值
}
  1. 参数列表，表示方法输入
  2. recevier type：表示这个方法和type这个类型进行绑定，或者说该方法作用于type类型
  3. recevier type：type可以是结构体，也可以是其他自定义类型
  4. recevier:就是type类型的一个变量（实例）比如：Person结构体的一个变量（实例）
  5. 参数列表：表示方法输入
  6. 返回值列表：表示返回的值，可以多个
  7. 方法主体。表示为了实现某一个功能代码块
  8. return语句不是必须的。
8）方法注意事项和细节讨论

  1. 结构体类型是值类型，在方法调用中，遵守值类型的传递机制，是值拷贝传递方式

    //为了提高效率，通常我们方法和结构体的指针类型进行绑定
func (c *Circle) area2() float64 {
	//因为c是一个指针，因此我们标准访问其字段的方式是(*c)
    return 3.14 * (*c).radius * (*c).radius
	//(*c).radius等价为c.radius
}

func main(){
	//创建一个cicle变量
	var c Circle
	c.radius = 5.0
	//res2 := (&c).area2()
	//编译底层做了优化,(&c).area2()等价c.area2()
	//因为编译器会自动加上
    res2 := c.area2()
	fmt.Printf("圆的面积为%v\n",res2) //面积为78.5
	
}

  2. 如果程序员希望在方法中，修改结构体变量的值，可以通过结构体指针的方式来处理

    func (c *Circle) area2() float64 {
	c.radius = 10
	//因为c是一个指针，因此我们标准访问其字段的方式是(*c)
    return 3.14 * (*c).radius * (*c).radius
	//(*c).radius等价为c.radius
}

func main(){
	
	//创建一个cicle变量
	var c Circle
	c.radius = 6.0
	//res2 := (&c).area2()
	//编译底层做了优化,(&c).area2()等价c.area2()
	//因为编译器会自动加上
     res2 := c.area2()
	fmt.Printf("圆的面积为%v\n",res2) //314
	fmt.Println("c.radius = ",c.radius) //10
	
}

    //为了提高效率，通常我们方法和结构体的指针类型进行绑定
func (c *Circle) area2() float64 {
	fmt.Printf("c是*cicle指向的地址=%p\n",c)
	c.radius = 10
	//因为c是一个指针，因此我们标准访问其字段的方式是(*c)
    return 3.14 * (*c).radius * (*c).radius
	//(*c).radius等价为c.radius
}

func main(){
	//创建一个结构体
	// var c Circle
	// c.radius = 4.0
	// area := c.area()
    // fmt.Printf("圆的面积为%v\n",area)
	//创建一个cicle变量
	var c Circle
	fmt.Printf("main的c结构体变量地址 =%p\n",&c)
	c.radius = 6.0
	//res2 := (&c).area2()
	//编译底层做了优化,(&c).area2()等价c.area2()
	//因为编译器会自动加上
	res2 := c.area2()
	fmt.Printf("圆的面积为%v\n",res2) //314
	fmt.Println("c.radius = ",c.radius) //10
	
	/*
    运行结果如下
	main的c结构体变量地址 =0xc0420120a0
    c是*cicle指向的地址=0xc0420120a0
    圆的面积为314
    c.radius =  10

	*/
}

    go的面向对象学习_第11张图片

  3. Golang中的方法作用在指定的数据类型上的（即：和指定的数据类型绑定）因此自定义类型，都可以有方法。而不仅仅是struct,比如int,float32等都可以有方法

    package main
import (
	"fmt"
)
/*
Golang中的方法作用在**指定的数据类型**上的
（即：**和指定的数据类型绑定**）因此自定义类型，
都可以有方法。而不仅仅是struct,比如int,float32等都可以有方法
*/
type integer int
func (i integer) print() {
	fmt.Println("i=",i)
}
//编写一个方法修改i的值
func (i *integer) ch() {
	*i = *i +1
}
func main(){
    var i integer = 10
	i.print() //1 = 10
	i.ch()
	i.print() //i =11
}

  4. 方法的访问范围控制的规则，和函数一样，方法名首字母小写，只能在本包访问，方法首字母大写，可以在本包和其他包访问

  5. 如果一个类型实现了String()这个方法，那么fmt.Println默认会调用这个变量的String（）进行输出

    //定义一个Student结构体
type Student struct {
	Name string
	Age int
}
//给Student实现方法String()
func (stu *Student) String() string {
   str := fmt.Sprintf("Name=[%v] Age=[%v]",stu.Name,stu.Age)
   return str
}
func main(){
	//定义一个Student变量
	stu := Student{
		Name : "tom",
		Age : 20,
	}
	//如果实现了*Student类型的String()方法会自动调用String()要传入&stu
	fmt.Println(&stu) 
}
9）有关方法的课外习题

  1. 编写结构体(MethodUtils),编程一个方法，方法不需要参数，在方法中打印一个10 *8 的矩形，在main方法中调用该方法

    package main
import (
	"fmt"
)

type MethodUtils struct{
    //字段...
}
//给MethodUtils编写方法
func (m MethodUtils) print(){
	for i :=1; i<=10;i++{
		for j :=1;j<=8;j++{
			fmt.Print("* ")
		}
		fmt.Println()
	}
}
func main(){
	/*
   编写结构体(MethodUtils),编程一个方法，
   方法不需要参数，在方法中打印一个10 *8 的矩形，
   在main方法中调用该方法
	*/
	var m MethodUtils
	m.print()
}

  2. 编写一个方法，提供m和n两个参数，方法中打印m*n的矩形

    //编写一个方法，提供m和n两个参数，方法中打印m*n的矩形
func (mu MethodUtils) print2(m int, n int){
	for i :=1; i<=m;i++{
		for j :=1;j<=n;j++{
			fmt.Print("* ")
		}
		fmt.Println()
	}
} 
func main(){
	/*
   编写结构体(MethodUtils),编程一个方法，
   方法不需要参数，在方法中打印一个10 *8 的矩形，
   在main方法中调用该方法
	*/
	var m MethodUtils
	// m.print()
    m.print2(3,4)
}

  3. 编写一个方法算该矩形的面积(可以接收长len和宽width),将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印

    func  (mu MethodUtils) area(length float32,width float32)float32{
      return length * width
}
func main(){
	res :=m.area(4.0,5.6)
	fmt.Println("该矩形的面积为：",res)
}

  4. 编写方法，判断一个数是奇数还是偶数

    func (mu *MethodUtils) qi(m int) {
	if m %2==0{
		fmt.Printf("%v是偶数",m)
	}else{
        fmt.Printf("%v是奇数",m)
	}
}

  5. 根据行、列、字符打印对应行数和列数的字符，比如：行：3，列：2，字符 * ，则打印相应的效果

    func (mu *MethodUtils) printe(n int, m int,key string) {
	for i :=1;i<= n;i++{
		for j :=1;j<=m;j++{
			fmt.Print(key)
		}
		fmt.Println()
	}
}

  6. 定义小小计算器结构体(Calcuator),实现加减乘除四个功能

    实现形式1：分4个方法完成

    //实现形式1：
type Calcuator struct{
	Num1 float64
	Num2 float64
}
//求和
func (calcuator *Calcuator) getSum() float64{
   
	return calcuator.Num1 +calcuator.Num2
}
//求差
func (calcuator *Calcuator) getJian() float64{
   
	return calcuator.Num1 -calcuator.Num2
}
//求积
func (calcuator *Calcuator) getJi() float64{
   
	return calcuator.Num1 *calcuator.Num2
}
//求商
func (calcuator *Calcuator) getShang() float64{
   
	return calcuator.Num1 /calcuator.Num2
}
func main(){
	 n := Calcuator{24.0,8.0}
	he :=n.getSum()
	cha :=n.getJian()
	ji :=n.getJi()
	shangha :=n.getShang()
	fmt.Printf("和为%v 差为%v 积为%v 商为%v",he,cha,ji,shangha)
}

    实现形式2：用一个方法搞定

    //实现形式2
func (calcuator *Calcuator) getRes(operator byte) float64 {
   res :=0.0
   switch operator {
   case '+':
	   res = calcuator.Num1 +  calcuator.Num2
   case '-':
	   res = calcuator.Num1 -  calcuator.Num2
   case '*':
	   res = calcuator.Num1 *  calcuator.Num2
   case '/':
	   res = calcuator.Num1 / calcuator.Num2
   default:
	   fmt.Println("运算符输入有误")
	}
	return res
}
func main(){
s := Calcuator{32.0,8.0}
	res :=s.getRes('*')
	fmt.Println("运算的结果为：",res)
}
    10）方法和函数的区别

    1. 调用方式不一样

      函数的调用方式 ： 函数名（实参列表）

      方法的调用方式：变量.方法名（实参列表）

    2. 对于普通函数，接收者为值类型的时候，不能将指针类型的数据直接传递，反之亦然

      type Person struct{
	Name string
}

//函数
func test01(p Person){
    fmt.Println(p.Name)
}

func test02(p *Person){
    fmt.Println(p.Name)
}
func main(){
 p := Person{"tom"}
  test01(p)
//  test01(&p)//不可以传地址
test02(&p)

}

    3. 对于方法如(struct的方法)，接受者为值类型的时候，可以直接用指针类型的变量调用方法，反过来同样也可以

      //方法
func (p Person) test03(){
  fmt.Print("test03=",p.Name)
}

func main(){
 p := Person{"tom"}
  
p.test03() //可以
(&p).test03()//指针传入地址也可以，从形式上是传入了地址但是本质上仍然是值拷贝
}

      总结：

      1. 不管调用形式如何，真正决定是值拷贝还是地址拷贝，看这个方法是和哪个类型绑定
      2. 如果是和值类型，比如(p Person),则是值拷贝，如果是指针类型，是(p *Person)则是地址拷贝

8.面向对象编程的应用实例

1）步骤

  1. 声明(定义)结构体，确定结构体名
  2. 编写结构体的字段
  3. 编写结构体的方法

2）案例

  1. 编写一个Student结构体，包含name、gender、age、id、score字段，分别是string、string、int、int、float54类型

  2. 结构体中声明一个say()方法，返回string类型，方法返回信息包含所有字段值

  3. 在main1方法中，创建一个stsudent结构体实例(变量),并访问say方法，并将调用结构打印输出

    package main
import (
	"fmt"
)
type Student struct{
   name string
   gender string
   age int
   id int
   score float64

}
func (stu *Student) say() string{
	//使用fmt.Sprintf()函数将值转换为字符串
    inforstr :=fmt.Sprintf("student的信息如下 name = [%v] gender=[%v] age = [%v] id=[%v] score=[%v]",stu.name,stu.gender,stu.age,stu.id,stu.score)
	 return inforstr
}
func main(){
var stu = Student{"小红","男",34,1001,99.5}
info :=stu.say()
fmt.Println(info)
}

3)案例2：盒子案例

  1. 编程创建一个Box结构体，在其中声明三个字段表示一个立方体的长、宽、高，长宽高要从终端获取

  2. 声明一个方法获取立方体的体积

  3. 创建一个Box结构体变量，打印给定尺寸的立方体的体积

    type Box struct{
	length float64
    width float64
	high  float64
}
func (b Box) getVolumn() float64{
    return b.length * b.width * b.high
}

func main(){
//测试box
var box Box
box.length = 1.1
box.width = 2.0
box.high = 3.0
Volum := box.getVolumn()
fmt.Printf("这个黑子的体积是%.2f",Volum)
}

3)案例3：景区门票案例

  1. 一个景区根据游人的年龄收取不同价格的民票，比如年龄大于18，收费20元，其他情况门票免费

  2. 请编写Visitor结构体，根据年龄段决定能够购买的门票价格并输出

    type Vistor struct{
	Name string
	Age int
}
func (vistor Vistor) showPrice(){
	if vistor.Age >18{
		fmt.Println("门票价格为20元")
	}else{
		fmt.Println("免费")
	}

}
func main(){
    var vio Vistor

for {
	fmt.Println("请输入你的名字")
	fmt.Scanln(&vio.Name)
	if vio.Name == "n" {
		fmt.Println("退出程序")
	    break
	}
	fmt.Println("请输入你的年龄")
	fmt.Scanln(&vio.Age)
	vio.showPrice()
}
}

面向对象编程（下）

1.创建结构体变量时指定字段值

1）说明：Golang在创建结构体实例（变量）时，可以直接指定字段值

2）创建结构体变量时指定字段值方式

  1. way1

    //在创建结构体变量时，就直接指定字段的值
	var stu1 = Stu{"tom",23}
	stu2 :=Stu{"晓明",20}

//创建结构体变量时。把字段名和字段值写在一起
	var stu3 = Stu{ //这种写法更加稳健不依赖于字段的顺序
		Name : "jack",
		Age : 20,
	}
	//可以类型颠倒
	var stu3 = Stu{ //这种写法更加稳健不依赖于字段的顺序
		Age : 20,
		Name : "jack",
	}

  2. way2

    //方式2.返回结构体的指针类型(!!!)
var stu5 *(Stu)= &Stu{"小王",29} //stu2--->地址 ---》结构体数据[xxxx,xxxx]
	stu6 :=&Stu{"小王",39}

	//在创建结构体指针变量是，把字段名和字段值写在一起，这种写法，就不依赖于字段的定义顺序
	var stu7 = &Stu{
		Name : "小李",
		Age : 49,
	}

	var stu8 = &Stu{
		Age :59,
		Name : "小李~",

	}
	fmt.Println(*stu5,*stu6,*stu7,*stu8)//
}

2.工厂模式

1）说明

Golang的额结构体没有构造函数，通常可以使用工厂模式来解决这个问题

看一个需求

一个结构体的声明是这样的

package model
type Student struct{
Name string ....
}

因为这里的Student的首字母S是大写的，如果我们想在其它包创建Student的实例(比如main包)，引入model包后，就可以直接创建Student结构体的变量(实例)

但是问题来了，如果首字母是小写的，比如是type student struct {,}就不行了，怎么办—》工厂模式来解决

2）工厂模式来解决问题

使用工程模式实现挎包创建结构体实例(变量)的案例

1》如果model包的结构体变量首字母大写，引入后，直接使用没有任何问题

package model
//定义一个结构体
type Student struct{
	Name string
	Score float64
}
package main
import (
	"fmt"
	"go_code/object2/factory/model"
)

func main(){
	//创建一个Student的实例
	var stu = model.Student{
		Name : "Tom",
		Score : 78.9,
	}
	fmt.Println(stu)
}

2》如果model包的结构体变量首字母小写，引入后，不能直接使用，可以使用工厂模式解决

package model
//定义一个结构体
type student struct{
	Name string
	Score float64
}
//因为student结构体首字母是小写，因此是只能在
//model包使用，通过工厂模式解决
func NewStudent(n string,s float64) *student{
	return &student{
		Name : n,
		Score : s,
	}
}

在main包下的main,go中使用
package main
import (
	"fmt"
	"go_code/object2/factory/model"
)

func main(){
	//当student结构体首字母是小写的我们可以通过工厂模式解决
	var stu = model.NewStudent("tom~",88.8)
	fmt.Println(*stu)
}

问题：

思考一下，如果model包的Student的结构体字段Score改为score,我们还可以正常访问吗？当然不可以正常访问，我们要使用一个方法去访问

package model
//定义一个结构体
type student struct{
	Name string
	score float64
}

//因为student结构体首字母是小写，因此是只能在
//model包使用，通过工厂模式解决
//返回这个结构体变量的指针
func NewStudent(n string,s float64) *student{
	return &student{
		Name : n,
		score : s,
	}
}

//如果score字段首字母小写，则在其他包不可以访问，我们可以提供方法
//就是用结构体指针来访问结构体字段
func (s *student) GetScore() float64{
    return s.score //（底层会优化为//return (*s).score）
}


package main
import (
	"fmt"
	"go_code/object2/factory/model"
)

func main(){
	
	//当student结构体首字母是小写的我们可以通过工厂模式解决
	var stu = model.NewStudent("tom~",88.8)
	fmt.Println(*stu)
    //注意了，这里我们使用getScore方法去访问stu,score
	fmt.Printf("name=%v Score=%v",stu.Name,stu.GetScore())
    //fmt.Printf("name=%v score的值为=%v",stu.Name,(*stu).GetScore())
}

3.vscode快捷键

1）删除当前行 ctrl +shift +k [也可自定义]

2）向上/向下复制当前行Shfit + Alt + 下箭头/上箭头

3）补全代码 alt +/

4）添加注释和取消注释 ctrl + /

5）快速修复 alt + /

6）快速格式化代码 shift + alt +f

特别说明：

1）VSCODE的快捷键不要和输入法冲突，否则不会生效

2）一些快捷键需要安装Go插件后才能生效

4.面向对象编程的三大特性

1）基本介绍

Golang仍然有面向对象编程的继承，封装和多态的特性，只是实现的方式和其他的OOP语言不一样，下面就一一来讲解吧

2）面向对象编程思想–抽象

如何理解抽象？

我们在定义一个结构体的时候，实际上就是把一类事物的共有的属性和行为提取出来，形成一个物理模型（结构体），这种研究问题的方法称为抽象。

go的面向对象学习_第12张图片

代码实现：

package main
import (
	"fmt"
)
//定义一个结构体
type Account struct{
	AccountNo string
	Pwd string
	Balance float64
}

//方法
//1.存款
func (account *Account) Deposite(money float64,pwd string){
	//看看输入的密码是否正确
	if pwd !=account.Pwd{
		fmt.Println("你输入的密码不正确")
		return
	}

	//看看存款金额是否正确
	if money <= 0 {
		fmt.Println("你输入的金额不正确")
		return
	}

	account.Balance += money
	fmt.Println("存款成功")
}
//取款
func (account *Account) WithDraw(money float64,pwd string){
	//看看输入的密码是否正确
	if pwd !=account.Pwd{
		fmt.Println("你输入的密码不正确")
		return
	}

	//看看存款金额是否正确
	if money <= 0 || money >account.Balance{
		fmt.Println("你输入的金额不正确")
		return
	}

	account.Balance -= money
	fmt.Println("取款成功")
}

//查询余额

func (account *Account)Query(pwd string){
	//看看输入的密码是否正确
	if pwd !=account.Pwd{
		fmt.Println("你输入的密码不正确")
		return
	}
	fmt.Printf("你的账号为=%v 余额=%v \n",account.AccountNo,account.Balance)
}


func main(){
	//测试一下
	account := Account{
		AccountNo : "gs111111",
		Pwd : "666666",
		Balance  : 1000.0,
	}
	for{
		//这里可以做的更加灵活，就是让用户通过控制台来输入命令
		//菜单
	account.Query("666666")
	account.Deposite(200,"666666")
	account.Query("666666")
	account.WithDraw(150.0,"666666")
	account.Query("666666")
	}

}
3）面向对象编程思想-封装
&1介绍

封装就是把抽象出来的字段和对字段的操作封装在一起，数据被保护在内部，程序的其他包只有通过被授权的操作（方法），才能对字段进行操作

&封装的理解和好处

  1. 隐藏实现细节

  2. 可以对数据进行验证，保证安全合理

    type Person struct{
Age int
}
&如何实现封装
  1. 对结构体中的属性进行封装(字段名小写)
  2. 通过方法，包 实现封装

4）封装的实现步骤

  1. 将结构体、字段（属性）的首字母小写（不能导出了，其他包不能使用，类似private）

  2. 给结构体所在包提供了一个工厂模式的函数，首字母大写。类似一个构造函数

  3. 提供一个首字母大写的Set方法（类似其他语言的public）,用于对属性判断并赋值

    func (var 结构体类型名)SetXxx(参数列表)(返回值列表){
    //加入数据验证的业务逻辑
    var.字段 = 参数
}

  4. 提供一个首字母大写的Get方法（类似其他语言的public）,用于获取属性的值

    func (var 结构体类型名)GetXxx(){
return var.字段
}

    特别说明：在Golang开发中并没有特别强调封装，这点并不像java，所以学过java的朋友不能总是用java语法特征来看待Glang,Golang本身对向对象的特性做了简化。

&案例入门

有一个程序，不能随便查看人的年龄，工资等隐私，并对输入的年龄进行合理的验证.设计：model包(person go) main包(main.go调用Person结构体)

person.go
package model
import (
	"fmt"
)
type person struct{
	Name string
	age int //字母小写，其他包不能访问
	sal float64
}

//写一个工厂模式的函数，相当于构造函数
func NewPerson(name string) *person{
	return &person{
		Name : name,
	}
}
//为了访问age和sal我们编写一个SertXxx的方法和GetXxx方法
func (p *person) SetAge(age int) {
	if age >0 && age < 150 {
		p.age = age
	}else{
		fmt.Println("年龄范围不正确...")
	}
}

func (p *person) GetAge() int {
	return p.age
}
func (p *person) SetSal(sal float64){
    if sal >=3000 && sal <= 30000 {
        p.sal = sal
	}else{
		fmt.Println("年龄范围不正确...")
	}
}

func (p *person) GetSal() float64{
	return p.sal
}
在其他包的main.go进行调用
package main
import (
	"fmt"
	"go_code/object2/encapsulate/model"
)

func main (){
	p :=model.NewPerson("smith")
	p.SetAge(18)
	p.SetSal(5000.0)
	fmt.Println(*p)
	fmt.Println(p.Name,"age =",p.GetAge(),"sal = ",p.GetSal())
}
&练习：

创建一个程序在model包中定义一个Account结构体：在main函数中体会Golang封装性

  1. Account结构体要求具有字段：账号（长度在6-10之间）、余额(必须>20)、密码（必须是六位）
  2. 通过SetXxx的方法给Account的字段赋值
  3. 在main函数中测试
package model
import (
	"fmt"
)
//定义一个结构体
type account struct{
	accountNo string
	pwd string
	balance float64
}

//工厂模式的函数-构造函数
func NewAccount(accountNo string,pwd string,balance float64) *account{
	if len(accountNo) < 6 || len(accountNo) > 10 {
		fmt.Println("账号的长度不对...")
		return nil
	}
	if len(pwd) != 6 {
		fmt.Println("密码的长度不对...")
		return nil
	}
	if balance < 20 {
		fmt.Println("余额数目不对")
		return nil
	}
	return &account{
		accountNo : accountNo,
		pwd : pwd,
		balance : balance,
	}
}




//方法
//1.存款
func (ac *account) Deposite(money float64,pwd string){
	//看看输入的密码是否正确
	if pwd !=ac.pwd{
		fmt.Println("你输入的密码不正确")
		return
	}

	//看看存款金额是否正确
	if money <= 0 {
		fmt.Println("你输入的金额不正确")
		return
	}

	ac.balance += money
	fmt.Println("存款成功")
}
//取款
func (ac *account) WithDraw(money float64,pwd string){
	//看看输入的密码是否正确
	if pwd !=ac.pwd{
		fmt.Println("你输入的密码不正确")
		return
	}

	//看看存款金额是否正确
	if money <= 0 || money >ac.balance{
		fmt.Println("你输入的金额不正确")
		return
	}

	ac.balance -= money
	fmt.Println("取款成功")
}


//查询余额
func (ac *account)Query(pwd string){
	//看看输入的密码是否正确
	if pwd !=ac.pwd{
		fmt.Println("你输入的密码不正确")
		return
	}
	fmt.Printf("你的账号为=%v 余额=%v \n",ac.accountNo,ac.balance)
}

main。go中进行测试
package main
import (
	"fmt"
	"go_code/object3/ex2/model"
)
func main(){
	account := model.NewAccount("jzh1111","999999",48)
   if account !=nil{
       fmt.Println("创建成功=",*account)
   }else{
	   fmt.Println("创建失败")
   }
}
4）面向对象编程思想-继承
&1.为什么需要继承

当然是为了代码复用

走代码看看

package main
import (
	"fmt"
)
//编写一个学生考试系统
type Pupil struct {
	Name string
	Age int
	Score int
}

//显示成绩
func (p *Pupil) ShowInfo(){
   fmt.Printf("显示学生名字=%v 年龄=%v 成绩=%v",p.Name,p.Age,p.Score)
}
func (p *Pupil) SetScore(score int) {
	
	p.Score = score
}

func (p *Pupil) testing() {
	fmt.Println("小学生正在考试")
}
//大学生，研究生。。
type Graduate struct {
	Name string
	Age int
	Score int
}

//显示成绩
func (p *Graduate) ShowInfo(){
   fmt.Printf("显示学生名字=%v 年龄=%v 成绩=%v",p.Name,p.Age,p.Score)
}
func (p *Graduate) SetScore(score int) {
	
	p.Score = score
}

func (p *Graduate) testing() {
	fmt.Println("大学生正在考试")
}

func main(){
  //测试
  var pupil = &Pupil{
	Name : "Tom",
	Age : 10,
  }

  pupil.testing()
  pupil.SetScore(90)
  pupil.ShowInfo()

  //测试
  var graduate = &Graduate{
	Name : "jhon",
	Age : 10,
  }

  graduate.testing()
  graduate.SetScore(90)
  graduate.ShowInfo()
}
//代码冗余 。。。高中生。。。

对上面代码做一个小结

  1. Pupil和Graduate两个结构体的字段和方法集合一样，但我们欠缺写了相同的代码，代码复用性不强
  2. 出现代码冗余，而且代码不利于维护，同时也不利于功能的扩展
  3. 解决方法：通过继承的方式解决
&2继承的基本介绍和示意图

继承可以解决代码复用，让我们的编程更加靠近人类思维

当多个结构体存在相同的属性（字段）和方法时，可以从这些结构体中抽象出结构体（比如刚才的Student），在该结构体中定义这些相同的属性和方法。

其他的结构体不需要重新定义这些属性（字段）和方法，只需嵌套一个Student匿名结构体即可

go的面向对象学习_第13张图片

也就是说：在Golang中，如果一个struct嵌套了另一个匿名结构体，那么这个结构体可以直接访问匿名结构体的字段和方法，从而实现了继承特性

&3.嵌套匿名结构体的基本语法
type Goods struct{
   Name string
   Price int
}
type Book struct {
     Goods//这里就是嵌套匿名结构体Goods相当于加入了Name和Pirce这两个字段
     Writer string
}

&4.应用案例

我们对先前有关student的结构体进行改进操作减少其冗余性,代码实现

package main
import (
	"fmt"
)
//编写一个学生考试系统
type Student struct{
	Name string
	Age int
	Score int
}
//将Pupil和Graduate共有的方法也绑定到Student
func (stu *Student) ShowInfo(){
	fmt.Printf("显示学生名字=%v 年龄=%v 成绩=%v",stu.Name,stu.Age,stu.Score)
}

func (stu *Student)SetScore(score int) {
	
	stu.Score = score
}

//给*Student增加一个方法，那么Pupil 和Graduate都可以使用该方法
func (stu *Student) GetSum(n1 int, n2 int) int{
	return n1 + n2
}

//小学生
type Pupil struct {
	Student  //嵌入Student匿名结构体
}

//这是Pupil结构体特有的方法，保留
func (p *Pupil) testing() {
	fmt.Println("小学生正在考试")
}
//大学生，研究生。。
type Graduate struct {
	Student  //嵌入Student匿名结构体
}
//保留特有的方法
func (p *Graduate) testing() {
	fmt.Println("大学生正在考试")
}

func main(){
  
	//当我们对结构体嵌入了匿名结构体使用方法会发生变化
	pupil :=&Pupil{}
	pupil.Student.Name ="tom~"
	pupil.Student.Age = 8
	pupil.testing()
	pupil.Student.SetScore(70)
	pupil.Student.ShowInfo()
    
	fmt.Println("res=",pupil.Student.GetSum(1,2))
	//大学生进行操作
	graduate :=&Graduate{}
	graduate.Student.Name ="MARY"
	graduate.Student.Age = 28
	graduate.testing()
	graduate.Student.SetScore(90)
	graduate.Student.ShowInfo()
	fmt.Println("res=",graduate.Student.GetSum(10,79))

}

&4.继承的深入讨论1

  1. 结构体可以使用嵌套匿名结构体所有的字段和方法，即：首字母大写或者小写的字段、方法，都可以使用。

    package main
import (
	"fmt"
)

type A struct {
	Name string
	age int
}

func (a *A) SayOk(){
   fmt.Println(" A SayOk",a.Name)
}
func (a *A) Hello(){
	fmt.Println(" A Hello",a.Name)
 }
type B struct {
	A
}
func main(){
   var b B
   b.A.Name = "tom"
   b.A.age = 19
   b.A.SayOk()
   b.A.Hello()


}

  2. 匿名结构体字段访问可以简化(如果B结构体中没有变量那么就会自动去寻找嵌入的结构体中的字段或方法)。

    var b B
   b.A.Name = "tom"       b.Name = "tom"
   b.A.age = 19    ==>    b.age = 19
   b.A.SayOk()            b.SayOk()  
   b.A.Hello()            b.Hello()

    总结

    1. 当我们直接通过b访问字段或方法时，其执行流程如下比如b.Name

    ​ 2.编译器会先看b对应的类型有没有Name，如果有则直接调用B类型的 Name字段，如果没有继续查找，没有找到就报错

    ​ 3.如果没有就去看嵌入中的匿名结构体有没有声明Name字段

  3. 当结构体和匿名结构体有相同的字段或者方法时，编译器采用就近访问原则访问如希望访问匿名结构体的字段和方法，可以通过匿名结构体名来区分。

    package main
import (
	"fmt"
)

type A struct {
	Name string
	age int
}

func (a *A) SayOk(){
   fmt.Println(" A SayOk",a.Name)
}
func (a *A) hello(){
	fmt.Println(" A Hello",a.Name)
 }
type B struct {
	A
}
func (b *B)SayOk() {
	fmt.Println("B SayOK",b.Name)
}
func main(){
   var b B
//    b.A.Name = "tom"
//    b.A.age = 19
//    b.A.SayOk()
//    b.A.hello()
   b.Name = "jack"
   b.age  = 100
   b.SayOk()  //B SayOK jack
   b.hello() // A Hello jack


}

  4. 结构体嵌入两个（或多个）匿名结构体，如两个匿名结构体有相同额字段和方法（同时结构体本身没有同名的字段和方法），在访问时，就必须明确指定匿名结构体名字，否则编译报错

    package main
import (
	"fmt"
)

type A struct {
	Name string
	age int
}
type B struct {
	Name string
	score float64
}
type C struct {
	A
	B
	Name string
}
func main(){
   var c C
   //如果 c 无Name字段，而A和B有Name,这时就必须指定匿名结构体名字来区分
   //c.Name = "tom"//会报错，因为不知道选择A里的Name还是B里面的Name
   //c.A.Name = "tom" //具体指定哪一个结构体中的Name
   c.Name = "tom" //成功是因为C有Name

}
//这个规则对于方法也是有效的

  5. 如果一个struct嵌套了一个有名的结构体，这种模式就是组合，如果是组合关系，那么在访问组合结构体的字段或方法时，必须带上结构体的名字

    type D struct {
	a A //有名结构体
}
func main(){
   var c C
   
   var d D
//    d.Name= "jack"//报错，必须将结构体名字带上
   d.a.Name = "jack"

  6. 嵌套匿名结构体，也可以在创建结构体变量（实例）时，直接指定各个匿名结构体字段的值

    package main
import (
	"fmt"
)

type A struct {
	Name string
	age int
}
type B struct {
	Name string
	score float64
}
type C struct {
	A
	B
	Name string
}
type D struct {
	a A //有名结构体
}

type Goods struct{
	Name string
	Price float64
}


type Brand struct{
	Name string
	Address string
}
type TV struct {
	Goods
	Brand
}
type TV2 struct {  //也可将指针类型传入进去
	*Goods
	*Brand
}
func main(){
   var c C
   //如果 c 无Name字段，而A和B有Name,这时就必须指定匿名结构体名字来区分
   //c.Name = "tom"//会报错，因为不知道选择A里的Name还是B里面的Name
   //c.A.Name = "tom" //具体指定哪一个结构体中的Name
   c.Name = "tom" //成功是因为C有Name
   var d D
//    d.Name= "jack"//报错，必须将结构体名字带上
   d.a.Name = "jack"

   tv := TV{ Goods{"电视机001",5000.99},Brand{"海尔","山东"}, }
   
   tv2 := TV{
	Goods{
		Price : 6000.90,
		Name : "电视002",
	},
	Brand{
		Name : "长虹",
		Address :"北京",
	},
   }
//创建之时要把地址传入进去
   tv3 := TV2{ &Goods{"电视机003",7000.99},&Brand{"创维","深圳"}, }
   fmt.Println("TV=",tv)
   fmt.Println("TV2=",tv2)
   fmt.Println("TV3=",*tv3.Goods,*tv3.Brand)
   tv4 := TV2{ 
	&Goods{
		Name : "电视机004",
		Price : 9900.99,
		},
		&Brand{
			Name : "康佳",
			Address : "上海",
			}, 
		}
		fmt.Println("TV4=",*tv4.Goods,*tv4.Brand)
}
&4.课堂练习

结构体的匿名字段是基本数据类型，如何访问，下面的代码

type A struct {  
    Name string
    Age int
}
type Stu struct {
     A
     int
}
func  main(){
stu :=Stu{}
stu.Name = "tom"
stu.Age = 10
stu.int = 80
fmt.Println(stu)
}
//输出结果为
{{tom 10} 80}

说明：

  1. 如果一个结构体有int类型的匿名字段，就不能有第二个。
  2. 如果需要多个int类型字段，则必须给int指定名字
&5.多重继承

多重继承说明

如一个struct嵌套了多个匿名结构体，那么该结构体可以直接访问嵌套的匿名结构体的字段和方法。从而实现了多重继承

&6.多重继承细节说明

  1. 如果嵌入的匿名结构体有相同的字段名或方法名，则在访问时，需要通过匿名结构体类型来区分
    main(){
    var c C

    var d D
    // d.Name= “jack”//报错，必须将结构体名字带上
    d.a.Name = “jack”

  2. 嵌套匿名结构体，也可以在创建结构体变量（实例）时，直接指定各个匿名结构体字段的值

    package main
import (
	"fmt"
)

type A struct {
	Name string
	age int
}
type B struct {
	Name string
	score float64
}
type C struct {
	A
	B
	Name string
}
type D struct {
	a A //有名结构体
}

type Goods struct{
	Name string
	Price float64
}


type Brand struct{
	Name string
	Address string
}
type TV struct {
	Goods
	Brand
}
type TV2 struct {  //也可将指针类型传入进去
	*Goods
	*Brand
}
func main(){
   var c C
   //如果 c 无Name字段，而A和B有Name,这时就必须指定匿名结构体名字来区分
   //c.Name = "tom"//会报错，因为不知道选择A里的Name还是B里面的Name
   //c.A.Name = "tom" //具体指定哪一个结构体中的Name
   c.Name = "tom" //成功是因为C有Name
   var d D
//    d.Name= "jack"//报错，必须将结构体名字带上
   d.a.Name = "jack"

   tv := TV{ Goods{"电视机001",5000.99},Brand{"海尔","山东"}, }
   
   tv2 := TV{
	Goods{
		Price : 6000.90,
		Name : "电视002",
	},
	Brand{
		Name : "长虹",
		Address :"北京",
	},
   }
//创建之时要把地址传入进去
   tv3 := TV2{ &Goods{"电视机003",7000.99},&Brand{"创维","深圳"}, }
   fmt.Println("TV=",tv)
   fmt.Println("TV2=",tv2)
   fmt.Println("TV3=",*tv3.Goods,*tv3.Brand)
   tv4 := TV2{ 
	&Goods{
		Name : "电视机004",
		Price : 9900.99,
		},
		&Brand{
			Name : "康佳",
			Address : "上海",
			}, 
		}
		fmt.Println("TV4=",*tv4.Goods,*tv4.Brand)
}
&4.课堂练习

结构体的匿名字段是基本数据类型，如何访问，下面的代码

type A struct {  
    Name string
    Age int
}
type Stu struct {
     A
     int
}
func  main(){
stu :=Stu{}
stu.Name = "tom"
stu.Age = 10
stu.int = 80
fmt.Println(stu)
}
//输出结果为
{{tom 10} 80}

说明：

  1. 如果一个结构体有int类型的匿名字段，就不能有第二个。
  2. 如果需要多个int类型字段，则必须给int指定名字
&5.多重继承

多重继承说明

如一个struct嵌套了多个匿名结构体，那么该结构体可以直接访问嵌套的匿名结构体的字段和方法。从而实现了多重继承

&6.多重继承细节说明
  1. 如果嵌入的匿名结构体有相同的字段名或方法名，则在访问时，需要通过匿名结构体类型来区分
  2. 为了保证代码的简洁性，尽量不要使用多重继承

你可能感兴趣的:(golang学习,学习日记,golang,学习,爬虫)

  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 2019-12-22-22:30 涓涓1016
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • GitHub上克隆项目 bigbig猩猩 github
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • 人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 阶段总结反思 轻争
    马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • ARM驱动学习之4小结 JT灬新一 嵌入式C++arm开发学习linux
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
  • 展现思维导图魅力，不断挖掘人生宝藏 思维导图讲师Mandy
    第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
  • 2019-3-23晨间日记 红红火火小耳朵
    今天是什么日子起床：7点40就寝：23点半天气：有太阳，不过一会儿出来一会儿进去特别清爽的凉意，还蛮舒服的心情：小激动要给女朋友过生日啦纪念日：田田女士过生日任务清单昨日完成的任务，最重要的三件事：1.英语一对一2.运动计划3.认真护肤习惯养成：调整状态周目标·完成进度英语七天打卡（5/7）轻课阅读（87/180）音标课（25/30）读书（福尔摩斯一章）学习·信息·阅读#英语课#Cookingte
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 教育 用心灵温暖心灵
    @陈春丽长期学习班冯倩。今天一早就听到说高职合并，取消中专教育的教育信息。感觉是虽然知道，再听还是吓一跳。国家重视职业教育为何还要取消中专技术学校的教育？再听高中就要进行技术教育了，一部分人学习好继续努力学习考大学，一部分人在高中就可以进行职业教育接受职业教育了还要中专技术教育学校干什么呢！a有些职业教育学校转型升级快，不是孩子上完给找工作，而是学校帮孩子创业，我觉得是不错的方向！新闻新你得实时更
  • 数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首 张三叨
    你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
  • 学习“论语”-第59天 春峰轩
    12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • web前段跨域nginx代理配置 刘正强 nginxcmsWeb
    nginx代理配置可参考server部分 server {         listen       80;         server_name  localhost;
  • spring学习笔记 caoyong spring
    一、概述     a>、核心技术 : IOC与AOP b>、开发为什么需要面向接口而不是实现     接口降低一个组件与整个系统的藕合程度，当该组件不满足系统需求时，可以很容易的将该组件从系统中替换掉，而不会对整个系统产生大的影响 c>、面向接口编口编程的难点在于如何对接口进行初始化,(使用工厂设计模式)
  • Eclipse打开workspace提示工作空间不可用 0624chenhong eclipse
    做项目的时候，难免会用到整个团队的代码，或者上一任同事创建的workspace， 1.电脑切换账号后，Eclipse打开时，会提示Eclipse对应的目录锁定，无法访问，根据提示，找到对应目录，G:\eclipse\configuration\org.eclipse.osgi\.manager，其中文件.fileTableLock提示被锁定。 解决办法，删掉.fileTableLock文件，重
  • Javascript 面向对面写法的必要性？ 一炮送你回车库 JavaScript
    现在Javascript面向对象的方式来写页面很流行，什么纯javascript的mvc框架都出来了：ember 这是javascript层的mvc框架哦,不是j2ee的mvc框架   我想说的是，javascript本来就不是一门面向对象的语言，用它写出来的面向对象的程序，本身就有些别扭，很多人提到js的面向对象首先提的是：复用性。那么我请问你写的js里有多少是可以复用的，用fu
  • js array对象的迭代方法 换个号韩国红果果 array
    1.forEach 该方法接受一个函数作为参数， 对数组中的每个元素 使用该函数  return 语句失效 function square(num) { print(num, num * num); } var nums = [1,2,3,4,5,6,7,8,9,10]; nums.forEach(square); 2.every 该方法接受一个返回值为布尔类型
  • 对Hibernate缓存机制的理解 归来朝歌 session一级缓存对象持久化
    在hibernate中session一级缓存机制中，有这么一种情况： 问题描述：我需要new一个对象，对它的几个字段赋值，但是有一些属性并没有进行赋值，然后调用 session.save()方法，在提交事务后，会出现这样的情况： 1：在数据库中有默认属性的字段的值为空 2：既然是持久化对象，为什么在最后对象拿不到默认属性的值？ 通过调试后解决方案如下： 对于问题一，如你在数据库里设置了
  • WebService调用错误合集 darkranger webservice
     Java.Lang.NoClassDefFoundError: Org/Apache/Commons/Discovery/Tools/DiscoverSingleton 调用接口出错， 一个简单的WebService import org.apache.axis.client.Call;import org.apache.axis.client.Service; 首先必不可
  • JSP和Servlet的中文乱码处理 aijuans Java Web
    JSP和Servlet的中文乱码处理 前几天学习了JSP和Servlet中有关中文乱码的一些问题，写成了博客，今天进行更新一下。应该是可以解决日常的乱码问题了。现在作以下总结希望对需要的人有所帮助。我也是刚学，所以有不足之处希望谅解。 一、表单提交时出现乱码： 在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以
  • 面试经典六问 atongyeye 工作面试
    题记：因为我不善沟通，所以在面试中经常碰壁，看了网上太多面试宝典，基本上不太靠谱。只好自己总结，并试着根据最近工作情况完成个人答案。以备不时之需。 以下是人事了解应聘者情况的最典型的六个问题： 1 简单自我介绍 关于这个问题，主要为了弄清两件事，一是了解应聘者的背景，二是应聘者将这些背景信息组织成合适语言的能力。 我的回答：(针对技术面试回答，如果是人事面试，可以就掌
  • contentResolver.query()参数详解 百合不是茶 androidquery()详解
    收藏csdn的博客,介绍的比较详细,新手值得一看 1.获取联系人姓名 一个简单的例子，这个函数获取设备上所有的联系人ID和联系人NAME。 [java]  view plain copy   public void fetchAllContacts() {      
  • ora-00054:resource busy and acquire with nowait specified解决方法 bijian1013 oracle数据库killnowait
            当某个数据库用户在数据库中插入、更新、删除一个表的数据，或者增加一个表的主键时或者表的索引时，常常会出现ora-00054:resource busy and acquire with nowait specified这样的错误。主要是因为有事务正在执行（或者事务已经被锁），所有导致执行不成功。 1.下面的语句
  • web 开发乱码 征客丶 springWeb
    以下前端都是 utf-8 字符集编码 一、后台接收 1.1、 get 请求乱码 get 请求中，请求参数在请求头中； 乱码解决方法： a、通过在web 服务器中配置编码格式：tomcat 中，在 Connector 中添加URIEncoding="UTF-8"； 1.2、post 请求乱码 post 请求中，请求参数分两部份， 1.2.1、url？参数，
  • 【Spark十六】： Spark SQL第二部分数据源和注册表的几种方式 bit1129 spark
    Spark SQL数据源和表的Schema case class apply schema parquet json JSON数据源 准备源数据 {"name":"Jack", "age": 12, "addr":{"city":"beijing&
  • JVM学习之:调优总结 -Xms -Xmx -Xmn -Xss BlueSkator -Xss-Xmn-Xms-Xmx
      堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置： java -Xmx355
  • jqGrid 各种参数 详解(转帖) BreakingBad jqGrid
      jqGrid 各种参数 详解 分类：  源代码分享  个人随笔请勿参考  解决开发问题 2012-05-09 20:29   84282人阅读   评论(22)   收藏   举报 jquery 服务器 parameters function ajax string  
  • 读《研磨设计模式》-代码笔记-代理模式-Proxy bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /* * 下面
  • 应用升级iOS8中遇到的一些问题 chenhbc ios8升级iOS8
    1、很奇怪的问题，登录界面，有一个判断，如果不存在某个值，则跳转到设置界面，ios8之前的系统都可以正常跳转，iOS8中代码已经执行到下一个界面了，但界面并没有跳转过去，而且这个值如果设置过的话，也是可以正常跳转过去的，这个问题纠结了两天多，之前的判断我是在 -(void)viewWillAppear:(BOOL)animated  中写的，最终的解决办法是把判断写在 -(void
  • 工作流与自组织的关系？ comsci 设计模式工作
      目前的工作流系统中的节点及其相互之间的连接是事先根据管理的实际需要而绘制好的，这种固定的模式在实际的运用中会受到很多限制，特别是节点之间的依存关系是固定的，节点的处理不考虑到流程整体的运行情况，细节和整体间的关系是脱节的，那么我们提出一个新的观点，一个流程是否可以通过节点的自组织运动来自动生成呢？这种流程有什么实际意义呢？   这里有篇论文，摘要是：“针对网格中的服务
  • Oracle11.2新特性之INSERT提示IGNORE_ROW_ON_DUPKEY_INDEX daizj oracle
    insert提示IGNORE_ROW_ON_DUPKEY_INDEX 转自：http://space.itpub.net/18922393/viewspace-752123 在 insert into tablea ...select * from tableb中，如果存在唯一约束，会导致整个insert操作失败。使用IGNORE_ROW_ON_DUPKEY_INDEX提示，会忽略唯一
  • 二叉树:堆 dieslrae 二叉树
        这里说的堆其实是一个完全二叉树,每个节点都不小于自己的子节点,不要跟jvm的堆搞混了.由于是完全二叉树,可以用数组来构建.用数组构建树的规则很简单:     一个节点的父节点下标为: (当前下标 - 1)/2     一个节点的左节点下标为: 当前下标 * 2 + 1   &
  • C语言学习八结构体 dcj3sjt126com c
    为什么需要结构体，看代码 # include <stdio.h> struct Student //定义一个学生类型，里面有age, score, sex, 然后可以定义这个类型的变量 { int age; float score; char sex; } int main(void) { struct Student st = {80, 66.6,
  • centos安装golang dcj3sjt126com centos
    #在国内镜像下载二进制包 wget -c  http://www.golangtc.com/static/go/go1.4.1.linux-amd64.tar.gz tar -C /usr/local -xzf go1.4.1.linux-amd64.tar.gz   #把golang的bin目录加入全局环境变量 cat >>/etc/profile<
  • 10.性能优化-监控-MySQL慢查询 frank1234 性能优化MySQL慢查询
    1.记录慢查询配置 show variables where variable_name like 'slow%' ; --查看默认日志路径 查询结果：--不用的机器可能不同 slow_query_log_file=/var/lib/mysql/centos-slow.log 修改mysqld配置文件：/usr /my.cnf[一般在/etc/my.cnf，本机在/user/my.cn
  • Java父类取得子类类名 happyqing javathis父类子类类名
      在继承关系中，不管父类还是子类，这些类里面的this都代表了最终new出来的那个类的实例对象，所以在父类中你可以用this获取到子类的信息！   package com.urthinker.module.test; import org.junit.Test; abstract class BaseDao<T> { public void
  • Spring3.2新注解@ControllerAdvice jinnianshilongnian @Controller
    @ControllerAdvice，是spring3.2提供的新注解，从名字上可以看出大体意思是控制器增强。让我们先看看@ControllerAdvice的实现：   @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Component public @interface Co
  • Java spring mvc多数据源配置 liuxihope spring
    转自：http://www.itpub.net/thread-1906608-1-1.html 1、首先配置两个数据库 <bean id="dataSourceA" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close&quo
  • 第12章 Ajax（下） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • BW / Universe Mappings blueoxygen BO
      BW Element OLAP Universe Element Cube  Dimension Class Charateristic A class with dimension and detail objects (Detail objects for key and desription) Hi
  • Java开发熟手该当心的11个错误 tomcat_oracle java多线程工作单元测试
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
  • 推行国产操作系统的优劣 yananay windowslinux国产操作系统
    最近刮起了一股风，就是去“国外货”。从应用程序开始，到基础的系统，数据库，现在已经刮到操作系统了。原因就是“棱镜计划”，使我们终于认识到了国外货的危害，开始重视起了信息安全。操作系统是计算机的灵魂。既然是灵魂，为了信息安全，那我们就自然要使用和推行国货。可是，一味地推行，是否就一定正确呢？ 先说说信息安全。其实从很早以来大家就在讨论信息安全。很多年以前，就据传某世界级的网络设备制造商生产的交
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他