Swift

import Foundation

print("Hello, World!")

//1.结构体
struct Rect{
    //声明结构体属性,(存储属性)
    var x : Float
    var y : Float
    var width : Float
    var height : Float
    
    //声明结构体变量属性
    static var description : String?
    
    //声明结构体的变量属性,(计算属性)
    //计算属性:这个属性专门计算其他属性的值,但其本身并不存储值,一般提供setter,getter方法,在setter,getter方法中实现对其他属性的计算
    var centerX :(Float){
        //setter方法
        set{
            //如果这个修改的属性是let类型的,那么不能进行修改,会报错
            x = newValue//这里的newValue是系统传递过来的数值,代指是调用setter方法的时候后面赋予 的值
        }
        get{
            return x+width/2
        }
    }
    
    var centerY :(Float){
        //getter方法是必须的,但是setter方法可以省略
    get {
    return y + height/2
    }
    }
    
    var totalLength :(Float){
        set{
            //计算属性可以对多个属性进行操作
            width = newValue / 4
            height = newValue / 4
        }
        get{
            //也可以同时返回多个属性计算的结果
            return (width + height) * 2
        }
    }
    
    //swift里面的结构体可以声明方法
    //声明方法,结构体方法不设置返回值
    func frameInfo(){
        
        print("frame的宽为(width),高为(height),周长为(totalLength)")
        
        //属性值的改变只能在计算属性里面去写
      
    }
    
    
    //声明结构体方法
    static func info(){
        print("这是一个结构体方法")
        //结构体变量只能在结构体方法里面使用,正常的方法里面不能使用它
        description = "2016年4月8日创建"
    }
}

//初始化结构体
var frame = Rect (x: 100, y: 100, 200, height: 200)
//打印frame
print(frame)
frame.x = 300
print(frame)

//计算属性的调用
frame.centerX = 200//这句代码,相当于调用了centerX属性的setter方法
print(frame)
print(frame.centerX)//这一句代码相当于调用了centerX的getter犯法

print(frame.totalLength)

//方法的调用
frame.frameInfo()

//结构体的属性在结构体里是全局的,所以要用结构体名来调用
Rect.info()



//2.类

//class Person{
//    //属性
//    var name : String?
//    var age : Int?
//    
//    //初始化方法,这里的参数列表要和上面的保持一致
//    init (name : String, age : Int){
//      self.name = name
//        self.age = age
//    }
//}
//
////2.1.类的使用
//var person = Person(name: "铁锤妹妹", age: 18)
////2.2.属性的使用
//print(person.name!)

class Person {
    //2.2.1.属性
    //声明对象属性
    var name : String?
    var age : Int?
    //声明类属性
    static var introduce : String?
    //声明计算属性
    var value : Int{
        set(a){
           age = a//setter getter方法中不能出现self,会造成死循环
}
        get{
     return age!//这里不要忘记了拆包
}
    }
    
    //.2.2.2.方法
    //(1).声明类方法
    //在类中如果使用static修饰,那么表示两个事件:1.他是类方法 2.他不能被子类重写
    static func sayHi() {
        
        print(introduce!)//类属性只能在类方法里使用,正常方法中不能使用
    }
    
    //在类中如果方法使用class修饰,那么表示两个事:1.他是类方法2.他能被子类重写
    class func sayHi1() {
        print(introduce!)
    }
    
    //(2).声明实例方法
    func sayHi2(){
        print("hello ,我是一个实例方法!!")
    }
    
    //自定义初始化方法(构造函数)
    init(name :String , age :Int){
     self.name = name
        self.age = age
    }
    
    init(name :String){
        self.name = name
    }
}

//怎么让一个类继承另一个类
class Student :Person{
    //重写父类的方法
    //子类重写父类的方法,必须添加override关键字
    override class func sayHi1() {
        print("我是student类重写了父类的类方法")
    }
    
    //重写父类的实例方法
    override func sayHi2() {
        print("重写了父类的实例方法")
    }
}

//类的穿建和实现
var person = Person (name: "李海洋", age: 28)
//调用类的类属性
Person.introduce = "大家好我是Person类,我喜欢人"

//调用类方法
Person.sayHi1()
Person.sayHi()
//调用实例方法
person.sayHi2()
//调用实例变量
print(person.name!)
person.name = "网汇通"
print(person.name!)
//调用计算属性
person.value = 30
print(person.age!)
//关于student
var student = Student(name: "小钰", age: 14)
//调用实例方法
student.sayHi2()
//调用类方法
Student.sayHi()
Student.sayHi1()


//3.值类型和值引用
//struct Animal{
//    var name :String
//    var age : Int
//    
//    init(name : String,age :Int){
//        self.name = name
//        self.age = age
//    }
//}
//
////使用这个方法
////(1).创建一个dog变量
//var dog = Animal(name:"旺财", age: 8)
////(2).创建另一个dog变量,等于原先的dog变量
//var dog1 = dog//此时dog1的值是从dog变量中拷贝一份出来的,是新的值
////(3).改变原先的dog变量
//dog.name = "阿黄"
////(4).打印两个变量的值
//print("(dog.name)->(dog1.name)")


class Animal {
    var name :String?
    var age :Int?
    
    init(name :String,age :Int){
        self.name = name
        self.age = age    }
}

//创建类的对象
var cat = Animal(name: "喵小喵", age: 1)
var cat1 = cat//访问的是同一块地址
cat.name = "喵十八"

print("(cat.name!)->(cat1.name!)")

//4.协议
//如果协议里面包含可选实现的方法,那么需要添加一个@objc关键字作为标记

 @objc protocol marryDelegate{
    //协议里面写的方法都是必须实现的
    func cook()
    func wash()
    //协议里面如果方法可选需要加关键字optional
    optional func hitDouDou()
}

protocol husbandDelegate{
    //挣钱
    func makeMoney()
}

//class Man : Person<marryDelegate,husbandDelegate>
//Swift规定,类名后面第一个是父类,剩下的都是接受的协议的名字
class Man :Person ,marryDelegate,husbandDelegate {
    @objc func cook() {
        print("红烧鲤鱼请你吃")
    }
    @objc func wash() {
        print("洗衣服")
    }
    func makeMoney() {
        print("我得多挣钱")
        
    }
}

//看看协议是否好用
var man = Man(name: "小小",age:18)
man.makeMoney()

//5.类的扩展
//(1).扩展类遵循协议中的方法的实现
extension Man{
    @objc func hitDouDou() {
        print("打豆豆")
    }
}

//(2).扩展一个类的方法,结果一个类添加一个类方法,类似于OC里面的Category
extension Man{
    //添加一个方法
    func joke(){
        print("php")
    }
}

man.hitDouDou()
man.joke()

//6.闭包(Block)
//Block 匿名函数
//int(^myBlock)(int a, int b)= ^int (int a, int b) {
//  return a>b?a:b
// }

var MyBlock :((a:Int ,b:Int)->Int)

//功能:求;两个数的最大值
//第一种方式
MyBlock = {
    (a:Int,b:Int) -> Int in//in是闭包结构的语法的一部分,必不可少,前面指定的是参数列表和返回值等信息
    return a > b ? a : b
}

//第二种方式
MyBlock = {
    a,b in
    return a > b ? a : b
}

//第三种
MyBlock = {
    (a,b)-> Int in
    return a > b ? a : b
}

//第四种
MyBlock = {
     a,b in
     a > b ? a : b
}

//第五种(逆袭神技)
MyBlock = {
    $0 > $1 ?$0 : $1
}

//调用
let max = MyBlock(a: 3, b: 5)
print(max)