精华内容
下载资源
问答
  • 一步一个脚印

    2017-06-30 23:11:30
    从事这一行,真的需要一步一个脚印,任何人如此。先打好技术基本功,如编程语言、设计模式、研发工具、三方类库等;做好自己负责的工作,职责范围由小到大,从子模块到模块、服务、子系统、复杂系统、到整体架构等;...
           从事这一行,真的需要一步一个脚印,任何人如此。先打好技术基本功,如编程语言、设计模式、研发工具、三方类库等;做好自己负责的工作,职责范围由小到大,从子模块到模块、服务、子系统、复杂系统、到整体架构等;了解清楚业务,学习各类业务架构,踩各种坑,一步步积累经验,打怪升级。
    

           有一个机会让我从0开始搭建一个百万级别同时在线的即时通讯的架构,在这个过程中我对即时通讯的架构细节和业务细节了解得更深了。之后我又有幸接触到更多的系统和业务,例如支付系统、摊销系统、数据库中间件、推荐系统,O2O的系统等,这些经历使我在架构方面更有经验。

           不同的经历理所当然会丰富我的业务知识以及系统架构设计经验。即时通讯后端架构、推荐系统架构、APP架构,不同的业务形态有着不同的业务特点和系统架构特点,主要矛盾可能不一样。

           对产品的了解、对业务的了解是必须的,架构最终是为业务服务的。对数据的敏感度也是要有的,在追查问题的过程中非常有用。至于广告方面的知识,只是个人兴趣爱好,我觉得广告比较有意思,自己学习学习而已。

            技术人员如果需要集中的时间写代码,建议设定“黄金免打扰时间”,在这个时间段内,关闭QQ、微信、邮箱,尽量不要被打断,提高编码效率。
    展开全文
  • 【  ##为什么选择它?---1、Google官方指定 2、简洁、现代、安全 3、无缝兼容Java  ##Basic:@1:IDE安装 @2:常量和变量、赋值、常量和变量的关系、代码注释 @3:整数型、浮点型、类型安全、布尔型、元组、可空...

         ##为什么选择它?---1、Google官方指定    2、简洁、现代、安全     3、无缝兼容Java
         ##Basic:@1:IDE安装   @2:常量和变量、赋值、常量和变量的关系、代码注释   @3:整数型、浮点型、类型安全、布尔型、元组、可空类型。
         ##Operalor&Type:@1、String-字符串和字符   @2、Collection-数组、Map、集合:一次处理多个类型的元素  @3、控制流-根据逻辑条件控制程序运行流向。
         ##Function & Lambda:@1、函数    @2、Lambda    @3、行内函数   @4、高级函数。
         ##OOP:@1、类和继承、属性、权限修饰符   @2、嵌套、数据类、封印类      @3、枚举类、对象声明和表达式。
       @4、错误处理    @5、类型检查。
         ##Interface:@1、接口实现   @2、接口中的属性    @3、接口冲突规则。
         ##Extensions:@1、函数拓展    @2、属性拓展   @3、伴生对象拓展     @4、拓展成员。
         ##Generics<泛型>:@1、型变    @2、类型投影   @3、泛型函数和泛型约束

    1、开发工具:IntelliJ  IDEA   {JetBrains  
    fun main(args: Array<String>) {
    print( "Hello World 世界你好!")
    }
     
    }

    2、常量:
    {
     
    /**
     * 预期范围内恒定不变的量
     *
     * 定义:val 常量名(任意文字、长度不限)
     * 给常量一个值,叫"赋值",形式 val 常量名 = 值
     */
    val  pai 3.14159
    val  girl 1
    val  wages 7000
    }

    3、变量:
    {
    /**
     * 可主动变更或者预期内自动有规律或者无规律的量
     *
     * 比如:每天的清醒时间、个人前途。。。。
     */

    //空调开机时间
    var  airConditionerOpenTime 5
    }

    4、整数型:
    {
    /**
     * 值的类型
     * 3这样的整数,在Kotlin中称为Int类型的值
     * 形式:var 变量名 : Int = 3
     * 由于Kotlin有类型推断,类型可以省略不写
     */

    //var run : Int = 5
    fun  main(args: Array<String>) {
        var run =  5
        run =  6
        print( "每天跑 ${run } 公里")
    }
    }

    5、浮点型
    {
    /**
     * 浮点型(小数)
     * Kotlin 中默认的浮点型是Double(双精度)
     */

    fun  main(args: Array<String>) {
        val pi =  3.14159267532
        print( "圆周率 ${pi } ")
    }
    }

    6、类型安全
    {
    /**
     * 类型安全:变量一旦定义,其类型不可更改。
     * 即:不能给变量一个类型不同的值
     * 类型安全的JavaScript:TypeScript
     */

    fun  main(args: Array<String>) {
        var 电费 =  3.6
    //    电费 = "5毛"   //类型安全,其类型不可更改。
        print( "电费 ${电费 } ")
    }
    }

    7、布尔型
    {
    /**
    * 布尔型:Boolean
    */
    fun main(args: Array<String>) {
    var vip = false
    print( "布尔值 ${vip } ")
    }
    }

    8、元组(Tuple)
    {
    /**
    * 元组(Tuple),给多个变量同时赋值,分二元(Pair)和三元(Triple)
    */
    fun main(args: Array<String>) {
    val (day ,method ,course) = Triple( 3 , "学会" , "Kotlin") //三元
    println( " ${day } ${method }${course } ")

    val (desc ,toll) = Pair( "学费" , 0) //二元
    println( " ${day } ${method }${course }${desc }${toll } 元")

    val peopleName = Pair( "王" , "五")
    println( "此人的姓名为: ${peopleName. first }${peopleName. second } ")
    }
    }

    9、可空类型
    {
    /**
    * 可空类型(据说这个发明价值$1000000000)
    *
    * 代表变量可能没有值的情况
    * 如:用户资料的选填部分,如住址/性别等辅助信息
    * 形式:var 变量 : 类型?,无值则是null
    */

    fun main(args: Array<String>) {
    var addr: String? = "上海师范大学东校区" //类型后加?代表可空类型
    var sex:Boolean? = null
    if(addr != null){
    println( "您的地址是 ${addr } ")
    }
    sex = false
    if(sex != null && sex){
    println( "您的男生")
    } else{
    println( "您的女生")
    }
    }
    }

    10、可空类型
    {
    /**
    * 可空类型(据说这个发明价值$1000000000)
    *
    * 代表变量可能没有值的情况
    * 如:用户资料的选填部分,如住址/性别等辅助信息
    * 形式:var 变量 : 类型?,无值则是null
    */

    fun main(args: Array<String>) {
    var addr: String? = "上海师范大学东校区" //类型后加?代表可空类型
    var sex:Boolean? = null
    if(addr != null){
    println( "您的地址是 ${addr } ")
    }
    sex = false
    if(sex != null && sex){
    println( "您的男生")
    } else{
    println( "您的女生")
    }
    }
    }

    11、基础操作符
    {
    /**
    * 一个符号或单词,类似数学+、-、*、/,用于运算或者操作
    * 同时操作对象的数目,被称之为几元操作符
    */
    fun main(args: Array<String>) {
    //操作一个目标,是一元操作符
    var a = 3
    var b = a
    var c = -a
    println( "b: ${b } --c: ${c } ")

    //二元操作符操作2个目标,在2个目标之间,前后用空格分隔
    var d = b + c
    println( "d: ${d } ")

    //赋值操作符,用等号右边的值来更新左边变量的值
    var e = d
    println( "e: ${e } ")

    //数学操作符:+、-、*、/
    println( 3+ 4)
    println( 3- 4)
    println( 3* 4)
    println( 3/ 4)

    //赋值与数学操作符的组合,比如+=、-=、*=、/=
    var gdp = 10_000.0
    var gdpGrowth = 6.7/ 100
    gdp += gdp*gdpGrowth
    println(gdp)

    //比较操作符:>、>= 、<、<= 结果是true或false

    //逻辑操作符:布尔值的组合,与<&&>/或<||>/非<!>
    var havaComputer = true
    var netAvaible = true
    var watchVideo = false
    if(havaComputer && netAvaible || watchVideo){
    println( "你学会Kotlin不成问题!")
    } else{
    println( "无法学会Kotlin!")
    }
    var tt = true
    var xx = !tt
    println(xx)
    }
    }

    12、集合类型-数组
    {
    /**
    * 集合类型 Collection
    * 同类型的值的组合,根据整体特性分:
    * 1、有序可重复 - Array,索引从0开始(index,i)
    * 2、无序不重复 - Set
    * 3、无序可重复 - Map,但值有唯一的键(Key) 字典
    * 区别:Array数组和List集合的区别,大小是否可变。
    */
    fun main(args: Array<String>) {
    //Array:Array<类型> 或 arrayof(元素1,元素2,...,元素n)
    //#大小固定,元素类型不可变
    var nollstations = arrayOf( "嘉定北" , "徐家汇" , "南翔" , "桃浦新村" , "上海西站" , "罗山路" , "迪士尼" , "桃浦新村" , "徐家汇")
    for (nollstation in nollstations) {
    // println(nollstation)
    }

    //创建一个有默认值的数组,Array(计数,{默认值})
    var nollstionNamePlaces = Array( 20 , { "临时站名" })
    for (nollstionNamePlace in nollstionNamePlaces) {
    // println(nollstionNamePlace)
    }

    //创建1到10数组:Array(10,{i ->i+1})
    //i代表元素的索引值,从0开始。
    var oneToTen = Array( 10 , {i ->i+ 1 }) //通过索引和Lamda表达式给数组赋值,索引默认从0开始
    for (i in oneToTen) {
    // println("输出数组元素为:${i}")
    }

    //元素计数:count(),空否:isEmpty
    /* println("数组的长度为:${oneToTen.count()}")
    println("数组为空:${oneToTen.isEmpty()}")
    println("数组不为空:${oneToTen.isNotEmpty()}")*/

    //获取其中元素:数组名[索引],首元素:数组名.first,尾元素:数组名.last
    /* println("获取数组的首元素:${oneToTen.first()}")
    println("获取数组元素的尾元素:${oneToTen.last()}")
    println("获取数组指定索引(3)位置的值:${oneToTen[3]}")*/
    //获取前5个元素的快捷方法.component 1到5
    // println("${oneToTen.component1()},${oneToTen.component2()}")

    //获取筛选重复元素后的数组:distinct()或用.toSet()转为Set.
    var nollStationsNoRepeat = nollstations. distinct() //唯一,去重
    for (s in nollStationsNoRepeat) {
    // println("通过distinct()去重后的数组元素为:${s}")
    }
    var nollStationsNoRepeatToSet = nollstations. toSet() //转换成Set集合,去重
    for (s in nollStationsNoRepeatToSet) {
    // println("通过toSet()转成集合去重后元素为:${s}")
    }

    //切割数组:sliceArray
    val nollstationsInNanXiang = nollstations. sliceArray( 2.. 3) //规定一个区间
    for (s in nollstationsInNanXiang) {
    // println("切割后的数组元素为:${s}")
    }
    //mutableList:MutableList<类型>或mutableListOf(元素1,元素2,....,元素n)
    //注意:大小可变,类型不可变.
    var nollNewsStations = mutableListOf( "嘉定北" , "徐家汇" , "南翔" , "桃浦新村" , "上海西站" , "罗山路" , "迪士尼" ,
    "桃浦新村" , "徐家汇" , "嘉定北" , "嘉定新城")
    var newStations = arrayOf( "徐家汇" , "嘉定北" , "嘉定新城")

    //在末尾增加元素:add方法,添加另一个数组addAll方法
    nollNewsStations.add( "花桥")
    nollNewsStations. addAll(newStations)
    for (nollNewsStation in nollNewsStations. distinct()) { //去重
    // println("添加数组元素后的结果为:${nollNewsStation}")
    }

    //移除元素remove,移除指定位置removeAt,移除一个数组
    nollNewsStations. removeAll(newStations) //移除一个数组
    nollNewsStations.removeAt( 0) //根据下标移除元素
    nollNewsStations.remove( "花桥") //根据元素名移除元素

    for (nollNewsStation in nollNewsStations) {
    // println("移除元素后的数组集合为:${nollNewsStation}")
    }
    }
    }

    13、集合类型-Set
    {
    /**
    * 集合类型 Set:无序不重复
    * 主要方法:交差并补
    */
    fun main(args: Array<String>) {

    //Set<类型> 或 setOf(元素1,元素2,...,元素n)
    //注意:大小固定,元素类型不可变

    //地铁11号线主线:"迪士尼","徐家汇","桃浦新村","南翔","马陆","嘉定新城"
    //嘉定区支线:"嘉定新城","嘉定西","嘉定北"
    //江苏昆山支线:"嘉定新城","上海赛车场","安亭","花桥"
    val mainLine = setOf( "迪士尼" , "徐家汇" , "桃浦新村" , "南翔" , "马陆" , "嘉定新城")
    val subkineJd = setOf( "嘉定新城" , "嘉定西" , "嘉定北")
    val sublineKs = setOf( "嘉定新城" , "上海赛车场" , "安亭" , "花桥")

    //元素计数:count(),空否:isEmpty()
    // println("Set集合计数:${mainLine.count()}")

    //检查是否包含某元素:contains,包含另一个Set:containsAll
    /* println("Set集合是否包含某个元素:${mainLine.contains("徐家汇")}")
    println("Set集合是否包含某个集合:${mainLine.containsAll(subkineJd)}")*/

    //转化为数组:toTypedArray()
    mainLine. toTypedArray()

    //集合之间的运算:intersect<交>/subtract<差>/union<并>/minus<补>(补集的被操作对象无须是Set类型)
    val interchage = mainLine. intersect(subkineJd) //取交:换乘站
    println( "换成站为: ${interchage } ")
    println( "取差集: ${mainLine. subtract(subkineJd) } ") //取差集:就是取交集剩下的部分
    println( "集合元素合并,行程所有站点: ${mainLine. union(subkineJd). union(sublineKs) } ")
    println( "获取集合元素的补集: ${mainLine. minus(subkineJd) } ")

    //转换为可变:toMutableSet

    //MutableSet<类型>或mutableSetOf(元素1,元素2,...,元素n)
    //注意:大小可变,类型不可变.
    val mutableMainline = mainLine. union(subkineJd). union(sublineKs). toMutableSet() //长度可变

    //在末尾增加元素:add方法. 添加另一个集合:addAll方法
    mutableMainline.add( "光明路")
    val newsLine = setOf( "昌吉东路" , "上海汽车城")
    mutableMainline.addAll(newsLine)

    //移除元素:remove, 移除另一个集合:removeAll
    mutableMainline.remove( "昌吉东路")
    mutableMainline.removeAll(newsLine)
    for (s in mutableMainline) {
    println( "最后的集合元素为: ${s } ")
    }
    }
    }

    14、集合类型-Map
    {
    /**
    * 集合类型Map:无序可重复.类型于"字典"字典的概念
    * 主要属性:keys (Set),values
    * 主要方法:
    */
    fun main(args: Array<String>) {

    //mapOf<key,value>(pair(key,value),...)
    //显示指定类型,可防止初始化值类型的错误
    //机场:"PVG","浦东" "SHA","虹桥" "HGH","萧山"
    val airports = mapOf <String,String>(Pair( "PVG" , "浦东国际机场") ,Pair( "SHA" , "虹桥") , Pair( "HGH" , "萧山")) //元组

    //元素计数:size,空否:isEmpty()
    println( "Map集合的大小: ${airports. size } 是否为空 ${airports.isEmpty() } ")

    //获取某个key对应的value:get,getOrDefault
    println( "根据键key-PVG获取值: ${airports.get( "PVG") } ")
    println( "根据键key获取值不存在返回默认值: ${airports.getOrDefault( "PVGs" , "送你去外太空") } ")

    //返回所有的key:keys,所有的value:values
    for (key in airports. keys) {
    println( "打印Map集合所有ksy的值: ${key } ")
    }
    for (value in airports. values) {
    println( "打印Map集合所有values的值: ${value } ")
    }
    //转换为可变:toMutableMap
    val airports2 = airports. toMutableMap()

    //mutableMapOf<key,value>(Pair(key,value),...)

    //添加或更新:下标方法 map变量名[key] = value
    airports2[ "PVG"] = "上海市浦东新区浦东国际机场" //存在键值,则更新对应的value值
    airports2[ "DLC"] = "大连市周水子机场" //不存在键,则新增一条数据
    for (mutableEntry in airports2) {
    // println("打印键值对:(${mutableEntry.key},${mutableEntry.value})")
    }

    //移除元素:remove
    airports2.remove( "PVG")
    for (mutableEntry in airports2) {
    println( "移除元素后的集合为:( ${mutableEntry. key } , ${mutableEntry. value } )")
    }
    }
    }




    展开全文
  • "快来学习Kotlin安卓开发" ) println (articlenewTitle.toString()) //数据类对象的解构 val   (id ,   title) = article println ( " $ id , $ title " ) //...
    26、数据类
    {
    /**
    * 数据类:专用于只"保存"数据的类,比如用户自动登录信息,聊天记录等
    * 这里的保存,并不是指保存到磁盘,而是指转换成文本格式,便于保存.
    * Kotlin数据类:data class 类名(属性列表)
    */
    data class  Article( var   id: Int , var   title: String , var   content: String)

    fun   main(args: Array<String>) {
    val  article = Article( 1001 ,   "基于Kotlin安卓开发" , "Kotlin内容介绍")

    //数据类的序列化:其实就是将实例转化成文本形式
    println(article.toString())

    //复制 copy:生成一个对象的克隆,并更改部分属性
    val  articlenewTitle = article.copy( title =   "快来学习Kotlin安卓开发")
    println(articlenewTitle.toString())

    //数据类对象的解构
    val  (id ,  title) = article
    println( " $id , $title ")

    //componentN列举属性
    println( "componentN: ${article.component2() } , ${article.component3() } ")
    }
    }

    27、枚举类
    {
    /**
    * 枚举类:有限个类型的枚举.
    * 其中的每一个称为枚举常量(可带初始值),每一个以逗号分隔
    */
    //扑克牌花色
    enum class  PokerCard {
    红心 ,   方片 ,   梅花 ,   黑桃
    }

    //衣服尺码:带构造器的枚举
    enum class  Size( val   height: Int) {
    S( 150) ,   M( 160) ,   L( 170) ,   XL( 180) ,   XXL( 190)
    }

    fun   main(args: Array<String>) {
    //列举枚举类的常量
    println(PokerCard.values(). joinToString())
    //枚举常量 名称和序号,name,ordinal
    println(Size.valueOf( "XXL"). name)
    println(Size.valueOf( "XXL"). ordinal) //位置

    println(Size.values(). joinToString   { it. name  +   ":"  +   it. height   })
    }
    }

    28、对象声明和表达式
    {
    /**
    * 有时候只是要对某个类进行轻微改造,供临时使用,避免继承
    * 对象声明和表达式就很有用.
    * 对面向对象编程的优化,避免一些继承导致的代价过高.
    */
    //对于中国人来说,这个类,可能各省人适合继承
    open class  Chinese28( var   name: String) {
    open val   skin  =   "yellow"
    }

    fun   main(args: Array<String>) {
    //但如果外国人入籍,就不适合用"继承"
    //对象表达式:val 对象名 = object : 类,接口{//属性或方法的override定义}
    val  baako =   object  : Chinese28( "Baako Zaid") {
    override val   skin  =   "black"
    }
    println( "肤色: ${baako. skin } ")

    //纯对象表达式:临时使用,无须继承任何类
    val  tempParking =   object  {
    var   x  =   100
    var   y  =   200
    }
    println( "停车的位置:( ${tempParking. x } , ${tempParking. y } )")

    //对象声明的调用,相当于调用函数
    NetWorkRequestManager.register()

    //伴生对象的方法,与类关联性强。伴生对象的使用
    IDCard.create()
    }

    //对象声明,不能用在函数中
    //一般用于对其他类的一种使用上的包装,不需要实例化直接使用
    object  NetWorkRequestManager{
    fun   register(){
    println( "连接网络注册中...")
    }
    }

    //伴生对象,一般用于创建一个类的实例的"工厂"方法
    //相当于Java中的,静态成员
    class  IDCard{
    companion object  {
    fun   create() = IDCard()
    }
    }
    }

    29、异常错误处理
    {
    /**
    * 异常错误处理
    * 对可能发生执行异常的代码的一种保护措施
    * 默认异常类:Exception
    */
    fun   main(args: Array<String>) {
    //直接展示错误
    try  {
    "333ggg". toInt()
    }   catch  (e: Exception) {
    println(e)
    }
    //忽略错误
    val  a: Int? =   try  {
    "3gg". toInt()
    }   catch  (e: Exception) {
    null
    }
    println(a)
    }
    }

    30、类型检查和转换
    {
    /**
    * 检查:对一个变量的类型进行辨别.
    * 转换:把变量转换成其他类型使用.
    */
    fun   main(args: Array<String>) {
    val  a =   5
    val  b =   6
    val  c =   if  (a > b)   "大于"   else  a - b

    //类型判断:is
    if(c   is  String){
    println( c. length)
    }

    if(c   !is  String){
    println( "整数: $c ")
    }

    //Kotlin编译器大多数时候会智能转换
    if(c   is  Int){
    println( c.inc())
    }

    //手动转换:强制转换as,安全转换 as?
    val  d = c   as  Int
    println( "d是c强制转换后的c,值是 $d ")

    //安全转换失败后返回可空类型的null
    val  e = c   as?  String
    println(e)
    }
    }

    31、为何使用Interface-接口
    {
    /**
    * 接口:interface:接口是方法、属性或一段功能的"蓝本"
    * 仅仅是规定实现的标准(抽象的)
    *
    * 通常用于对类进行附加功能,可以让类本身保持简洁的定义
    * 通过实现1个或N个接口的组合,来实现非继承式的功能增强。
    *
    * 生物界的启示1:动物通常大量生长皮毛或者完全光溜溜,但是人基本上是裸替状态。
    * 人类通过进化,把皮毛功能剥离,从而实现了着装的自由,与动物极大的区分开。
    * 着装让人类可以在任何气候下保持适宜的体温,而不需要靠遗传来维持体温。
    *
    * 启示2:猛兽有尖牙厉爪,可以在捕食大型动物占据优势。但是人类基本没有。
    * 人类通过发明类似尖牙厉爪的工具,同时可以轻松捕获大型动物。
    * 人的后代不仅不需要尖牙厉爪就可以得到大象肉,牛肉,鲸鱼肉。
    *而且人类如此弱体力或弱攻击的物种,居然成了几乎所有动物的噩梦。
    *
    * 这些启示都在明示,继承获得的功能通常是不得已而为之,且进化缓慢,代价高昂。
    * 而且在此基础上通过组合各种功能,可以获得强大的能力同时可以轻装上阵。
    */
    }

    32、接口中的属性
    {
    /**
    * 接口中的属性
    *
    * 接口定义:interface 接口名{ //各种属性或方法定义 }
    */
    //很多外国人入籍
    interface  Livable{
    var   hasSkill  : Boolean
    }

    interface  ChinaLivable{
    //接口中的属性只有类型定义,不可初始化。
    val   hasJobOffer  : Boolean

    //接口中的属性可以有get,通常用于单纯增加一个常量属性:组合属性
    val   visaCategory  : String
    get() =   "工作签证"

    //接口中的变量属性
    var   city  : String
    }
    }

    33、接口中的方法
    {
    /**
    * 接口中的方法
    */
    interface  ChinaLivableA{
    //接口中的方法
    fun   speakChinese()
    //接口中的方法可以有默认实现,通常指该方法是固定不变的。
    fun   handleGuanxi(){
    println( "我知道在中国要非常注重处理人际关系。")
    }
    }

    open class  Person{
    var   name  =   ""
    }
    }

    34、接口的实现和组合
    {
    interface  LivableB{
    val   hasSkill  : Boolean
    }

    interface  ChinaLivableB{

    //接口中的属性只有类型定义,不可初始化。
    val   hasJobOffer  : Boolean

    //接口中的属性可以有get,通常用于单纯增加一个常量属性:组合属性
    val   visaCategory  : String
    get() =   "工作签证"

    //接口中的变量属性
    var   city  : String

    //接口中的方法
    fun   speakChinese()

    //接口中的方法可以有默认实现,通常指该方法是固定不变的。
    fun   handleGuanxi(){
    println( "我知道在中国要非常注重处理人际关系。")
    }

    var   bankDeposite  : Int

    }

    open class  PersonB{
    var   name  =   ""
    }

    //继承父类,并实现多个接口
    class  ForigenChinese : PersonB() ,LivableB ,ChinaLivableB {
    override val   hasJobOffer: Boolean
    get() =   true
    override var   city  =   ""

    override fun   speakChinese() {
    println( "我叫 ${this. name } ,我有HSK一级证书,日常工作生活用中文无障碍。")
    }

    override val   hasSkill: Boolean
    get() =   true

    override var   bankDeposite  =   100000
    }

    fun  main(args: Array<String>) {
    val  tom = ForigenChinese()
    tom. name  =   "汤格林"
    tom. city  =   "上海"

    tom.speakChinese()
    tom.handleGuanxi()

    println(tom. visaCategory)
    println(tom. hasSkill)
    }
    }

    35、泛型
    {
    /**
    * 泛型 Generics
    * 让一个类型能被"广泛"使用,即通用化,称为"泛型"
    * 一般用于函数的参数类型定义,让函数更通用
    */
    fun  main(args: Array<String>) {
    //常用的例子,print和println函数,几乎可放任何类型的参数
    println( 2)
    println( "泛型")
    println( arrayOf( "Swift" , "Kotlin" , "ios" , "Android"))

    //Array,参数也可以是任意类型
    val a =   arrayOf( 1 , 2 , 3)

    //自定义一个泛型函数:<T>,Type的首字母缩写,T代表一个占位符,用尖括号包含
    fun < T> showText(pare:   T){
    println(pare)
    }

    showText( 3)
    showText( "我也是泛型函数")
    }
    }

    36、泛型约束
    {
    /**
    * 泛型约束
    */
    fun  main(args: Array<String>) {

    //有时候系统提供的泛型函数很好
    //求和
    val sum =   arrayOf( 1 3 99 - 2 10245). sum()
    println( "求和为: ${sum } ")

    // val sum2 = arrayOf(1, 3, 99, -2, 10245,99.24).sum()

    //泛型约束:<泛型占位符:类型>
    fun < T:Number>   sum( vararg numbers :   T): Double {
    return numbers. sumByDouble  { it.toDouble()   }
    }
    println(sum( 1 3 99 - 2 10245 , 99.24))

    //多重约束:where,各个约束用逗号分隔,写在函数体之前
    //例子:把数组中大于某个元素(阈值)的部分取出来并升序排列。
    // (99,1,2,-389,88,1024,8888)> (88,99,1024,8888)
    fun < T>   biggerPart(list: Array< T> threhold:   T): List< T>
    where  T:Number   T:Comparable< T>
    {
    return list. filter  { it >= threhold   }. sorted()
    }
    val b =   arrayOf( 1 , 0 , 55 , 99 , 3 ,- 3824 , 666)
    println(biggerPart(b , 3))

    }
    }

    37、扩展
    {
    /**
    * 扩展:对既有的类增加新功能而无需继承该类,即时无法获取其源代码。
    * 主要作用是"立即"为相关的类整体上添加"工具类(Utils)"方法或属性,高效优雅。
    *
    * Kotlin支持:扩展函数,扩展属性。 扩展协议(可能将来版本会支持,Swift中已经实现)
    * 与接收者类中参数、名称都一样的扩展是无效的。
    * 尽量避免与已有的名字重名,如果一定要重名,参数名和类型也要补一样。
    *
    */

    //扩展函数:fun 接受者类型.新扩展函数名(参数类别){ //函数实现 }
    //1、普通函数拓展:整数的平方
    fun Int. square(): Int {
    return this *   this
    }

    //泛型属性拓展
    //1、普通属性扩展。 例子:整数的下一个数字
    val Int. next: Int
    get() =   this +   1

    //泛型属性扩展:数字类型的半径对应的面积:20.3.area, 面积πr2
    val < : Number>   T. area : Double
    get() =   3.141592 *   this.toDouble() *   this.toDouble()

    fun  main(args: Array<String>) {
    println((- 12). square())

    val a =   arrayOf( 1 2 3 99 - 8734)
    println( "系统方法 ${a. max() } ")   //系统方法
    println( "泛型函数拓展方法 ${a. biggest() } ")   //泛型函数拓展

    println( "普通属性拓展测试: ${ 3. next } ")

    println( "求圆的面积: ${ 20.33. area } ")
    }

    //2、泛型函数拓展:取数字型数组中最大的元素
    fun < T> Array< T>. biggest():   T
    where  : Number ,
    : Comparable< T> {
    var biggest =   this[ 0]
    for (i   in  1.. lastIndex) {
    val element =   this[i]
    if (element > biggest) {
    biggest = element
    }
    }
    return biggest
    }
    }



    展开全文
  • 【  15、控制流 { /** * 用来检查和运算各种条件和逻辑的组合,控制App的运行流向. * 循环:for, while 及 循环控制 ...//for:依次操作一个序列(如集合类型)中的每一项,执行次数是可预测的 ...arrayOf(1
    【 

    15、控制流
    {
    /**
    * 用来检查和运算各种条件和逻辑的组合,控制App的运行流向.
    * 循环:for, while 及 循环控制
    * if:二元判断
    * when:细致化判断
    */
    fun main(args: Array<String>) {
    //for:依次操作一个序列(如集合类型)中的每一项,执行次数是可预测的
    val numbers = arrayOf( 1 , 2 , 3 , 4)
    for (number in numbers) {
    // println(number)
    }

    //重复执行:for(a in 1..10){//操作}
    for (a in 1.. 100) {
    // println("重要的事情说100遍。。。。")
    }

    //while:循环执行一系列操作,直到条件不成立,适合执行次数未知的场合
    //Q:1加到多少次,才能加到15050?
    var number = 1
    var times = 0
    var total = 0
    while (total < 15050) {
    total += number ;
    number += 1
    times += 1
    if (total == 5050) {
    break // break 结束整个循环
    }
    }
    println( "加到多少次才能达到要求: ${times } ")

    //循环中的控制:continue 结束本次循环 , break 结束整个循环
    for (number in numbers) {
    if (number == 3) {
    continue //continue 结束本次循环
    }
    // println(number)
    }

    //if:条件判断语句,整个语句本身是一个表达式(可用于简单的二元判断计算)
    var a = 5
    var b = 8
    var result = if (a > b) "大于" else 3
    println(result)

    //when:可对某个变量的大小/范围/表达式/类类型进行判断:筛选判断,其中的条件都是互斥的
    when (result) {
    in 4.. 10 -> { //in:在范围内 !in:不在范围内
    println( "0到10之间")
    }
    /* (9 - 6) -> {
    println("值是3")
    }*/
    18 , 25 , 32 ->{
    println( "值是18,25,32")
    }
    is Int ->{ //is:判断是某类型
    println( "值是Int类型")
    }
    else -> { //以上条件不满足,执行此语句
    println( "未知")
    }
    }
    }
    }

    16、函数
    {
    /**
    * 函数是有名字的一段代码块.
    * 包含参数和返回值(可选),参数可以有moren4值.
    */
    fun add(x: Int , y: Int = 0): Int {
    return x + y
    }

    fun main(args: Array<String>) {
    //F1函数名看文档
    //调用时可打参数名,可读性更好(但调用Java函数无效)
    // val b = add(x = 2,y = 3)
    val b = add( 2 , 3)
    println(b)
    //可变参数调用
    val sum = sum( 1 , 12 , 23 , 45 , 2 , 56)
    println( "可变参数调用返回结果: ${sum } ")
    var a = intArrayOf( 1 , 12 , 23 , 45 , 2 , 56 , 12 , 5 , 20)
    println( "可变参数调用返回结果,参数为数组: ${ sum(*a) } ")
    }

    //可变参数修饰符vararg, 可以直接接收数组
    fun sum( vararg x: Int): Int {
    var total = 0
    for (i in x){
    total += i
    }
    return total
    }
    }

    17、Lambda和高阶函数
    {
    /**
    * 高阶函数:参数或返回值的类型是函数型
    * 函数型:(参数) -> 返回值
    * lambda:一种无名函数的简写 { (参数)-> 函数执行语句 }
    * 其他语言称闭包,即有能力访问其自身范围外的变量
    */
    fun main(args: Array<String>) {
    //高阶函数:描叙任务的结果,而不是使用循环详细推算
    //map:常用于对集合类型的元素类型整体转变
    //其lambda中参数的约定名称为it
    val a = arrayOf( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 12)
    val b = a. map { "第 ${ it } " } //参数是一个函数,此处采用的是闭包
    for (s in b) {
    println(s)
    }
    //排序
    // a.sortBy { }

    //filter:对集合类型进行筛选
    var sum = 0
    /* val c = a.filter { it % 2 == 0 } //闭包可以访问自身范围外的变量
    for (i in c) {
    println("返回筛选后的元素:${i}")
    }*/
    a. filter { it % 2 == 0 }. forEach {
    sum += it
    println(sum)
    }
    //分组
    // a.groupBy { }
    }
    }

    18、面向对象编程简介
    {
    /**
    * 面向对象编程
    * 对某种事物进行抽象化,称为"建模(model)",就是提取生物的基因
    * 一个建模称之为一个类(class),从而简化认知,找到规律
    * 特征和属性:需氧/厌氧,寿命(多方因素影响) -- 变量(属性)
    * 功能和行为:进食,奔跑,睡觉,卖萌 -- 函数(方法)
    * 繁殖:继承和多态
    *
    * 要创建一个具体的生物,必须给予配置参数,即"实例化(instance)"
    */
    }

    19、类定义及构造器
    {
    /**
    * 类定义及构造器
    */
    //快捷定义:class 类名 constructor(属性列表){更多的属性和方法描述}
    //构造器:用来设置类的新实例出厂配置
    //类的定义,如果设置一个类能否被继承,要加open关键字修饰。
    open class Chinese constructor( var sex: Boolean , var region: String) {

    }

    //类的继承,添加了默认属性
    class Shanghainin(sex: Boolean , region: String = "sh") : Chinese(sex , region) {

    }

    //类的继承,无默认属性
    class Sichuanwa(sex:Boolean ,region: String):Chinese(sex ,region) {

    }

    fun main(args: Array<String>) {
    //实例化一个类
    val xioayaoming = Shanghainin( true)
    println( "xioayaoming-sex: ${xioayaoming. sex } --region: ${xioayaoming. region } ")

    val xiaoguojinming = Sichuanwa( true, "四川")
    println( "xiaoguojinming-sex: ${xiaoguojinming. sex } --region: ${xiaoguojinming. region } ")
    }
    }

    20、普通属性和组合属性
    {
    /**
    * 普通属性和组合属性
    */
    //快捷定义:class 类名 constructor(属性列表){更多的属性和方法描述}
    //构造器:用来设置类的新实例出厂配置
    //类的定义,如果设置一个类能否被继承,要加open关键字修饰。
    open class ChineseA constructor( var sex: Boolean , var region: String) {
    //普通属性,与变量定义相似
    var skin = "yellow"

    //组合属性,由其他属性计算而来(get)
    val avgLife : Double
    get(){
    when( this. region){
    "sh"->{
    return 82.4
    }
    "安徽"->{
    return 77.8
    }
    else ->{
    return 77.4
    }
    }
    }

    //组合属性反过来可以影响其他属性(set,可选),this代表实例
    var avgSalary : Int
    get() {
    when ( this. region) {
    "sh" -> {
    return 4900
    }
    "ah"->{
    return 3200
    }
    else -> {
    return 3000
    }
    }
    }
    set(value) {
    when (value) {
    in 4500..Int. MAX_VALUE -> {
    this. region = "sh"
    }
    in 2800.. 3500->{
    this. region = "ah"
    }
    else -> {
    this. region = "other region"
    }
    }
    }
    }
    }

    21、子类中的属性和属性覆盖
    {
    //类的继承,添加了默认属性
    class ShanghaininB(sex: Boolean , region: String = "sh") : ChineseB(sex , region) {
    var dialect = "我港吴侬软语" //子类中新增的属性
    //属性覆盖,父类属性需加open,子类覆盖的属性前要加override
    override var skinb = "shanghaiYellow"
    }

    //类的继承,无默认属性
    class SichuanwaB(sex:Boolean ,region: String):ChineseB(sex ,region){
    var dialect = "四川普通话" //子类中新增的属性
    override var skinb = "sichuanYellow"
    }
    }

    22、方法
    {
    /**
    * 方法
    */
    open class ChineseC constructor( var sex: Boolean , var region: String) {
    //普通属性,与变量定义相似
    open var skinb = "yellow"

    //组合属性,由其他属性计算而来(get)
    val avgLife: Double
    get() {
    when ( this. region) {
    "sh" -> {
    return 82.4
    }
    "安徽" -> {
    return 77.8
    }
    else -> {
    return 77.4
    }
    }
    }

    //组合属性反过来可以影响其他属性(set,可选),this代表实例
    var avgSalary: Int
    get() {
    when ( this. region) {
    "sh" -> {
    return 4900
    }
    "ah" -> {
    return 3200
    }
    else -> {
    return 3000
    }
    }
    }
    set(value) {
    when (value) {
    in 4500..Int. MAX_VALUE -> {
    this. region = "sh"
    }
    in 2800.. 3500 -> {
    this. region = "ah"
    }
    else -> {
    this. region = "other region"
    }
    }
    }

    //方法:厨艺
    fun cook() {
    val menu = arrayOf( "青椒炒肉丝" , "番茄炒蛋" , "紫菜蛋汤")
    val desc = menu. reduce { s1 , s2 -> s1 + ","+ s2 }
    println( "我会 ${desc } ")
    }
    }

    //类的继承,添加了默认属性
    class ShanghaininC(sex: Boolean , region: String = "sh") : ChineseC(sex , region) {
    var dialect = "我港吴侬软语" //子类中新增的属性
    //属性覆盖,父类属性需加open,子类覆盖的属性前要加override
    override var skinb = "shanghaiYellow"
    }

    //类的继承,无默认属性
    class SichuanwaC(sex: Boolean , region: String) : ChineseC(sex , region) {
    var dialect = "四川普通话" //子类中新增的属性
    override var skinb = "sichuanYellow"
    }

    fun main(args: Array<String>) {
    //实例化一个类
    val xioayaoming = ShanghaininC( true)
    // println("xioayaoming-sex:${xioayaoming.sex}--region:${xioayaoming.region}")
    xioayaoming. avgSalary = 3000
    println(xioayaoming. region)
    println(xioayaoming. dialect)
    xioayaoming.cook() //调用方法
    val xiaoguojinming = SichuanwaC( true, "四川")
    // println("xiaoguojinming-sex:${xiaoguojinming.sex}--region:${xiaoguojinming.region}")
    }
    }

    23、方法的覆盖和加成
    {
    /**
    * 方法的覆盖和加成
    */
    open class ChineseD constructor( var sex: Boolean , var region: String) {
    //普通属性,与变量定义相似
    open var skinb = "yellow"

    //组合属性,由其他属性计算而来(get)
    val avgLife: Double
    get() {
    when ( this. region) {
    "sh" -> {
    return 82.4
    }
    "安徽" -> {
    return 77.8
    }
    else -> {
    return 77.4
    }
    }
    }

    //组合属性反过来可以影响其他属性(set,可选),this代表实例
    var avgSalary: Int
    get() {
    when ( this. region) {
    "sh" -> {
    return 4900
    }
    "ah" -> {
    return 3200
    }
    else -> {
    return 3000
    }
    }
    }
    set(value) {
    when (value) {
    in 4500..Int. MAX_VALUE -> {
    this. region = "sh"
    }
    in 2800.. 3500 -> {
    this. region = "ah"
    }
    else -> {
    this. region = "other region"
    }
    }
    }

    //方法:厨艺
    open fun cook() {
    val menu = arrayOf( "青椒炒肉丝" , "番茄炒蛋" , "紫菜蛋汤")
    val desc = menu. reduce { s1 , s2 -> s1 + "," + s2 }
    println( "我会 ${desc } ")
    }
    }

    //类的继承,添加了默认属性
    class ShanghaininD(sex: Boolean , region: String = "sh") : ChineseD(sex , region) {
    var dialect = "我港吴侬软语" //子类中新增的属性
    //属性覆盖,父类属性需加open,子类覆盖的属性前要加override
    override var skinb = "shanghaiYellow"
    }

    //类的继承,无默认属性
    class SichuanwaD(sex: Boolean , region: String) : ChineseD(sex , region) {
    var dialect = "四川普通话" //子类中新增的属性
    override var skinb = "sichuanYellow"
    //方法的覆盖,要加override并且父类方法加open修饰
    override fun cook() { //加成,在父类原有的基础上有所发展,叫多态。
    super.cook() //继承父类的方法
    val menu = arrayOf( "麻婆豆腐" , "重庆毛血旺" , "诸葛烤鱼")
    val desc = menu. reduce { s1 , s2 -> s1 + "," + s2 } //将数组合成字符串
    println( "我还会 ${desc } ")
    }
    }

    fun main(args: Array<String>) {
    //实例化一个类
    val xioayaoming = ShanghaininD( true)
    // println("xioayaoming-sex:${xioayaoming.sex}--region:${xioayaoming.region}")
    xioayaoming. avgSalary = 3000
    println(xioayaoming. region)
    println(xioayaoming. dialect)
    xioayaoming.cook() //调用方法
    val xiaoguojinming = SichuanwaD( true, "四川")
    // println("xiaoguojinming-sex:${xiaoguojinming.sex}--region:${xiaoguojinming.region}")
    xiaoguojinming.cook()
    }
    }

    24、可见性修饰符
    {
    /**
    * 可见性修饰符
    * 设定类本身及其属性,方法,构造器
    * 以及接口和对象的对外的访问权限,即"可见性"
    *
    * 举个例子:生物都有内脏,这个"内"其实就是私有属性
    * private 私有:仅当前类可见,最小的可见性
    * protected 保护:仅子类可见
    * internal 内部:当前模块内可见
    * public 公开:*默认,对外完全可见
    */
    }

    25、嵌套类
    {
    /**
    * 嵌套类
    */
    //新闻类
    class News{
    //默认地区
    private var lang = "cn"

    //新闻分类:嵌套类 与主类关系并不是十分紧密,只是一个形式上的合作,主从关系。
    class Category{
    var list = arrayOf( "推荐" , "娱乐" , "体育" , "科技" , "美女")
    val listDesc = list. joinToString() //将数组转成一个逗号分隔的字符串
    }

    //内部类:新闻语种. 通常用于不直接对外的类,为主类服务的。
    inner class Lang{
    fun changeRegion(newRegion : String){
    //内部类可以访问主类的属性
    lang = newRegion
    println( "现在可以查看 ${newRegion } 地区的新闻了!")
    }
    }
    }

    fun main(args: Array<String>) {
    //显示中国地区的新闻列表. 使用嵌套类
    println(News.Category(). listDesc)

    //更改新闻地区,内部类的调用:内部类必须依赖主类的实例,再加上自身的实例才能使用。
    News().Lang().changeRegion( "us")
    }
    }

    展开全文
  • 一直觉得自己的技术在部门内还算不差,而最近在技术群里和一群热衷于技术研究,热爱技术,将技术成为自己生活的一部分的人的沟通中,发现自己的弱小无知。同年甚至更小的程序员,已经写了不下几十篇的博客,讲起各种...
  • IPv4:网际协议,版本4。IPv4(我们通常称之为IP)使用32位的地址。IPv4给TCP,UDP,ICMP和IGMP提供递送分组的服务。 ...IPv6:网际协议,版本6。...主要变化是使用128位的大地址已处理因特网络爆发性的增长。...
  •  任何一门技术的出现不是凭空出现的,出现一定是为了解决存在的某种问题。 WCF出现的目的 实现计算机之间的通信和交互,使得计算机之间的通信标准能达成一致。比如:计算机A说:计算机B啊,把你的那个方法让我用...
  • 单片机编程技术学习攻略 学习与应用单片机的高潮正在工厂、学校及企事业单位大规模地兴起。过去习惯于传统电子领域的工程师、技术员正面临着全新的挑战,如不能在较短时间内学会单片机,势必会被时代所遗弃,只有...
  • 就是前面我们讲的文章“一步一个脚印学习WCF之WCF概要—WCF服务的创建与调用HelloWorld实例,通过编码方式(四)”一文中的IHelloWorldService,它与其他分布式技术最显著的区别是耦合性是基于契约的,不是基于代码...
  • 学习都是有一个过程的,不管是学习什么内容,都是有好奇时期—兴趣大—认真学习—遇到阻力沮丧—回头细想理性对待。(1)要根据自己的特长去决定自己学习MAX和应用MAX的目标。譬如,你的主业是建筑行业,熟悉建筑,...
  • 学习技术的过程中就是要一步一个脚印,总有一天会豁然开朗,不知不觉的发现所有知识都串起来了,一件很神奇的事情 持续学习,哪怕每天只有一点点
  •  WCF全称叫做Windows Communication Foundation(Windows 通信 基础),从全称可以看到是为我们提供基于Windows平台下关于通信方面的一个基础架构,利用这个WCF我们能够实现基于Windows平台下的各种通信技术的开
  • 就是说作为我们开发人员来说,我们在解决不同的问题要学习不同的技术,这样无疑为了我们增加了学习量,WCF的出现统一了各种不同的开发模型,使得我们在一个统一的编程模型当中来使用不同的技术去解决不同应用中的...
  • 阅读目录  一:前言  二:WCF出现的目的是什么?  三:学了WCF能做什么?  四:为什么要把一个应用程序分布放在不同的... 任何一门技术的出现不是凭空出现的,出现一定是为了解决存在的某种问题  二...
  •  客户端与服务端之间所共享的或者所耦合的信息应该是Contract契约,就是之前提到的interface,它与其他的分布式的技术最显著的区别是基于Contract的耦合而不是基于代码的耦合,由于在契约当中不包含具体的服务逻辑...
  • 为了简化这些选项,使它们易于管理,开发人员不必在这方面煞费苦心,所以WCF引入了绑定(Binding)技术,将这些通信选项组合在一起,一个绑定封装了:消息通信模式,传递消息的传输协议,消息的安全性等一系列相关...
  • 技术有几年了,发现自己彻底爱上了这份职业,虽然有很多人说程序员不适合女孩子干,有时跟群里一些网友讨论有点难度的技术时,别人会说小姑娘搞什么编程,但只有我知道,我是多么喜欢编程,喜欢做设计,喜欢把...
  • 脚踏实地,一步一个脚印

    千次阅读 2008-03-23 12:49:00
    心比天高,命却比那楼房高不了多少!... 我们有太多需要学习,需要改变的. 理想是要靠能力能实现的,一个人的能力决定了一个人能做多大的事情. 然而刚刚出来的时候大多是抱着梦想,而不抱着能力,抱着学习教科书的能力
  • 新的技术 webworker, websocket, Geolocation; 移除的元素: 纯表现的元素:basefont,big,center,font, s,strike,tt,u; 对可用性产生负面影响的元素:frame,frameset,noframes; * 支持 HTML5 新...
  • 一位资深 架构师大牛给予Java技术提升的学习路线建议对于工作多年的程序员而言,日后的职业发展无非是继续专精技术、转型管理和晋升架构师三种选择。架构师在一家公司有多重要、优秀架构师需要具备怎样的素质以及...
  • 今天学习了cs,我从计算机导论开始学习,从框架开始学习一步一个脚印学习,我承认自己拿不到图灵奖,但是我不会放弃这个初心,从数制进制到计算。从电脑硬件概论。到系统学习。我一步一步向前进。 ...
  • @WebServlet(description = "学习Servlet创建的", urlPatterns = { "/Home/FirstServlet" }, initParams = { @WebInitParam(name = "userName", value = "abc", description = "用户姓名") })  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,257
精华内容 2,102
关键字:

技术学习一步一个脚印