ios学习笔记（一）包括类和对象的初始化

**

ios上课学习

**
2018-9-6
ios初步的语法简介和相关类型

//: Playground - noun: a place where people can play

import UIKit

//可以用let或者var定义
let label = "The width is"
//用\()可以将数据转换成字符串
//补码在计算机负数总比证书多一个数
//元祖tuple
  //远足可以分解，可以用下标访问元组中每个值
    let amount = (100,"eur")
    let currency = amount.1
  //元组可以给每个元素命名
    let mon = (amount:100,currency:"eur")
    let cur = mon.currency
  //元组分解可以指分解部分值，其他值用_代替
    //let (cur,_) = mon
//swift没有++，--，for，一律用for..in代替,in后是可以放任何有顺序的，if后没有圆括号，且条件必须是bool值的
let ind = [56,76,87,98]
for score in ind {
    print(score)
}
//===，！==判断是否是同一个应用对象，或者是位置
//字典key-value,最后一个元素后面允许有个逗号
var occupations = [
    "ma":"ca",
    "ka":"ner",
]
occupations["ja"] = "pu"
//空数组
let emptyArray = [String]()
//空字典
let e = [String:Float]()
//元组(元组的作用)
var x = 1, y = 2
print("x=\(x) y=\(y)")
(x,y) = (y,x)
print("x=\(x) y=\(y)")
//字典的访问快，但是顺序和放入的顺序不同，因为是哈希表，数组访问速度很慢，元组可以同时存多类型的元素，并且个数固定，不可增加删除，一般适合少量数据
//switch
var age = 60
switch age {
case let x where x < 18:
    print("少年")
default:
    print("其他")
}
//函数(_空标签，否则要加上参数名)
func greet(_ person:String,_ day:String) -> String{
    return "hello \(person) on \(day)"
}
var m = greet("jfa","28193")

func add(x:intptr_t,y:intptr_t) -> intptr_t {
    return x+y
}
var r = add(x: 1, y: 2)

print(r)
//..<不包括上界，...包括上界


//可选值
var k:String? = "hello world"
print(k)
var str:String = ""
if k != nil {
    str = k!
}

