swift_02_基础知识

来源：互联网发布：mac倍速看视频编辑：程序博客网时间：2024/05/01 10:20

import Foundation

// 1.类

// 1.根类:不再拥有父类的类：NSObject
// 2.基类:拥有多个子类，并且拥有父类,如:UIView,NSOperation

// 类的写法:关键字:class
class Person{

    //声明属性
    //类中自带的构造函数不带参数，所以要给每个变量设置为可空的，可以用‘？’或'!'修饰，但用'!'，要在使用之前必须赋值

    var name: String?
    var age: Int?


    //声明类属性
    static var country: String?



   //声明方法
    func sayHi(){
        print("你好，name : \(name),age :\(age)")
    }

    //声明类方法
    //方法一:（在子类中不能重写，只能使用）
    static func sayHello(){
        print("country : \(country)")
    }

    //方法二:(可以在子类中重写)
    class func sayHello1(){
        print("country : \(country)")
    }


    //类中自带了一个无参的构造函数，要使用有参的构造函数，要自己声明
    init(name: String, age: Int){
        self.name = name
        self.age = age
    }

}

var person = Person(name: "大华子", age: 1)
print(person.age)

//子类继承父类的属性和方法，而static修饰的方法不能继承，class修饰的方法可以重写
//子类重写父类的方法，要有关键字override
class Student: Person {


    override func sayHi() {
        print("重写了sayHi方法")
    }

    override class func sayHello1(){
        print("这是重写的方法")
    }

}

class Rect {

    //声明属性
    var x: Int?
    var y: Int?
    var weidth: Int!
    var height: Int?


    //计算属性
    //可以直接通过其他属性计算出来的属性，但不保存该属性值

    //只读属性就是不写set方法，只有get方法
    var centerX: Int {

        get{
            return self.x! + weidth/2
        }
        set{
            //此时newValue存的就是中心点x的值
            print(newValue)
        }
    }

    var centerY: Int {

        get{
            return self.y! + height!/2
        }
        set{
            print(newValue)
        }
    }

    //声明构造函数
    init(x: Int, y: Int, weidth: Int, height: Int){
        self.x = x
        self.y = y
        self.weidth = weidth
        self.height = height
    }


}

// 2.值类型和引用类型

//结构体:值类型，每赋值一次，都会拷贝一份新的内容，修改原来的,不会影响新的副本的内容
struct YaBo1 {
    var price: Double
}

//类:引用类型，赋值就像是OC中的指针指向，无论通过哪个变量名修改，始终操作的都是该对象
class LuDan1 {
    var price: Double!
}

//
var YaBo = YaBo1(price: 100.0)
print(YaBo)

// 3.协议
protocol MarryProtocol {


    //声明协议方法
    func test1()
    func test2()


}

//声明可选协议方法
//如果协议里有可选协议方法，则声明协议之前要加关键字 @objc
//swift协议方法中要声明可选方法时，每个方法前都要加 optional ，不然默认是必须实现的
@objc protocol MarryProtocol2 {

    //可选方法
    optional func test3()

    //必须实现的方法
    func test4()


}

//协议名也是直接写在冒号后面,多个协议时直接加","和协议
//注意:如果有父类，父类必须写在协议之前
class LaTiao: MarryProtocol{

    func test1() {

    }

    func test2() {

    }

    //如果实现可选协议的方法,在没有父类的情况下，需要添加 @objc 关键字
    //如果实现可选协议的方法,有父类，直接写就可以了
    @objc func test4() {

    }


}

// 4.Extension
//给类或结构体拓展方法
extension LuDan1 {

    func sayHello() {
        print("Hello,我是卤蛋")
    }
}

//给结构体拓展方法
extension Int{


    func test(a: Int) -> Int{
        var sum: Int = 1
        for _ in 0..<a {
            sum *= self
        }
        return sum
    }
}

print(2.test(2))

let luDan = LuDan1()
luDan.sayHello()

// 拓展协议方法
extension LaTiao:MarryProtocol2
{
    @objc func test3() {
        print("lallalaaaaaa")
    }
}

let latiao = LaTiao()
latiao.test3()

//声明闭包变量
var sumClosure: ((a: Int, b: Int) -> Int)?
//可以省略参数，只写参数类型
var maxClosure: ((Int, Int)) -> Int?

//赋值
sumClosure = { (a: Int, b: Int) -> Int in

    return a + b

}

sumClosure = { (a, b) -> Int in

    return a + b

}

sumClosure = { (a, b) -> Int in

    a + b

}

sumClosure = { (a, b) in

    a + b

}

sumClosure = { a, b in
    return a + b

}
sumClosure = {
   return $0 + $1
}

sumClosure = {
    $0 + $1
}

//调用
var sum = sumClosure!(a: 1,b: 2)
print(sum)

//给闭包变量起别名
//关键字:typealias
typealias Sum = (Int, Int) -> Int

//声明闭包变量
var sumA: Sum?

//定义
sumA = {(a, b) -> Int in
    a * b

}

//调用
print(sumA!(2,5))

0 0