本swift教程并不是教大家如何如何玩转一门语言，是让大家快速看懂别人swfit的项目，最后加上强大的复制粘贴和万能的google，用一种相对极端的方法快速入门做项目
重复说明，我的写代码，大家千万不要拿去敲（谁敲谁傻b)，太浪费时间和消磨积极性，只需要根据代码板块复制粘贴到playground上看（不知道的看上一篇文章）, 一块一块看比较有效率 ，特别要看打印结果，然后可以自己根据思路写上注释，如果遇到报错，可能是你复制粘贴代码导致重复定义，也可能是xcode的问题，细节不用太在意，主要了解语法结构！
重点到最后一章我会上传一个小项目让你大家来敲一遍，敲到不懂的回来看即可！
可选类型的应用场景
// 2.可选类型的应用场景
// 2.1.将字符串类型转成Int类型
let str = "123"
let result = Int(str)
// 2.2.根据String创建一个NSURL
let urlString = "http://www.baidu.com"
let url : NSURL? = NSURL(string: urlString)
if let url = url {
let request = NSURLRequest(URL: url)
}
// 2.3.根据一个文件名称, 获取文件的路径
let path = NSBundle.mainBundle().pathForResource("123.plist", ofType: nil)
if let path = path {
NSArray(contentsOfFile: path)
}
is 的使用
// 1.is 的使用
let infoArray = ["Kobe", 18, 1.98]
let item = infoArray[0]
// item.isKindOfClass(UIView.self) 判断是否是某种类
if item is String {
print("是一个字符串")
} else {
print("不是一个字符串")
}
as 的使用
// 2.as 的使用
// 2.1. as 的直接使用 -> Swift类型和OC类型之间的转化
let infoArray = [Kobe", 18, 1.98]
let urlString = "www.baidu.com"
(urlString as NSString).substringToIndex(3)
// 2.2 as? 的使用 : 将NSObject转成确定的类型的可选类型
/*
let item1 = infoArray[1]
let name = item1 as? String
if let name = name {
print(name.characters.count)
}
*/
if let name = infoArray[0] as? String {
print(name.characters.count)
}
// 2.3. as! 的使用 : 将NSObject转成确定的类型, 但是如果转化不成功, 则程序会崩溃
/*
let item1 = infoArray[0]
let name = item1 as! String
print(name.characters.count)
*/
let count = (infoArray[0] as! String).characters.count
函数
import UIKit
// 1.没有参数没有返回值的函数
func about() -> Void {
print("iPhone8")
}
about()
func about1() {
print("iPhone8")
}
// 2.有参数, 没有返回值的函数 +86
func callPhoneNum(phoneNum : String) {
print("打电话给:" + phoneNum)
}
callPhoneNum("+86 110")
// 3. 没有参数, 有返回值的函数
func readNewMsg() -> String {
return "吃饭了吗?"
}
let newMsg = readNewMsg()
print(newMsg)
// 4. 有参数有返回值的函数
func addTwoNums(num1 : Int, num2 : Int) -> Int {
return num1 + num2
}
let result = addTwoNums(20, num2: 30)
print(result)
addTwoNums(20, num2: 39)
内部参数&外部参数
1.什么内部参数名称
1> 在函数内部可以看到的标识符就是内部参数
2> 默认情况下, 所有的参数都是内部参数
2.什么外部参数名称
1> 在函数外部可以看到的标识符就是外部参数
2> 从第二个参数开始, 都是外部参数. 但是第一参数默认不是外部参数
3> 如果希望第一个参数可以也是外部参数, 那么可以第一个参数的标识符前, 加上第一个参数的外部参数名称
4> 如果希望后面的参数不是外部参数, 可以在标识符前加上 _
func sum(num1 num1 : Int, num2 : Int, num3 : Int) -> Int {
return num1 + num2 + num3
}
sum(num1: 20, num2: 30, num3: 40)
*/
/*
func sum(num1 : Int, _ num2 : Int, _ num3 : Int) -> Int {
return num1 + num2 + num3
}
sum(20, 30, 40)
*/
// 了解
func sum(num1 num1 : Int, fdafdafad num2 : Int, num3 : Int) -> Int {
return num1 + num2 + num3
}
sum(num1: 20, fdafdafad: 30, num3: 40)
函数特殊用法
//雀巢是默认咖啡
import UIKit
func makeCoffee(coffeeName : String = "雀巢") -> String {
return "制作了一杯爱心\(coffeeName)咖啡"
}
let coffee1 = makeCoffee("拿铁")
makeCoffee("摩卡")
makeCoffee()
可变参数
func sum(nums : Int...) -> Int {
var total = 0
for num in nums {
total += num
}
return total
}
sum(20, 30)
指针参数
import UIKit
var m = 20
var n = 30
func changeNum(inout num1 : Int, inout num2 : Int) {
let temp = num1
num1 = num2
num2 = temp
}
changeNum(&m, num2: &n)
print("m:\(m) n:\(n)")
函数的嵌套，函数里面嵌套多个函数
func demo() {
func test() {
print("test")
func test1() {
print("test1")
}
}
print("demo")
test()
}
demo()
函数式编程，函数作为参数调用
// 1.定义两个函数
// 类型 (Int, Int) -> Int
func addTwoInts(num1 : Int, num2 : Int) -> Int {
return num1 + num2
}
func multiplyTwoInts(num1 : Int, num2 : Int) -> Int {
return num1 * num2
}
var abc : (Int, Int) -> Int = addTwoInts
abc = multiplyTwoInts
abc(20, 30)
func printResult(cba : (Int, Int) -> Int) {
print(cba(20, 30))
}
printResult(multiplyTwoInts)
类比学习
// 20 --> Int
var m : Int = 20
m = 30
let result = m + 30
func printNum(m : Int) {
print(m)
}
printNum(m)
// 30 --> Int
枚举
import UIKit
// 1.枚举的基本定义
enum Direction {
case East
case West
case North
case South
}
// 2.使用枚举类型
// 完整写法
let d : Direction = Direction.East
// 简便写法 : 根据上下文能推导出确定的类型
var d1 = Direction.East
d1 = .West
// 3.枚举类型的应用
let btn = UIButton(type: .Custom)
btn.addTarget(nil, action: "函数", forControlEvents: .TouchUpInside)
给枚举类型进行赋值
// 1.定义枚举类型 给枚举类型进行赋值
enum Direction : String {
case East = "10"
case West = "11"
case North = "12"
case South = "13"
}
var d : Direction = .North
d = .South
let d1 : Direction? = Direction(rawValue: "10")
// 2.定义枚举类型 : 太阳系的行星
enum Planet : Int {
case waterxing = 0, earth, firexing, gelding//后面自动会添加底标
}
let p : Planet = .earth
let p1 : Planet? = Planet(rawValue: 2)//打印firexing
结构体
import UIKit
let m : CGFloat = 10
let n : Double = 11
// 1.创建系统的结构体
let point = CGPointMake(100, 100)
let point1 = CGPoint(x: 10, y: 10)
let size = CGSizeMake(100, 100)
let size1 = CGSize(width: 50, height: 50)
let rect = CGRectMake(0, 0, 100, 100)
let rect1 = CGRect(x: 50, y: 50, width: 50, height: 50)
// 2.定义自己的结构体
struct Location {
var x : Double
var y : Double
// 给自己的结构体扩充构造函数
// 1.如果没有自定义构造函数, 那么系统也会提供一个默认的构造函数
// 如果有自定义构造函数, 那么会覆盖掉系统的构造函数. 如果不希望被覆盖, 则需要明确的实现
init(x : Double, y : Double) {
self.x = x
self.y = y
}
// 2.自定义的构造函数
init(x : Int, y : Int) {
self.x = Double(x)//要转
self.y = Double(y)//要转
}
init(x : CGFloat, y : CGFloat) {
self.x = Double(x)//要转
self.y = Double(y)//要转
}
init() {
x = 0
y = 0
}
}
let l : Location = Location(x: 50, y: 50)
print(l)
在结构体里面写函数并修改成员属性
mutating : 如果函数中有修改成员属性, 那么函数前必须加上mutating
import UIKit
struct Location {
var x : Double
var y : Double
func test() {
print("-----")
}
// mutating : 如果函数中有修改成员属性, 那么函数前必须加上mutating
mutating func moveH(distance : Double) {
self.x += distance
}
}
var l = Location(x: 20, y: 30)
l.moveH(-10)
swift中的类
/ 1.定义类
class Person {
// 对象类型, 声明称可选类型
// 值类型, 赋值初始化值
var name : String = ""
var age : Int = 0
}
// 2.创建类对应的对象
//let view : UIView = UIView()
let p : Person = Person()
p.name = "Kobe"
p.age = 18
print(p.name)
print(p.age)
存储属性／计算属性／类属性
import UIKit
class Student {
// 存储属性 : 存储一些值
var name : String = ""
var age : Int = 0
var mathScore : Double = 0.0
var chineseScore : Double = 0.0
/*看看就好
func getAverageScore() -> Double {
return (mathScore + chineseScore) * 0.5
}
*/
// 计算属性 : 通过某种方式计算得到结果的属性就是计算属性
/*完整写法，看看就好
var averageScore : Double {
set {
}
get {
return (mathScore + chineseScore) * 0.5
}
}
*/
var averageScore : Double {
return (mathScore + chineseScore) * 0.5
}
// 类属性 : 和整个类相关的属性, 并且是通过类名访问
// 类属性的定义是使用static
static var courseCount : Int = 0
}
let stu = Student()
stu.name = "Kobe"
stu.age = 18
stu.mathScore = 99
stu.chineseScore = 80
let averageScore = stu.averageScore
// 访问类属性
Student.courseCount = 2
类的构造函数
class Person {
var name : String = ""
var age : Int = 0
// 系统默认提供
// 如果有自定义构造函数, 那么会覆盖掉系统提供的构造函数
// 如果不希望被覆盖, 则需要明确时限
//系统默认
init() {
}
// 如果在一个方法中, 属性名称产生了歧义(重名), self.不可以省略
init(name : String, age : Int) {
self.name = name
self.age = age
}
init(dict : [String : NSObject]) {
if let name = dict["name"] as? String {
self.name = name
}
if let age = dict["age"] as? Int {
self.age = age
}
}
}
let p = Person()
p.name = "Kobe"
p.age = 18
let p1 = Person(name: "yz", age: 19)
print(p1.name)
print(p1.age)
let p2 = Person(dict: ["name" : "Kobe", "age" : 18])
print(p2.name)
print(p2.age)
KVC
/*
使用KVC的条件
1.必须继承自NSObject
2.如果是在构造函数中使用, 那么必须先调用super.init()
*/
class Person : NSObject {
var name : String = ""
var age : Int = 0
init(dict : [String : NSObject]) {
super.init()
setValuesForKeysWithDictionary(dict)
}
//重写override，因为里面数组里面添加了未定义的属性-》"height" : 1.88
override func setValue(value: AnyObject?, forUndefinedKey key: String) {}
}
/*
let p = Person()
p.setValuesForKeysWithDictionary(dict)
print(p.name)
print(p.age)
*/
let dict = ["name" : "Kobe", "age" : 18, "height" : 1.88]
let p = Person(dict: dict)
print(p.name)
print(p.age)
析构函数
import UIKit
class Dog {
var weight : Double = 0.0
// 析构函数
deinit {
print("Dog已经销毁")
}
}
var d : Dog? = Dog()
d = nil
网友评论