//函数可以嵌套,函数是一等公民，可以做很多事情，还可以作为函数的返回值,最外层的返回值是被返回的函数的参数和返回值类型
func ma() -> ((intptr_t) -> intptr_t){
    var number = 0
    func addone(number:intptr_t) -> intptr_t{
        return 1+number
    }
    return addone
}
//函数可以作为参数
//闭包，函数是有名字的闭包，还有一种没有名字的闭包（匿名函数）
var primes = [Int]()
for i in 2...100 {
    var isPrime = true
    for j in 2.. Bool {
    return one > two
}
primes.sort(by: compare(one:two:))

primes.sort(by: compare)
primes.sort(by: {
    (one:Int,two:Int) -> Bool in
    return one > two
})
primes.sort(by: {
    (one,two) in one > two
})
primes.sort(by: { $0 < $1 })
primes.sort { $0 < $1 }
primes.sort(by: >)

print(primes)

数组例题（数组排序）

//例题
var primes = [Int]()
for i in 2...100 {
    var isPrime = true
    for j in 2..Bool{
		return n1>n2
}
primes1.sort(by:compare(n1:n2:))*/

//方法二
/**
func compare(n1:Int,n2:Int)->Bool{
		return n1>n2
}
primes1.sort(by:compare)*/

//方法三
/**
primes1.sort(by:{
	(one:Int,two:Int) -> Bool in
	return one>two
})*/

//方法四
/**
primes1.sort(by:{
	(one,two) in return one>two
})*/

//方法五
/**
primes1.sort(by:{
	(one,two) in one>two
})*/

//方法六
/**
primes1.sort(by:{$0>$1})*/

//方法七
primes1.sort(by:>)

print(primes1)

ios中的类和对象
<注意>
1.系统要求存储属性必须初始化
2.可选值可以不初始化,默认将设置为nil
3.如果非可选类型存储属性不设置默认值,则必须在初始化方法中对其进行初始化
4.类必须自己写初始化方法,用来初始化没有默认值的非可选存储属性
5.结构体系统默认会添加初始化方法,也可以自定义
6.子类如果没有自己的初始化方法,系统默认使用父类的初始化方法,一旦有了自己的初始化方法,或者重写了父类的初始化方法,则父类的所有初始化不能被子类调用
7.可以给子类添加和父类相同的初始化方法,但需要加上override 修饰
8.重写父类的convenience修饰的便利初始化方法,不需要加override
9.用self来区分参数和实例变量
<类的初始化>

• 使用init来创建一个构造器步骤
• 1、设置子类声明的属性值 2、调用父类的构造器 3、改变父类定义的属性值，其他的工作比如调用方法、getters和setters也可以在这个阶段完成

  class Person{
      var firstName:String
      var lastName:String
      var age:Int
      var gender:Gender
      var fullName:String{
          get{
              return firstName+" "+lastName
          }
      }
       init(firstName:String,lastName:String,age:Int,gender:Gender){
          self.firstName = firstName
          self.lastName = lastName
          self.age = age
          self.gender = gender
      }
      convenience init(name:String) {
          self.init(firstName:name,lastName:"",age:18,gender:Gender.male)
      }
      var description:String {
          return "Name:\(fullName) Age:\(age) Gender:\(gender)"
      }
  }
  

• 子类的定义

• class Student: Person{
      var grade:Int
      init(firstName:String,lastName:String,age:Int,gender:Gender,grade:Int){
              self.grade = grade
          super.init(firstName:firstName,lastName:lastName,age:age,gender:gender)
      }
      convenience init(name:String) {
          self.init(firstName:name,lastName:"",age:18,gender:Gender.female,grade:60)
      }
      override var description:String {
          return super.description + " grade:\(grade)"
      }
  }
  

• 对象的创建和类的使用

• let p1 = Person(firstName:"li",lastName:"guiyang",age:43,gender:Gender.male)
  let p2 = Person(name:"gaoyuexiang")
  print(p1.description)
  print(p2.description)
  
  let s1 = Student(name:"fan")
  print(s1.description)
  

• 最后的呈现效果
•  属性可以有 getter 和 setter，这称之为计算属性 计算属性 (闭包) 不直接存储值，而是提供一个 getter 来获取值，一个可选的 setter 来间接设置其他属性或变量的值(即：计算属性可以根据所设置内容，进行一些修改或计算) (Person类的属性)

  var per:String {
  		get{
  			return "Name:\(fullName) Age:\(age) Gender:\(gender)"
  		}
  		set{
  			firstName = newValue;
  		}
  	}
  print(p1.per);
  p1.per = 'tan'
  

  类的初始化器
  1.指定初始化器（至少有一个，它会将类中所有的属性赋值初始化，并且一路往上调用类的父类的指定初始化器去初始化它们各自引入的属性
  ）
  2.便利初始化器（可以没有，不能被子类重写或从子类中以super的方式被调用）
  初始化器调用规则：
  1、子类的指定初始化器必须要调用父类的指定初始化器
  2、便利初始化器必须调用同一类中定义的其他指定初始化器
  3、便利初始化器必须最终以调用一个指定初始化器结束
  
  3.required关键字
  
  4.可失败构造器（init初始化方法可以通过在init关键字后面加上?或!将其变为可失败初始化方法，表示某对象的初始化过程可能失败，并返回 nil）

  【未带完序…】

  ---

  尴尬的分界线
  **
  2018-9-6
  as与is
  as用来类型转换，如果不确定是否成功，可以在其后加？

  any
  any类型表示这个可以存任何类型，包括闭包

  struct和class
  //struct是传值的，且没有构造函数，类是传引用(如果发生赋值，那么一个类变了，原来的那个也变，受影响，但是传值不会影响)

  struct Student{
      var name:String
      var age:Int
  }
  var s1 = Student(name:"tjw",age:20)
  print(s1.name)
  

  //除了class和闭包都是值类型
  //最好尽量避免引用，只要一个引用有强引用（相互引用）那么会变成垃圾，造成内存泄漏，可以用weak声明为弱引用（弱引用是optional，释放后变为nil），内存中所有对对象的引用都是强引用

  闭包中的循环引用
  //闭包中的循环引用，闭包只要用到变量肯定是强引用，在var前加lazy表示暂时不构造，但是释放还是没完全释放，因此最好还要在{后面加[weak self] in。。。。

  lazy var printname:()->()={
      [weak self] in
      if let strongSelf = self{
          print("kdsjlflk")
      }
  }
  

  协议
  //协议有点像接口，类来实现协议，类必须有协议中的属性
  /**
  class Person: CustomStringConvertible这个就是一个协议，可以直接print(p1)
  */
  print(p1)
  //协议还可以作为一个类的属性

  扩展
  //扩展，是向一个已有的类，结构体，枚举类型添加新的功能
  //添加长度单位double属性

  extension Double{
   var km:Double{
       return self*1_000.0
   }
      var m:Double{
          return self
      }
  }
  let kmTest = 10.5.km
  print(kmTest)
  

  泛型
  //泛型：协议和比较两个数大小的函数

  func isEqualInt(a:Int,b:Int) -> Bool{
      return(a==b)
  }
  func isEqualString(a:String,b:String) -> Bool{
      return (a==b)
  }
  

  //写一个比较两个数大小的通用函数(一个顶三)

  func isEquals(a:T,b:T)->Bool{
      return (a == b)
  }
  print(isEquals(a: 1, b: 2))
  print(isEquals(a: "fad", b: "fad"))
  

  补充
  //guard如果guard是真就不执行，与if相反，

  guard let x = someOptional else{
      return
  }
  print(x)
  

  //defer读取牟文件内容并处理数据，首先打开文件夹，读取文件内容，处理数据，关闭文件以及文件夹，不会调这句话，函数整体推出后，才调用defer后面的语句

  func doSomething(){
      openDirectory()
      defer{closeDirectory()}
      openFile()
      defer{closeFile}
  }
  

  //final 表示不能被继承，使用final声明的属性，方法和下标不能被重写

  final class Person{}
  

  //构造与析构：构造函数名为init，析构为denit

  //访问范围：模块，源文件
  //权限：private,fileprivate:只要一个文件就可以访问，internal:（只能被模块内部访问）默认的，写的app所有都可以访问，public:代码可以被任何人访问，可以被外面访问，且只能用，不能派生，open:可以被任何人使用和派生

  //一些函数使用

  var numbers = [1,3,5,4,7,5,23,56,76]
  numbers.sort{ $0 > $1}
  print(numbers)
  var evens = numbers.filter { $0 % 2 == 0 }
  print(evens)
  var strNumbers = numbers.map { String($0) }
  //var strNumbers = numbers.map { "\($0)" }
  print(strNumbers)
  var sum = numbers.reduce(0,{ $0 + $1 })
  print(sum)
  var sqartsum = numbers.reduce(0,{ $0 + $1*$1 })
  

  2018.9.19
  git commit -am ‘第三次提交’
  git checkout
  git checkout – 名字
  git reset–hard HEAD//硬复制一份到
  //建分支
  git branch 分支名
  //强制切换分支
  git checkout -f second
  git checkout -f master

  补充