1.同java一致,使用class
和类名来创建一个类。
2.使用init
创建一个构造方法,使用deinit
创建一个析构方法,通过构造方法来初始化类实例。创建类实例同java一致,在类名后面加上()(实际是调用无参数的构造方法init(),构造方法也可以带参数)。使用.来访问实例的属性和方法。
class NamedShape { var numberOfSides: Int = 0//每个属性都需要初始化一个值——无论是通过声明(就像numberOfSides)还是通过构造器(就像name)。 var name: String init(name: String) { self.name = name//self同java中的self,隐示参数,表示类实例 } func simpleDescription() -> String { return "A shape with \(numberOfSides) \(name) sides." } } var namedShape = NamedShape(name: "popkidorc") namedShape.simpleDescription()//A shape with 0 popkidorc sides.
3.子类的定义方法是在它们的类名后面加上父类的名字,用:分割。创建类的时候可以忽略父类。子类如果要重写父类的方法的话,需要用override
标记(与java不同,若没有添加override
就重写父类方法的话编译器会报错,编译器同样会检测override
标记的方法是否确实在父类中)。
class Square: NamedShape { var sideLength: Double init(sideLength: Double, name: String) { self.sideLength = sideLength super.init(name: name) numberOfSides = 4 } func area() -> Double { return sideLength * sideLength } override func simpleDescription() -> String { return "A square with sides of length \(sideLength)." } } let test = Square(sideLength: 5.2, name: "my test square") test.area()//27.04 test.simpleDescription()//A square with sides of length 5.2.
4.类的属性可以有getter和setter,如果不需要计算属性,但要在设置一个新值之前或之后运行一些代码,使用willSet
和didSet
。
class EquilateralTriangle: NamedShape { var sideLength: Double = 0.0 init(sideLength: Double, name: String) { self.sideLength = sideLength//设置子类声明的属性值 self.area = sideLength*1.732/2 super.init(name: name)//调用父类的构造器 numberOfSides = 3//改变父类定义的属性值。 //其他的工作比如调用方法、getters和setters也可以在这里执行。 } var perimeter: Double { get { return 3.0 * sideLength } set { sideLength = newValue / 3.0//新值的名字是newValue } } var area: Double { willSet{ println("an new value \(newValue)") } } override func simpleDescription() -> String { return "An equilateral triagle with sides of length \(sideLength)." } } var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle") triangle.perimeter//9.3 triangle.perimeter = 9.9 triangle.sideLength//3.3 triangle.perimeter//9.9 triangle.area//2.6846
5.方法的参数名除了第一个外,都需要在调用的时候显式说明。方法的参数名默认和它在方法内部的名字一样,也可以定义另一个名字,在方法内部使用。
class Counter { var count: Int = 0 func incrementBy(amount: Int, numberOfTimes times: Int) { count += amount * times } } var counter = Counter() counter.incrementBy(2, numberOfTimes: 7)//14
6.操作可选值变量时,可以再在操作(比如方法、属性和子脚本)之前加?。
如果?
之前的值是nil,
?
后面的东西都会被忽略,并且整个表达式返回nil
。否则,?
之后的东西都会被运行。在这两种情况下,整个表达式的值也是一个可选值。
let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square") let sideLength = optionalSquare?.sideLength//操作前加?
1.使用enum
来创建一个枚举。和类一样,枚举可以包含方法。使用case声明枚举成员。
2.枚举的成员还可以设置默认值(当然可以不用设置,默认从0开始的整数,0、1、2),我们叫原始值,这些值的类型是相同的,并且设置了为第一个成员的原始值后,剩下成员的原始值会按照顺序赋值。通过toRaw
方法获取成员的原始值,fromRaw
方法尝试通过原始找到枚举成员(若找不到则为nil)。
enum Rank: Int { case Ace = 1 case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten case Jack, Queen, King func simpleDescription() -> String { switch self { case .Ace://枚举成员使用缩写.Ace来引用,因为已经知道self的值是一个Rank。已知变量类型的情况下可以使用缩写。 return "ace" case .Jack: return "jack" case .Queen: return "queen" case .King: return "king" default: return String(self.toRaw()) } } } let ace = Rank.Ace//枚举成员Rank.Ace需要用全名来引用,因为常量ace没有显式指定类型。 let aceRawValue = ace.toRaw()//1 if let convertedRank = Rank.fromRaw(1) { let threeDescription = convertedRank.simpleDescription()//ace }
3.使用struct
来创建一个结构。结构和类有很多相同的地方,比如方法和构造器。它们之间最大的区别就是结构是传值,类是传引用。
struct Card { var rank: Rank func simpleDescription() -> String { return "The \(rank.simpleDescription())" } } let threeOfSpades = Card(rank: .Three) let threeOfSpadesDescription = threeOfSpades.simpleDescription()//The 3
4.一个枚举的成员可以有实例值(也可以叫关联值)。相同枚举成员的实例值可能不同,创建枚举实例的时候传入。而在定义枚举时候设置的原始值对于所有实例都是相同的。
enum ServerResponse { case Result(String, String) case Error(String) } let success = ServerResponse.Result("6:00 am", "8:09 pm")//实例值 let failure = ServerResponse.Error("Out of cheese.") switch success { case let .Result(sunrise, sunset): let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."//Sunrise is at 6:00 am and sunset is at 8:09 pm. case let .Error(error): let serverResponse = "Failure... \(error)" }
1.使用protocol
来声明一个协议,类似于java中的接口,为了和interface做为区别我们叫做协议。类、枚举和结构都可以实现协议(发现枚举实现协议协议中好像不能带有属性,希望大神指教)。
protocol ExampleProtocol { var simpleDescription: String { get }//在属性声明后写上{ get set }表示属性为可读写的。{ get }表示属性为可读的。即使为可读的属性实现了setter方法,它也不会出错。 mutating func adjust()//mutating关键字用来标记一个会修改结构体的方法 } class SimpleClass: ExampleProtocol { var simpleDescription: String = "A very simple class." var anotherProperty: Int = 69105 func adjust() {//不用mutating标记,因为class中的方法经常会修改类 simpleDescription += " Now 100% adjusted." } } var a = SimpleClass() a.adjust() let aDescription = a.simpleDescription//A very simple class. Now 100% adjusted. struct SimpleStructure: ExampleProtocol { var simpleDescription: String = "A simple structure" mutating func adjust() { simpleDescription += " (adjusted)" } } var b = SimpleStructure() b.adjust() let bDescription = b.simpleDescription//A simple structure (adjusted)
2.使用extension
来为现有的类型添加功能(称作扩展),比如添加一个计算属性的方法。可以使用扩展来给任意类型添加协议,甚至是你从外部库或者框架中导入的类型。
extension Int: ExampleProtocol { var simpleDescription: String { return "The number \(self)" } mutating func adjust() { self += 42 } } var i = 7; i.adjust()//直接写7.adjust()会有异常,这是因为7是常量,而adjust是mutating改变类方法 i.simpleDescription//The number 49 i//49
3.可以像使用其他命名类型一样使用协议名,可以创建一个有不同类型,但是都实现一个协议的对象集合。当处理类型是协议的值时,协议外定义的方法不可用。
let protocolValue: ExampleProtocol = a protocolValue.simpleDescription // protocolValue.anotherProperty // Uncomment to see the error
1.在<>里写一个名字来创建一个泛型方法或者类型。 也可以创建泛型类、枚举和结构体。
func repeat<T>(item: T, times: Int) -> [T] { var result = [T]() for i in 0..<times { result.append(item) } return result } repeat("knock", 4)//["knock", "knock", "knock", "knock"]
2.在类型名后面使用where
来指定一个需求列表,例如要限定实现一个协议的类型,需要限定两个类型要相同,或者限定一个类必须有一个特定的父类。简单起见,可以忽略where
,只在冒号后面写接口或者类名。<T: Equatable>
和<T where T: Equatable>
是等价的。
func anyCommonElements <T, U where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, rhs: U) -> Bool {//限定SequenceType类型,并且Element实现Equatable协议,该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。 for lhsItem in lhs { for rhsItem in rhs { if lhsItem == rhsItem { return true } } } return false } anyCommonElements([1, 2, 3], [3,4])//true func anyCommonElementsNew <T, U, R where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element, R == T.Generator.Element> (lhs: T, rhs: U) -> [R] {//限定序列SequenceType类型,并且Element实现Equatable协议,该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。 var results = [R]() for lhsItem in lhs { for rhsItem in rhs { if lhsItem == rhsItem { results.append(lhsItem) } } } return results } anyCommonElementsNew(["1", "2", "3", "4"], ["3","4","6"])//["3", "4"]
点击进入ooppookid的博客