Swift - 02

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, width: 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)