// 如果没用返回值,Void可以写成()
func run1() -> () {
    print("I am running")
}
// 如果没有返回值,后面的内容可以都不写
func run2() {
    print("I am running")
}

// 调用函数
run2()

// 2.有参数,没用返回值
func callPhone(phoneNum : String) {
    print("打电话给\(phoneNum)")
}
callPhone("10086")

// 3.没用参数,有返回值
func greetings() -> String {
    return "吃饭了吗?"
}
var str1 = greetings()
print(str1)

// 4.有参数,有返回值
func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}
var result = sum(20, num2: 30)
print(result)

• // 默认情况下,从第二个参数开始,参数名称既是内部参数也是外部参数
  func calculate(num1 : Int, num2 : Int, num3 : Int) -> Int {
      return num1 * num2 * num3
  }
  var result1 = calculate(20, num2: 4, num3: 5)

  // 如果第一个参数也想要有外部参数，在变量名前加标签即可，如果不想要，在参数名前加 _
  func calculate1(myNum1 num1 : Int, _ num2 : Int, num3 : Int) -> Int {
      return num1 * num2 * num3
  }
  var result2 = calculate1(myNum1: 20, 4, num3: 5)

  // 方法的重载:方法名称相同,但是参数不同,可以称之为方法的重载
  func calculate(num1: Int, _ num2 :Int) -> Int {
      return num1 * num2
  }
  var result3 = calculate(20, 20)

• func makecoffee(type :String = "卡布奇诺") -> String {
      return "制作一杯\(type)咖啡。"
  }
  print(makecoffee("拿铁"))
  print(makecoffee())
  制作一杯拿铁咖啡。
  制作一杯卡布奇诺咖啡。

• func sum(numbers:Double...) -> Double {
      var total: Double = 0
      for number in numbers {
          total += number
      }
      return total
  }

  sum(100.0, 20, 30)
  sum(30, 80)

• // 函数一:值传递
  func swap(var a : Int, var b : Int) {
      let temp = a;
      a = b;
      b = temp  
      print("a:\(a), b:\(b)")
  }

  var a = 10
  var b = 20
  swap(a, b: b)
  print("a:\(a), b:\(b)")
  a:20, b:10
  a:10, b:20

  // 函数二:指针的传递
  func swap2(inout m : Int, inout n : Int) {
      let temp = m
      m = n
      n = temp
      print("m:\(m), n:\(b)")
  }
  var m = 10
  var n = 20
  swap2(&m, n: &n)
  print("m:\(m), n:\(n)")
  m:20, n:20
  m:20, n:10

• let value = 55
  func test() {
      func demo() {
          print("value \(value)")
      }
      print("test")
      demo()
  }

  //demo() // 错误
  test()
  test
  value 55

var person = Person()

person.age = 20          // 直接通过点运算符读写

person.name = "Siri"

print("person的名字是\(person.name), person的生命是\(person.life), person的年龄是\(person.age)")

• //  注意：计算属性的值是不固定的，只能声明为变量，不能使用let
  class Square {
      var width: Double = 0   // 边长
      var girth: Double {     // 周长 
          get {  
              returnwidth * 4 
              }
          set {               // 默认有一个newValue 的值 
              width = newValue / 4
              }
          }
      }
  var square = Square()
  square.width = 10
  print(square.girth)   // 调用 girth 属性的 get，输出结果是40
  square.girth = 200
  print(square.width)   // 调用 girth 属性的 set，并且把200传递给 newValue，输出结果是 50
• // 注意：一个属性不能既是存储属性有事计算属性
  // 只读计算属性：只有get方法，没有set方法
  class Square3 {  
      var girth: Double {   // 周长 
          get {  
              return40  
          }
      }
  }

  //也可以简写成：
  class Square4 {
      var girth: Double {   // 周长 
          return40
      }
  }

• // 类型属性：用类来访问的属性，用class关键字修饰的属性，也可以称为“类属性” 。
  // 特点：一个类只会有一份，类的多个实例对象都共享这唯一的一份。
  // 使用：类型属性不依赖于对象而存在，用类名来访问。
  // 注意：class修饰的类型属性只能是计算属性，不能是存储属性。
  class Circle {
      classvar PI: Double {// 所有用到的PI的值都是一样的，可以写成类属性
          return3.14  
      }
  }
  print("圆周率 = \(Circle.PI)")

• // 属性监视器
  //可以监视属性值的修改过程。需要在属性值被修改的时候做出响应的情况可以用属性监视器。计算属性可以在set方法中监听，而存储属性没有set，可以为存储属性添加willSet和didSet两个属性监视器。
  class Square5 {
      var width: Double = 0.0 {
           willSet {// willSet 有 newValue
               print("willSet---new=\(newValue), current=\(width)")
           }
           didSet {// oldSet 有 oldValue 
               print("didSet---old=\(oldValue), current=\(width)")
           }
       }
   }
• var square5 = Square5()
  square5.width = 10.0
  willSet---new=10.0, current=0.0
  didSet---old=0.0, current=10.0

• //注意：willSet和didSet在属性初始化过程中不会被调用，只会当属性的值在初始化之外的地方被设置时被调用。也就是在声明时不会引发willSet和didSet的调用
  //如果在didSet方法中修改了属性的值，就不会再引发didSet的调用，也就不会循环引用。
  class Square6 {
      var width: Double = 0.0 {
          willSet {
          }
          didSet {
              width = 80
          }
      }
  }

  var square6 = Square6()
  square6.width = 40
  print("width=\(square6.width)")  // 打印：width=80.0