2話不說 先遞上資料傳送門
Swift 官方文檔
https://developer.apple.com/swift/resources/
標(biāo)準(zhǔn)庫
https://developer.apple.com/library/ios/documentation/General/Reference/SwiftStandardLibraryReference/
=========================
Swift語言簡介
=========================
案例走起
Swift 類型成員
屬性 property
方法 method
初始化器 init
析構(gòu)器 deinit
下標(biāo) subscript
插入代碼看看
class MyClass {
//屬性
var x:Int
var y:Int
var datas:[Int]=[1,2,3,4,5]
//初始化器
init(x:Int, y:Int){
self.x=x
self.y=y
}
//方法
func printing(){
print("\(x), \(y), \(datas)")
}
//下標(biāo)
subscript(index: Int) -> Int {
get {
return datas[index]
}
set(newValue) {
datas[index]=newValue
}
}
//析構(gòu)器
deinit{
print("clear up resources")
}
}
var myObject=MyClass(x:10,y:20)
myObject.printing()
myObject.x += 1
myObject[0]=100
==============================
class類 與 struct結(jié)構(gòu)體
花了點時間上網(wǎng)找了點資料, 認(rèn)為還是挺全面的
http://faq.sealedabstract.com/structs_or_classes/
然后在作業(yè)中我也得出
//class類--引用類型
//●位置棧上的指針()引用類型
//●位于堆上的實體對象
//struct結(jié)構(gòu)--值類型
//●實例直接位于棧中
//●struct沒有繼承的功能略水，而class是可以繼承的，這是面向?qū)ο笳Z言的核心能力劝萤，class當(dāng)然會有這個能力渊涝。
//
//●體現(xiàn)在內(nèi)存使用上，struct是通過值傳遞床嫌，而class是通過引用傳遞的.
也說說棧與堆
========================
Swift 屬性
1.最簡單的情形
作為特定類或結(jié)構(gòu)實例的一部分跨释，存儲屬性存儲著常量或者變量的值。存儲屬性可分為變量存儲屬性（關(guān)鍵字var描述）和常量存儲屬性（關(guān)鍵字let描述）厌处。
上面面的例子定義了一個叫Rectangle的結(jié)構(gòu)鳖谈，它描述了一個一定范圍內(nèi)的整數(shù)值，當(dāng)創(chuàng)建這個結(jié)構(gòu)時阔涉，范圍寬度度是不可以被改變的
class Rectangle{
//存儲屬性
var height:Double = 0
let width:Double = 100
//計算屬性-只讀屬性
var area:Double{
return height*width
}
//靜態(tài)屬性
static var max:Double=10000
}
var r=Rectangle()
2.靜態(tài)屬性
靜態(tài)的成員不能實例來使用.
只能類型使用
按照上面代碼插入輸出代碼
Rectangle.max+=300
//r.max
//Rectangle.height
//注釋上面2行 會報錯
3.延遲存儲屬性
當(dāng)?shù)谝淮伪徽{(diào)用的時候才會計算其初始值缆娃，使用@lazy標(biāo)志捷绒，屬性的值在實例構(gòu)造完成之前可能為空，而常量要求構(gòu)造完成之前必須有初始值贯要，所以延遲屬性必須是變量
主要是不經(jīng)常使用的加載,減緩內(nèi)存壓力.達(dá)到優(yōu)化作用
class LargeData {
var data:String="延遲加載"
}
class DataProcessor{
lazy var myData=LargeData()
}
let dp=DataProcessor()
print(dp.myData.data)
4.屬性監(jiān)督者;
willSet在改變前調(diào)用
didSet在改變后調(diào)用
class DataStorage {
var data: Int = 0 {
willSet {
print("About to set data to \(newValue)")
}
didSet {
print("Changed from \(oldValue) to \(data)")
}
}
}
var ds=DataStorage()
ds.data=300
====================
方法
全局函數(shù)
//全局函數(shù)
func add(data1:Int, data2:Int)-> Int{
return data1+data2
}
var result=add(100,data2:200)
成員函數(shù)就是 在class,struct內(nèi)的函數(shù),大致與全局函數(shù)規(guī)范相似
class number{
func add(data1:Int, data2:Int)-> Int{
return data1+data2
}
}
var result =number()
result.add(100,data2:200)
*inout參數(shù)
加入inout 后,方法內(nèi)部數(shù)據(jù)就可以相互更改變量
class MyClass{
//inout參數(shù)
func swap(inout a:Int,inout b:Int){
let tempA=a
a=b
b=tempA
}
}
var myObject=MyClass()
var data1=100
var data2=200
myObject.swap(&data1,b: &data2)
// 輸出后,data1的值就會變成200 data2的值就會變成100
*多個返回值 tuple類型
class MyClass{
func minMax(array: [Int]) -> (min: Int, max: Int){
var currentMin = array[0]
var currentMax = array[0]
for value in array[1..<array.count] {
if value < currentMin {
currentMin = value
} else if value > currentMax {
currentMax = value
}
}
return (currentMin, currentMax)
}
}
let range=myObject.minMax([3,-9,23,15,-45,7])
print("max=\(range.max), min=\(range.min)")
========================
初始化器
*一個類可以有多個初始化器,但是最少需要一個
*如果一個雷沒有提供初始化器,那么編譯器會自動生成初始化器
*默認(rèn)初始化器,無參數(shù)形式init()
class Point{
var x=101
var y=201
init(){
x=1000
y=2000
}
init(x:Int, y:Int){//帶x,y參數(shù)
self.x=x
self.y=y
}
init(x:Int, y:Int) -> Int{//帶x,y參數(shù),并返回Int形式數(shù)據(jù)
self.x=x
self.y=y
}
}
var 1pt=Point()//你猜猜輸出是多少?
var 2pt=Point(x:20,y:20)
*指定初始化器Vs 便捷初始化器
指定初始化器為類的主初始化器,負(fù)責(zé)初始化所有屬性.必須調(diào)動其父類的主初始化器
便捷初始化器為類的輔助初始化器.必須調(diào)用同類的指定初始化器
class Point3D{//便捷初始化器
var x:Int
var y:Int
var z:Int
//初始化器1號
init(x:Int, y:Int, z:Int){
self.x=x
self.y=y
self.z=z
//other processing
print("other task")
}
//初始化器2號
convenience init(x:Int, y:Int){
self.init(x:x,y:y,z:0)//調(diào)用1號初始化器
}
//初始化器3號
convenience init(){
self.init(x:0,y:0,z:0)//調(diào)用1號初始化器
}
======================
析構(gòu)器
析構(gòu)器:1沒有參數(shù)2沒有返回值2一個class只有一個.
歸屬權(quán),只有實例析構(gòu)器,沒有類型析構(gòu)器
自動釋放:運行時根據(jù)ARC的釋放規(guī)則,自動釋放
析構(gòu)器樣子
class FileStream{
init(){
print("open file...")
}
func process(){
print("process file...")
}
//析構(gòu)器
deinit{
print("close file...")
}
}
說道析構(gòu)器, 這里一定也會說道Swift ARC
//樓主剛開始學(xué)習(xí)ARC的文檔
1號傳送門
//大牛的詳細(xì)講解
2號傳送門
==================
下標(biāo)
1.下標(biāo):可以類比"含參數(shù)計算的屬性",其實本質(zhì)是一堆帶索引參數(shù)的訪問器(get/set)
2.歸屬權(quán):只能定義實例下標(biāo),不能定義類型下標(biāo)(靜態(tài)也是不行)
3.定義讀寫(get/set):可以讀寫并存(get/set), 也可以只讀下標(biāo)(get)
下標(biāo)例子
class Vector{
var datas = [Int](count:100,repeatedValue:0)
//subscript下標(biāo)(關(guān)鍵字) (index:Int)索引 int 返回值
subscript(index:Int)-> Int{
get{
return datas[index]
}
set{
datas[index]=newValue
}
}
}
var datas=Vector()
for i in 0..<10{
datas[i]=i
}
for i in 0..<10{
print(datas[i])
}
==============================
標(biāo)準(zhǔn)操作符
這里說一下swift 的操作符
范圍操作符:1. a..<b 2. a...b
for index in 1...5 {
print("\(index) iteration")
}
print("-----------")
for index in 1..<5 {
print("\(index) iteration")
}
print("-----------")
前后中綴操作符
class Complex{
var real=0.0
var imag=0.0
init(real:Double, imag:Double){
self.real=real
self.imag=imag
}
}
var c1=Complex(real: 10,imag: 20)
var c2=Complex(real: 100,imag: 200)
//前綴操作符/方法前家進入prefix
prefix func - (data: Complex) -> Complex {
return Complex(real: -data.real, imag: -data.imag)
}
var c3 = -c1
//C3的結(jié)果是 real =-10 image =-20
//中綴操作符
//如果不實現(xiàn)這個操作, C3 就會報錯
func + (left: Complex, right: Complex) -> Complex {
return Complex(real: left.real + right.real,
imag: left.imag + right.imag)
}
var c4=c1+c2
C4的結(jié)果是 real =110 image =220
//后綴操作符 /方法前加postfix
postfix func ++ (data: Complex) -> Complex {
return Complex(real: data.real + data.real, imag: data.imag + data.imag)
}
var c6 = c2++
//C6的結(jié)果是 real =200 image =400
//復(fù)合賦值操作符 參數(shù)加上inout
func += (inout left: Complex, right: Complex) {
left = left + right
}
c1+=c2
//C1的結(jié)果是 real =110 image =220
//值相等操作符,創(chuàng)建==,就要創(chuàng)建!=
//插一個 `(==,!==)`是指值,`(===,!==)`是指引用
func == (left: Complex, right: Complex) -> Bool {
return (left.real == right.real) && (left.imag == right.imag)
}
func != (left: Complex, right: Complex) -> Bool {
return !(left == right)
}