go语言的学习之路

　　一.学习前言

　　（1）go语言的介绍

　　　　　1.解释型语言：python   PHP  java scripy (前端)

　　　　　2.编译型语言：C  C++  C#(微软开发)  java（sun公司开发 后来被甲骨文公司收购）

　　　　　　go(谷歌)

　　　　　3.热门语言的法展：2009年11月初 ;使用 python：1989年；java:1990年

　　　　　4.Go是静态强类型语言：强类型》》》固定类型

　　　　　　 是一门跨平台的编译型语言

　　  （2）补充：

　　　　　（1）C开发：在window上开发，编译好的代码只能在windows 环境上使用 无法实现 跨平台

　　　　　　Java 横空出世：跨平台，一处代码处处使用

　　　　　　　　　     原理：代码编译成字节码文件: 中间件

　　　　　　java概念普及：

　　　　　　　　jdk:

JDK，开发java程序用的开发包，JDK里面有java的运行环境(JRE)，包括client和server端的。需要配置环境变量。。。。

Jdk 全写是java development kit，是java的开发工具包，里面包含了各种类库和工具

　　　　　　　　jre

Jre 是java runtime environment, 是java程序的运行环境 》》》 java 的运行程序

、既然是运行，当然要包含jvm，也就是大家熟悉的虚拟机啦，还有所有java类库的class文件，都在lib目录下打包成了jar

　　　　　　　　jvm：java虚拟机

　　　　　　　　javase:java 基础知识  》》》安卓方向呀

　　　　　　　　javaee：进阶(java web 方向 网页的服务端和客户端进行交互的功能的数据实现)

　　　　　　　　　  1.ssh合成框架介绍: 最初 struts进行流程的控制  spring 进行业务的流转，Hibermate进行数据库操作的封装

AVA三大框架的各自作用 

　　hibernate是底层基于jdbc的orm(对象关系映射)持久化框架，即：表与类的映射，字段与属性的映射，记录与对象的映射 数据库模型 也就是Model;
　　struts提供的丰富标签是用于显示层View;同时struts也充当了实现Control的功能(不管是Struts1，还是Struts2)，接收参数，视图分发。
　　Spring是用于降低层与层间耦合度的，就是所有的类都可以由spring统一创建，用时只需注入即可(IOC)
　　从功能上来说，hibernate为M，struts2 为V，也可以为C，spring可以为C。
　　但大多数项目中，hibernate为M，struts2 为V+C，spring用来帮助管理类以及实现一些业务无关功能，如日志记录等，大多数都是用struts来做C的。
一、Spring
 　　Spring是一个解决了许多在J2EE开发中常见的问题的强大框架。 Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。Spring的架构基础是基于使用JavaBean属性的Inversion of Control容器。然而，这仅仅是完整图景中的一部分：Spring在使用IoC容器作为构建完关注所有架构层的完整解决方案方面是独一无二的。 Spring提供了唯一的数据访问抽象，包括简单和有效率的JDBC框架，极大的改进了效率并且减少了可能的错误。Spring的数据访问架构还集成了Hibernate和其他O/R mapping解决方案。Spring还提供了唯一的事务管理抽象，它能够在各种底层事务管理技术，例如JTA或者JDBC事务提供一个一致的编程模型。Spring提供了一个用标准Java语言编写的AOP框架，它给POJOs提供了声明式的事务管理和其他企业事务--如果你需要--还能实现你自己的aspects。这个框架足够强大，使得应用程序能够抛开EJB的复杂性，同时享受着和传统EJB相关的关键服务。Spring还提供了可以和IoC容器集成的强大而灵活的MVC Web框架。

二、STRUCTS
　　Struts是一个基于Sun J2EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。由于Struts能充分满足应用开发的需求，简单易用，敏捷迅速，在过去的一年中颇受关注。Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中，开发人员利用其进行开发时不用再自己编码实现全套MVC模式，极大的节省了时间，所以说Struts是一个非常不错的应用框架。

　　　　　　　　　   2.ssm 三层 简介演变：

  1 Spring简介

    Spring是一个开源框架，是于2003年兴起的一个轻量级的Java开发框架由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。
  它是为了解决企业应用开发的复杂性而创建的。pring使用基本的JavaBean来完成以前只可能由EJB完成的事情。但是，Spring的用途不仅限于服务器端的开发。
  从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

  2 SpringMVC简介

    pring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。pring MVC 分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。

  3 Mybatis简介

   Myatis 原本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。MyBatis是一个基于Java的持久层框架。
 iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO）MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。
 MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Old Java Objects，普通的 Java对象）映射成数据库中的记录。

　　　　　　　 　3.spring全家桶(当下)

