Swift3.0 - 对象和类

学习什么

1.类的定义 2.属性定义 3.类的方法创建 4.对象方法定义 5.初始化 6.类的释放 7.给类添加协议 8.继承 9.重写

  • 如何定义一个类
class Shape {
   var numberOfSides = 0 // 属性
    // 对象方法
   func simpleDescription() -> String {
      return "A shape with \(numberOfSides) sides."
   }
  // 类方法
  class func shapeDescription()->String{
      return "我是一个定义形状的类"
  }
}
  • 初始化
class NamedShape {
var numberOfSides: Int = 0
var name: String
// 注意初始化前面没有func
init(name: String) {
    self.name = name
}
}
  • 继承
class NamedShape{
  var name:String
  var numberOfSides:Int?
  init(name:String) {
      self.name = name
  }
}

class Square: NamedShape {
  var sideLength: Double
  init(sideLength: Double, name: String) {
      self.sideLength = sideLength
      super.init(name: name)
      numberOfSides = 4
  }
}
  • 计算属性setter和getter
class Circle{
  var area: Double = 0.0
  var r:Double {
      set{
         area = newValue*newValue*3.1415926
      }
      get{
          return sqrt(area/3.1415926)
      }
  }
}
  • 监测属性willSet和didSet,顾名思义,就是用来检测属性值的变化
class Circle{
    // 监测面积的变化,修改半径
  var area: Double = 0.0 {
    willSet{
        r = sqrt(newValue/3.1415926)
    }
}
// 检测半径的变化修改面积的值
var r:Double = 0.0 {
    willSet{
        area = newValue*newValue*3.1415926
    }
}
}

运行会报错,因为循环监测了,这个编译不会出错的,所以不用在两个基本类型之间相互监测,两个对象之间是可以的

  • 添加协议
  // 协议 1
  protocol LoveMusic{
    func songMusic()

  }
   // 协议2
  protocol Draw{
      func draw()
  }
   // 给类添加协议
  class Student:LoveMusic,Draw{
    var name = "小明"
    func addMusic(name: String) {
        music = name
    }
    func draw() {
        print("会画画")
    }
    func songMusic() {
        print("会唱歌");

    }
  }
  • 重写

1.重写计算属性 2.重写对象方法 3.重写类方法 4.重写初始化方法 5.重写存储属性(只能扩展监测,不能重写值)

定义父类

class Person{
    var name:String
    var rename:String{
        return self.name
    }
    init(_ name:String) {
        self.name = name
    }
    func describe() -> String {
        return self.name
    }
    class func describeClass()->String{
        return "这是一个描述人的类"
    }
}

重写父类

class Man:Person{
    var score:Double
    // 重写计算属性
    override var rename: String{
        set{
            self.name = newValue
        }
        get{
            return self.name
        }
    }
    // 重写初始化
    override init(_ name: String) {
        self.score = 0.0
        super.init(name)
    
    }
    // 重写对象方法
    override func describe() -> String {
       return self.name + "\(self.score)"
    }
    // 重写类方法
    override class func describeClass() -> String {
        return "我是描述男人的类"
    }
    }

重写存储属性例子,重写后,它的初始化的值依然是父类的初始化的值

class AutomaticCar: Car {
override var currentSpeed: Double {
    didSet {
        gear = Int(currentSpeed / 10.0) + 1
    }
}
}

重写计算属性例子

class Car: Vehicle {
    var gear = 1
    override var description: String {
        return super.description + " in gear \(gear)"
    }
}

重写下标方法

override subscript (index:Int)->Int{
    return Int(self.score)
}

注意:

  1. 重写计算属性的时候,只能增加功能,不能减少功能,比如父类的计算属性为(set get) 重写的话,只能全部重写,但是如果父类只有get方法,可以给子类增加set功能
  2. 重写监测属性,不能有初始化的值

问题:怎么才能不让重写计算属性,下标,方法,或者不让继承

