Swift学习笔记
2016-06-05 本文已影响18人
立刻就爽
Swift和OC的不同
1.类型推断,不需要指定变量的类型,swift相比OC最强大的地方在于编译器,Swift编译器是全类型编译器,在编译的时候就知道了所有的对象的类型,这是OC的动态编译所做不到的,这样做有一个好处,就是类型安全
2.Swift当中不能向nil发送消息
3.泛型 允许向Java那样将数据类型参数化.
4.字符串做了一些增强
5.switch语法做了精简,提供了范围限制
引入的时候没有双引号,也没有尖括号,直接写框架名
import Foundation
//输出函数
//字符串取消前面的@标记
//没有分号,分号是可选写入的
print("Hello, World!")
1.变量和常量的声明
let myGender = "男"//常量
var carName = "BMW"//变量
carName = "Audio"```
Swift中允许使用任何Unicode字符作为变量和常量的名字,包括哪些不在ACSII编码的字符(不过貌似然并卵)
let 李帅 = "呆萌2b"
let 😳 = "呵呵"
let 🐶 = "狗"
print(🐶)
var a = 10
var b = "A"
var c = 100.1
var d = 200.2
var e = c+d
var char = "A"//这样的创建的是字符变量
####2.类型判断
swift中定义变量和常量的时候,不需要标识出变量和常量的类型,系统会自动进行匹配补全,但是也可以进行手动指定
let name = "小超"//这里就会自动推断为String类型,是由后面的字符串推断出来的
let name1 : String = "西门庆"//这个常量就不会进行类型推断,因为已经显示的指定了常量的类型
//swift中(系统原生的)所有的类型都是首字母大写,剩下的小写
var age :Int = 20
var weight : Float = 130
var money : Double = 100000000
不论是变量还是常量,要么赋初值,要么指定类型,要么指定为可选类型,要么指定类型并且赋初值,否则报错
####3.可选类型
在Swift当中对象没有赋初值就没有起始值,没有值的量是不能使用的,会报错和警告,这个时候就需要可选类型,可选类型简单来说就可以理解为,允许为空
将一个变量声明为可选类型?很简单,在最后面加一个?就可以了
//声明一个可选类型的字符串变量
var sex : String?
print(sex)
sex = "女"
print(sex)
print(sex!)//显示拆包,用!可以将可选类型中的数据拆解出来
//下面的代码因为不能为空又没有进行初始化,所以会报错
//var sex2 : String
//print(sex2)
####4.字符串
//(1).创建空的字符串
var str_empty :String = ""
var str_empty2 :String = String()
//(2).判断字符串是否为空
if str_empty.isEmpty{
print("字符串是空")
}
//(3).字符串拼接
var str1 = "aaa"
var str2 = "bbb"
var str3 = "!!!"
var str4 = str1 + str2 + str3
print(str4)
//(4).字符串中间插入数值
//swift中占位符更改了,使用()来进行变量和常量的取值
print("字符:(str4)\n")
//(5).获取字符串长度
print(str4.characters.count)
//(6).字符串等值判断
if str1 != str2{
print("两个字符串不相等")
}
####5.(隐式类型转换)
swift里面没有隐式类型转换,只有显示类型转换
//强制类型转换语法: Float()
let aa:Int = 3
let bb:Float = 2.3
var cc = Float(aa)+bb
####6.数组的使用
swift中的特点�:1 存储的所有的数据类型必须是同一类型 2 不必非得是对象类型,基本数据类型也可以存储
//数组的创建方式
var nameArray = ["呵呵","阿斯顿","金坷垃"];//首先推断为数组,数组里面元素的类型为字符串
//这种事直接显示指定数组和其元素类型
var nameArray1:Array<String> = ["小明","老王","星池"];
//创建一个空的数组
var array = Array<String>()//推荐用这种
var array1 = Int//创建一个整型的数组
//访问数组
print("数组第一个元素是(nameArray[0])")
//添加元素
nameArray.append("金条")
nameArray.insert("小祥", atIndex: 0)
print(nameArray)
//删除
nameArray.removeAtIndex(0)
print(nameArray)
//修改
nameArray[0] = "小翔子"
print(nameArray)
####7.字典
```
//定义字典
var score:Dictionary<String,Int> = ["小贱":99,"小杰":82,"小随":56]
//定义空的字典
var dic1:Dictionary<String,Int> = [:]
var dic2 = Dictionary<String,Int>()//推荐
//添加键值对
score["小欧"] = 95
//修改某个键值对
score["小贱"] = 59
print(score)
//删除
score.removeValueForKey("小杰")
print(score)
```
####8.元组
元组是将任意类型的任意个数的元素组成一个新的数据类型
```
var status = ("大神32",["18","19","20"],32)
var status1:(className:String,ages:Array,count:Int) = ("大神32",["18","19","20"],32)
//元组数据的访问
//方式1
print(status.0)
//方式2
print(status1.className)
```
元组的建议:元组中的元素过多,用标记名称,元组中的元素较少,种类能够分开,直接使用下标
####9.分支语句
在swift当中,bool类型只有true个false 没有YES和NO
```
let flag = true
if flag == true{
print("开心")
}else{
print("不开心")
}
```
switch
```
1.不需要使用break,不会有贯穿现象
let ageOfCat = 10
switch ageOfCat{
case 0:
print("小包")
case 1:
print("阿包")
default:
print("包包")
}
2.支持区间选项
switch ageOfCat{
case 0..<10://半闭区间
print("哈宝")
case 10...100://闭区间
print("呢宝")
default:
print("腰包")
}
3.支持where子句
switch ageOfCat{
case var value where ageOfCat < 10 && ageOfCat > 0:
value++
print("baobao")
case var value2 where ageOfCat >= 10 && ageOfCat < 100:
print("大宝")
default:
print("hehe")
}
```
####10.循环
```
for循环
for var i = 0; i < 10 ; i++ {
print("我是第\(i)遍")
}
let arr = ["🐂","🐴","🐍","🐰","🐲","🐯"]
//遍历数组
for a in arr{
print(a)
}
//遍历字典
let dict = ["❀":18,"西施":16,"杜十娘":21]
for (key,value) in dict{
print("\(key)->\(value)")
}
//while
var number = 5;
while number > 0{
number--
print(number)
}
repeat {
print("dasd")
number--
}while number > -6
```
####11.函数
```
//无参无返回值的函数
func function1() ->Void{
print("啦啦啦")
}
//无参有返回值的函数
func function2() ->Int{
return 10
}
//有参无返回值的函数. 参数列表是先写参数名,再写参数类型
func function3(a:Int,b:Double) ->Void{
}
//有参有返回值的函数
func function4(a:Int,b:Double) ->Int{
return a + Int(b)
}
//函数调用的时候需要显示的标明参数名字,但是,一般第一个参数不写,剩下的参数都要标明参数的名字
function4(5, b: 2.0)
//inout参数
//参数默认的是let类型的,但是swift提供了另外一种方式,可以将参数和传入的值进行关联,就是inout
func change(inout value : Int){
value = 10
}
var number1 = 20
change(&number1)
print(number1)
```
####12枚举
```
enum Season : Int{
case spring = 10
case summer
case autumn
case winter
}
print(Season.summer.rawValue)
```
####13 结构体
```
struct Rect {
//声明结构体的变量属性,(存储属性)
var x : Float
var y : Float
var width : Float
var height :Float
//声明结构体属性
static var desription:String?
//声明结构体的变量属性,(计算属性)
//计算属性:这个属性专门计算其他属性的值,但其本身并不存储值,一般提供setter,getter方法,在setter,getter方法中实现对其他属性的计算
var centerX :(Float){
//setter方法
set{
//这里的newValue是系统传递过来的数值,代指就是调用set方法的时候赋予的值
//如果这个修改的属性是let类型的,那么不能进行修改,会报错
x = newValue
}
//getter方法,这个方法必须要有,否则报错
get{
return x+width/2
}
}
var centerY :(Float){
//get方法是必须的,但是set方法可以省略
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),周长为\(width*2 + height*2)")
//属性值的改变只能在计算属性里去写
// description = "2016年4月8日创建"
// print(desription)
}
//声明结构体方法
static func info(){
print("这是一个结构体方法")
//结构体变量只能在结构体方法里面使用,正常方法不能使用
desription = "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属性的set方法
print(frame)
print(frame.centerX)//这一句代码相当于调用了CenterX属性的get方法
print(frame.totalLength)
//方法的调用
frame.frameInfo()
Rect.info()
```
####14 类
```
/*
class Person{
//属性
var name : String?
var age : Int?
//初始化方法,这里的参数列表要和上面的保持一致
init(name :String, age : Int){
self.name = name
self.age = age
}
}
//1.类的使用
var person = Person(name: "铁锤", age: 18)
//2.属性的使用
print(person.name!)
*/
class Person {
//1.属性
//声明对象方法
var name : String?
var age :Int?
//声明类属性
static var introduce : String?
//计算属性
var value : Int{
//类中计算属性实现的不同
set(a){
age = a//set get方法中不能出现self,会造成死循环
}
get{
return age!//这里不要忘记了拆包(去掉括号)
}
}
//方法
//声明类方法
//在类中,如果方法使用static修饰,那么表示两个事,1 他是类方法 2.他不能被子类重写
static func sayHi(){
print(introduce!)//类属性只能在类方法中使用,正常方法中不能使用
}
//在类中,如果方法使用class修饰,那么表示两个事,1 他是类方法 2.他能被子类重写
class func sayHi1() {
print(introduce!)
}
//声明实例方法
func sayHi2(){
print("我是实例方法~~~")
}
//自定义初始化方法(构造函数)
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("我是Student类,重写了父类的实例方法")
}
}
//类的创建和使用
var person = Person(name: "小海", age: 18)
//调用类的类属性
Person.introduce = "我是Person类"
//调用类方法
Person.sayHi()
Person.sayHi1()
//调用实例方法
person.sayHi2()
//调用实例变量
print(person.name!)
person.name = "小通"
print(person.name!)
//调用计算属性
person.value = 30
print(person.age!)
//关于Student
var student = Student(name: "小2B", age: 23)
//调用实例方法
student.sayHi2()
//调用类方法
Student.sayHi()
Student.sayHi1()
```
####15 值类型和值引用
```
*/
//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: 8)
var cat1 = cat
cat.name = "喵喵"
print("\(cat.name!)--\(cat1.name!)")
/**
* 协议(protocol)
*/
//如果协议里面包含可选实现的方法,那么需要添加一个@objc关键字作为标记
@objc protocol marryDelegate{
//协议里面写的方法都是必须实现的
func cook()
func washCloth()
//协议里面如果方法可选,需要加关键字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 washCloth() {
print("洗衣机洗去")
}
func makeMoney() {
print("$66666")
}
}
//看看协议是否好用
var man = Man(name: "小小",age:18)
man.makeMoney()
//类的扩展(Extension)
//1.扩展类遵循的协议中的方法的实现
extension Man{
@objc func HitDouDou() {
print("打豆豆")
}
}
//2.扩展一个类的方法,给某一个类添加一个方法,类似于OC里面的Category
extension Man{
//添加一个方法
func joke(){
print("讲笑话")
}
}
man.HitDouDou()
man.joke()
```
####16 闭包(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)
```