　　　　　　　　　　（1）springboot ：一站式搞定

1、SpringBoot：是一个快速开发框架，通过用MAVEN依赖的继承方式，帮助我们快速整合第三方常用框架，
完全采用注解化（使用注解方式启动SpringMVC），简化XML配置，内置HTTP服务器（Tomcat，Jetty），最终以Java应用程序进行执行。

　　　　　　　　　　 （2）sprintcloud: 类似微服务

2、SpringCloud： 是一套目前完整的微服务框架，它是是一系列框架的有序集合。它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，
通过SpringBoot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。
它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，
都可以用SpringBoot的开发风格做到一键启动和部署。

　　　　　　　　　　SpringBoot和SpringCloud的关系与区别

1、SpringBoot只是一个快速开发框架，使用注解简化了xml配置，内置了Servlet容器，以Java应用程序进行执行。

2、SpringCloud是一系列框架的集合，可以包含SpringBoot。

　　　　　　　　　补充：

三、SpringBoot是微服务框架吗？

1、SpringBoot只是一个快速开发框架，算不上微服务框架。

2、SpringCloud+SpringBoot 实现微服务开发。具体的来说是，SpringCloud具备微服务开发的核心技术：RPC远程调用技术；SpringBoot的web组件默认集成了SpringMVC，可以实现HTTP+JSON的轻量级传输，编写微服务接口，所以SpringCloud依赖SpringBoot框架实现微服务开发。

四、SpringMVC在3.0开始支持采用注解方式启动，所以可以不再配置传统的XML配置文件。

　　　　　　　　 javame：手机端开发 （目前好像不怎么用了）

　　　　　　　　大数据：开发方向

　　　　　　　　　　

　　　　　

　　　　　　go编译型语言：跨平台编译

　　　　　　　　　　原理：在windows 平台可以编译出linux操作系统的可执行文件

　　　　　　　　

　　二. Go的安装

　　（1）go的安装：https://golang.google.cn/  直接安装下一步

　　（2）go之IDE编辑器的安装：　https://www.jetbrains.com/go/  其实和我们的pycharm 解释器一样的界面 ，

　　　（3）学习路线

　　　　　　1.注释代码字母

　　　　　　　　单行

　　 　　单行：// 注释 >>> 单行

　　　　　　　　 多行：

/* 第一行
第二行
多行注释
*/

　　　　　　.第一个pringln() >>> hello world  输入　的代码

　

package main  // 表示当前编译型文件的属于main包

import "fmt"  //  导入fmt 包

// 编译型语言需要有一个入口文件 main包下的main 函数
func main()  {
    fmt.Println("hello world") // 类似print（）
}

　　　　如何展现编译型语言

　　　　

方法一：先编译在执行：生成一个可自行文件 >>> 命令行：go buld s1.go  执行：s1.exe 打印结果hello world

　　

　　

方法二：编译并执行(但是不生可自行文件) >>>命令行：go run s1.go

　　　　　　2.变量的定义和使用

　　　　　　　1.var a int =10  第一 声明变量的类型 并初始化

func main()  {
    // 1.var a int =10  第一种 声明变量的类型 并初始化  (1)
    // var a =20 第二种 类型推导出20 是int　　　　　　　　(2)
    // a :=30  // 第三种 简略声明 注意：是跟着等号的 　　　（3）
    // fmt.Println(a)

　　　　　　

　　　　　　2.var b =40  // 注意一个函数内的变量得是不能重定义的

    // 2.var b =40  // 注意一个函数内的变量得是不能重定义的
     // b:=50  会报错
    // fmt.Println(b)

　　　　　　

　　　　　　3.go 是强类型语言在定义一开始就必须指定类型，重新赋值类型是固定 统一类型

     // 3.go 是强类型语言在定义一开始就必须指定类型，重新赋值类型是固定 统一类型
     //var c int = 60
    // c = 100  // 重新赋值
     //  c = "哈哈"  // 直接系统报

　　　　　　

　　　　　　 4.定义不赋初始值 int 类型默认是0 string 类型默认为空

    // 4.定义不赋初始值 int 类型默认是0 string 类型默认为空
    // var d  int 0
    // var d string  空值
    // fmt.Println(d)

　　　　　　 5.同时定义多个类型和多个变量
　　

    var e,f =10,"kk"
    var g,h = 20,30
    fmt.Println(e)
    fmt.Println(f)
    fmt.Println(g,h)  // 没有问题

}

　　　　　　3.类型分类

　　　　　　(1)bool 布尔值

package main

import "fmt"

