//类型安全，swift中不支持隐式转换


//var c = 100
//var c1 = 100.85
//
//let res = c + c1
//总结：swift 中不同数据类型，不能赋值和运算
//---------循环语句---------
//for in /for/while/ do while

var sum_1 = 100

while(sum_1 > 50)
{   //--,++ 不能空格
    sum_1--

    print("sum_1 \(sum_1)")
}

//do while 

repeat{
    sum_1--

    print("sum_1 \(sum_1)")

}while(sum_1 > 50)

//总结：do while 换成了repeat while 其他语法没有改变


//分支语句
// if else

var girlfriend = (name:"XXX",age:30)
if girlfriend.age <= 18
{
    print("too young too naive")
}else if girlfriend.age > 18 && girlfriend.age <= 22
{
    print("I want you")
}else if girlfriend.age > 22 && girlfriend.age <= 30
{
    print("not bad")
}else
{
    print("OMG")
}
//Switch

let source = 68;
switch source
{
case 0..<60:
    print("不及格")

case 60..<80:
    print("及格")
   fallthrough
case 80..<90:
    print("良好")
case 90..<100:
    print("优秀")

case 100:
    print("满分")
default :
    print("输入有误")
}
//Switch判断条件可以是字符串

let let_str = "lee"

switch let_str
{
    case "zz":

    print("doubi")

    case "lee":

    print("cool")
default:
    print("yeah")
}

let point = (0,0)
switch point
{
case (0,0):
    print("原点")
case(0,_)://占位符_
    print("y轴上")
case(_,0):
    print("x轴上")
default:
    print("其他")
}


/*
1：switch不需要加break，也就是默认没有贯穿，判断条件不用加（）
2: 如果想实现贯穿需要加 fallthrough
3: switch可以以字符串和元组作为判断条件

*/

//----------函数----------
//1.无参无返回值函数

func method1() ->Void
{

}

//省略版 无参无返回值函数
func method2()
{
    print("我是无参无返回值的函数")
}
//2:无参有返回值
func method3() ->String
{
   return "wp"
}

let func_str = method3()

print(func_str)

//3.有参无返回值

func method4(A:Int,B:String,C:Float) ->Void
{

}
//4.有餐有返回值
func method5(A A:Int,B:Int) ->Int
{
    if A > B

    {
        return A
    }else
    {
        return B
    }
    // return A > B ? A : B
}

let func_int1 = method5(A : 100,B : 25)

print(func_int1)

//5.有参有返回值（返回多个值）

func method6 (name:String,age:Int,gender:String) ->(String,Int,String)
{
    return("ez",18,"boy")
}

print(func_int1)


let fun_str_2 = method6("s",age: 12,gender: "female")

print(fun_str_2.0)

//交换函数参数的值(如果改变参数函数，需要在参数前面加一个关键字：inout)

func method7(inout A:Int,inout B:Int) ->Void
{
    let temp = A
          A = B
    B = temp

}

var A = 100
var B = 999

method7(&A,B: &B)
print(A)

//---------------------------枚举-----------------------
enum Season : Int
{
    case Spring = 0
    case Summer
    case fall
    case winter
}
//根据C语言对比，枚举多了Case关键词，不用加逗号“，” Swift中枚举为 int 类型的， 不会默认从0开始
let enum_1 = Season.Spring
//typealias Newname = Season

switch enum_1
{
case.Spring:
    print("春天")
case.Summer:
    print("夏天")
case.fall:
    print("秋天")
default:
    print("冬天")
}

print(enum_1)

//总结：Switch用枚举作为判断条件，case后面是用“.”来获取枚举的值
//switch中，当所有case条件满足，default可以省略，若不满足必须加default

//第二种枚举（可以用字符串定义枚举值）

enum Season2:String
{
    case Spring = "春天"
    case Summer = "夏天"
    case Autumn = "秋天"
    case Winter = "冬天"

}
//----------------结构体--------------
// Swift结构体，相当于swift中的类。结构体是值类型（重新拷贝一份值，修改拷贝的值对原来的值没有影响，类是引用类型（共用一个内存地址，原值会改变影响新值）
struct Person {
    //对象的属性
    var name: String
    var age : Int
    //对象的方法
    func sayHello()->Void
    {
        print("你好")
    }
    //类方法
 static func sayHi() ->Void
    {
        print("HI")
    }
   //类属性
    static var personName:String?

}
//生成一个对象
let per1 = Person(name: "z",age: 21)

//调用对象方法
per1.sayHello()
//输出对象的名字
print(per1.name)

//调用类方法
Person.sayHi()

Person.personName = "lisi"

var p1 = Person.init(name: "lol",age: 111)
var p2 = p1

print(p2.name)
p1.name = "zzz"
print(p2.name)

print(Person.personName!)

//类

class Student {
    var name: String?//类，声明属性必须用可选方法
    var age: Int?

    func sayFuck()->Void
    {
        print("fuck")
    }
    static var studentName:String?
}

var stu1 = Student()
stu1.name = "www"
stu1.age  = 35

var stu2 = stu1
print(stu2.name)

stu1.name = "hole"
print(stu2.name)