/*---------------我是帅气的分割线--------*/
/**
* 协议
*/
@objc protocol Description {
func description() -> String
// mutating func amutatingMethod()
//这里可以改变属性的值
class func aTypeMethod()//类方法需要用class关键字
@optional func anOptionalMethod()
}
//如果声明可选择实现方法. 需要在func前加@optional声明,而且协议前面要加@objc 这样协议结构体不能遵守,所以也不允许matating方法的存在
//protocol Description{
// func description() -> String
// mutating func aMutatingMethod()
// class func aTypeMethod() //类型方法需要用class关键字
// @optional func anOptionalMethod()
//
//}
/*---------------我是帅气的分割线--------*/
/*------- 结构体 -------*/
struct Point {
var x = 0.0
var y = 0.0
}
struct Size {
var width = 0.0
var height = 0.0
}
// Swift中结构体也可以创建("对象")实例
var point = Point()
var size = Size()
//创建两个空的数组
var anEmptyArrayA = Array<String>()
// or
var anEmptyArrayB = String[]()
struct Rect{ ///------------>遵守协议,下面实现方法
var origin = Point()
var size = Size()
//计算属性必须是变量
var center: Point{
get{
let centerX = origin.x + size.width / 2
let centerY = origin.y + size.height / 2
return Point(x: centerX , y:centerY)
}
set (getCenter){ //--------> setter方法会提供一个默认的新值,newValue
let originX = getCenter.x - size.width / 2
let originY = getCenter.y - size.height / 2
origin = Point(x: originX,y: originY)
}
}
mutating func moveBy(deltaX:Double,deltaY: Double){
let newX = origin.x + deltaX
let newY = origin.y + deltaY
origin = Point(x:newX , y:newY)
}
//------实现协议方法
func description() -> String{
return "(\(origin.x),\(origin.y),\(size.width),\(size.height))"
}
mutating func aMutatingMethod(){
//这里可以改变属性的值
}
// 如果是现实协议中的类型方法,虽然在协议中使用了class关键字,但是在结构体
static func aTypeMethod() {
}
}
var frame = Rect()
frame.origin.x = 10
frame.origin.y = 10
//frame.size.width = 10
//frame.size.height = 10
frame.size = Size(width: 100, height:100)
println("frame = (\(frame.origin.x),\(frame.origin.y),\(frame.size.width),\(frame.size.height))")
println("frame.center = (\(frame.center.x),\(frame.center.y))")
println(frame.description())
/*---------------我是帅气的分割线--------*/
/**
* 枚举值
*/
enum PersonIdeentify: String {
case Teacher = "teacher"
case Student = "student"
}
class Person{
var name:String?
var sex:String?
var identify:PersonIdeentify?
//构造器中,第一个参数依然会创建一个和局部参数名称相同的外部参数名称
init(name: String,sex: String, identify: PersonIdeentify){
self.name = name
self.sex = sex
self.identify = identify
}
//实现协议方法
func description() -> String{
// 调用枚举值的toRow()方法可以获取到枚举值的初值
return "(name = \(name) sex = \(sex) identify = \(identify!.toRaw()))"
}
// 在类中如果实现协议中定义的mutating方法,那么不需要加"mutating"关键字
func aMutatingMethod(){
}
}
//前面声明枚举,直接可以用" .Student "再次说明自动类型推断
var personA = Person(name: "张三",sex :"m", identify: .Student)
var personB = Person(name: "lisi",sex :"f", identify: .Teacher)
switch (personA.identify!){
case .Teacher:
println("I am teacher")
case .Student:
println("I am Student")
}
/*---------------我是帅气的分割线--------*/
/**
* 继承
*/
class Student: Person {
var number: String?
// 在类中,类型属性只可以是计算属性,但是在枚举和结构体中,既可以是计算属性,也可以是存值属性
// 在类中声明一个类型属性的关键字class,在结构体和枚举中是static
class var attendClassTime: String {
return "9:30"
}
init(name: String,sex:String,number:String){
super.init(name:name,sex:sex,identify:.Student) //继承父类
self.number = number //自己的初始化
}
}
var studentA = Student(name: "李莉",sex: "f",number:"312321")
var studentB = Student(name: "李莉",sex: "f",number:"312321")
println("Student attendClassTime = \(Student.attendClassTime)")
class Teacher:Person {
var course:String?
init(name: String,sex:String,course:String){
super.init(name:name,sex:sex,identify:.Student)
self.course = course
}
override func description() -> String{ ///----------我重写之前的方法(协议中),加上关键字 override
return super.description() + "" + "course = \(course)"
}
}
var teacherA = Teacher(name:"张阳",sex:"男",course:"Swfit")
println()