func main()  {
    // bool 布尔值类型
    var b = true // true
    var c=false
    fmt.Println(b)  // 返回的true
    fmt.Println(c)  // 返回的false

　　（2）整型>>> 正整型和负整型

    // 数字类型
    // int类型:表示整数 int8,int16,int32,int64(机器的最大一次读取位数) 1bytes=8bit

    // uint 正整数uint8，uint16,uint32,uint64
     var e uint64=10  // 不能是负数 var e uint8  = 100
     k:=-1999
     fmt.Println(k)
     fmt.Println(e)

　　（3）//float 浮点数

    //float 浮点数
    var f float64=1.667657  // 只要是浮点数就行了
    fmt.Println(f)
    // byte:uint8的别名 rune:int32 的别名

　　（4）字符串

　　

    // 字符串
    var g string="chian"
    h:="abc"  // 反向推导 是字符串类型
    fmt.Println(g)
    fmt.Println(h)
    // 字符串多行 前面是有空格的
    var j =`第一行
    第二多行
    第三行
`
    fmt.Println(j)

}

　　　　　　4.常量的使用

package main

import "fmt"

// 函数的定义：
func main() {
    // 定义常量不能再次修改
    // const a int= 10
    const a  = 10
    // a = 1000  // 不能修改
    fmt.Println(a)
    const IP  = "127.0.0.1"
    fmt.Println(IP)
}

　　　　　　5.函数的使用：

　　　　　　　　(1)无参和无参返回即调用

　　　　

　　　　　　　　(2)有参和有参返回及调用

　　　　　　　

　　　　　　　　

package main

import "fmt"

// 无返回值

func main(){
    // fmt.Println("haha")
    // test()
     // var x=test1(10,20) // 需要将函数的返回值进行接收
    // var x int=test1(10,20)

    //     x:=test1(2,20)  // 推荐使用
    y:=test2(10,30)

        // t,k:=test3(100,5)  // 注意reture 是返回馈两个值 那么必须用俩个值取接收
        // 如果我们只想要一个返回值 下滑线_ 表示不接收
        t,_:=test3(100,200)
    // fmt.Println(x)// 进行打印
    fmt.Println(y)
        fmt.Println(t)
        // fmt.Println(k)
}
func test()  {

}

// 返回一个值 有参函数 有一个数字类型返回值， 一定要指定返回值的类型
// int 指定返回的数字类型
func test1(a int, b int)  int{
    // 可以写a,b int
    return a+b
}

　　　　命名参数

// 命名返回值  ??? 咋么用
func test4(a ,b int)(j int, k string){
    j=a*b // 直接用
    k="ok"
    return // 不需要指定返回值
}

函数调用

　　不定长参数 在go 函数中是没有位置和关键字参数的

　　函数调用1

　　go 中的闭包函数

(1) 定义在函数内部，对外部作用域有引用

　　(2) go语言中，函数是一等公民看，可以把函数赋值给变量

package main

import "fmt"

func main(){
    var a  func(a int,b int)(int,int)
    a=test6
    a(1,2)
}

func test6(a int,b int ) (int,int) {
    fmt.Println("xxx")
    fmt.Println(a,b)
    return 1,2

}

　　(3) 闭包函数的高级使用

package main

import "fmt"

// 函数高级

// 闭包函数 ，内部号数据引用外部海曙的作用域

// 闭包函数       // 函数返回的类型
func test(a int) func() {
    // 定义内部函数
    // 闭包其实是为函数多了一种传参方式
    // 函数可以你不用写函数名：匿名函数
    b := func() {
    fmt.Println(a)
    fmt.Println("我是闭包函数")
    }
    return b
}

func main(){
    // go中无论是函数名还是函数 定义了必须要执行使用
    // 可以将函数进行赋值
    a:=test(3)
    a()  // 执行函数
}

　　（4）闭包函数 五参数 无返回值

// go 闭包函数中的“装饰器” 的使用 在go 中是没有装饰器一说的
// 定义一个函数 >>>> 传入函数  >>>>> 返回函数
// (五参数五返回值)
func test2(a func()) func(){
    // 内部定义函数
    b:=func(){
        // 外部调用执行内
        fmt.Println("我先执行")

        // 定义的a func() 函数要执行
        a()
        fmt.Println("执行完毕")
    }
    // 外层函数返回
    return b
}

// 再定义一个函数
func test(){
    fmt.Println("我是另一个函数")
}

// 调用的函数  函数内部的调用
func main(){
    // 进行跳转
    a:=test  // 不加括号
    a=test2(a)
    a()
}

　　（5）闭包函数有参数 有返回值

// 给类型命别名
type MyFunc func(a int, b int)
type MyInt int
func test3() {

}

func main(){
    var a MyInt=10
    fmt.Println(a)
}