swift基础之<二>

//类型安全，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)