使用关键字final

  • 类型检测

a.is 的使用

class Person {
}

class Teacher:Person{
    var name:String
    init(name:String) {
        self.name = name
    }
}
let teacher = Teacher(name: "酷走天涯")
var persons:[Any] = []
persons.append(teacher)

for person in persons{
    // 检测类型
    if person is Teacher{
        print("我是Teacher")
    }
    if person is Person{
        print("我是Person")
    }
}

b.as? 的使用

for person in persons{
// 检测类型
if let p = person as? Teacher{
    print("我是Teacher")
}
if let p = person as? Person{
    print("我是Person")
}
}

c.as! 的使用

let teacher:Any = Teacher(name: "酷走天涯")
let p = teacher as! Person

注意:

一旦teacher 不是Person 类型或者它的子类,系统就会报错

建议使用

let p = teacher as? Person

d.更多应用请看下面代码

for thing in things {
switch thing {
case 0 as Int:  // 如果值等于0 请检测是不是Int
    print("zero as an Int")
case 0 as Double:// 和上面类型
    print("zero as a Double")
case let someInt as Int: // 模式匹配上面的值,检测是不是Int
    print("an integer value of \(someInt)")
case let someDouble as Double where someDouble > 0:// 模式匹配上面的值 检测是不是double 并且判断它是不是大于0
    print("a positive double value of \(someDouble)")
case is Double: // 检测是不是double类型
    print("some other double value that I don't want to print")
case let someString as String: // 模式匹配是不是String类型
    print("a string value of \"\(someString)\"")
case let (x, y) as (Double, Double): // 模式匹配是不是元组类型,并且检测数据类型
    print("an (x, y) point at \(x), \(y)")
case let movie as Movie:
    print("a movie called \(movie.name), dir. \(movie.director)")
case let stringConverter as  (String) -> String:
    print(stringConverter("Michael"))
default:
    print("something else")
}
}

注意事项

1.对象中的所有变量或者常量在定义时如果不初始化,在对象初始化的时候,必须初始化,这个是swift安全性考虑,可选类型没有强制性要求初始化,因为系统默认给可选类型初始化为nil

2.初始化顺序

1.首先在自己的初始化方法中先给自己的属性初始化 2.然后调用父类的初始化 3.最后修改父类的属性

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏从流域到海域

Python dict(字典)

Python dict即字典,是一种非常有用的数据结构,相当于其他语言的Map,这种数据结构采用键值对(key-value)形式存储,具有非常快的查询速度...

46490
来自专栏Vamei实验室

Python补充03 Python内置函数清单

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。 Python内置(built-in)函数随着py...

20860
来自专栏用户2442861的专栏

Python中dict详解

#字典的添加、删除、修改操作 dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "ora...

25710
来自专栏土豆专栏

Java面试之数据类型(一)

封装类是引用类型,基本类型在传递参数的时候都是按值传递,而封装类型是按引用传递的(其实引用也是按值传递的,但是传递的是对象的地址)

22320
来自专栏Rovo89

JavaScript闭包与箭头函数

11820
来自专栏desperate633

LintCode 移动零题目分析

给一个数组 nums 写一个函数将0 移动到数组的最后面,非零元素保持原数组的顺序

9020
来自专栏极乐技术社区

使用ES6新特性开发微信小程序(2)

Template Literals(模板对象) ES6中的模板字符串(Template String)是一种能在字符串文本中内嵌表达式的字符串字面量(Strin...

35660
来自专栏coding for love

JS原生引用类型解析2-Array类型

(注1:如果有问题欢迎留言探讨,一起学习!转载请注明出处,喜欢可以点个赞哦!) (注2:更多内容请查看我的目录。)

14120
来自专栏河湾欢儿的专栏

第五节正则

9620
来自专栏前端知识分享

第203天:js---Array对象常用方法

10520

扫码关注云+社区

领取腾讯云代金券