2话不说 先递上资料传送门
Swift 官方文档
https://developer.apple.com/swift/resources/
标准库
https://developer.apple.com/library/ios/documentation/General/Reference/SwiftStandardLibraryReference/
=========================
Swift语言简介
=========================
案例走起
Swift 类型成员
属性 property
方法 method
初始化器 init
析构器 deinit
下标 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)")
}
//下标
subscript(index: Int) -> Int {
get {
return datas[index]
}
set(newValue) {
datas[index]=newValue
}
}
//析构器
deinit{
print("clear up resources")
}
}
var myObject=MyClass(x:10,y:20)
myObject.printing()
myObject.x += 1
myObject[0]=100
==============================
class类 与 struct结构体
花了点时间上网找了点资料, 认为还是挺全面的
http://faq.sealedabstract.com/structs_or_classes/
然后在作业中我也得出
//class类--引用类型
//●位置栈上的指针()引用类型
//●位于堆上的实体对象
//struct结构--值类型
//●实例直接位于栈中
//●struct没有继承的功能，而class是可以继承的，这是面向对象语言的核心能力，class当然会有这个能力。
//
//●体现在内存使用上，struct是通过值传递，而class是通过引用传递的.
也说说栈与堆
========================
Swift 属性
1.最简单的情形
作为特定类或结构实例的一部分，存储属性存储着常量或者变量的值。存储属性可分为变量存储属性（关键字var描述）和常量存储属性（关键字let描述）。
上面面的例子定义了一个叫Rectangle的结构，它描述了一个一定范围内的整数值，当创建这个结构时，范围宽度度是不可以被改变的
class Rectangle{
//存储属性
var height:Double = 0
let width:Double = 100
//计算属性-只读属性
var area:Double{
return height*width
}
//静态属性
static var max:Double=10000
}
var r=Rectangle()
2.静态属性
静态的成员不能实例来使用.
只能类型使用
按照上面代码插入输出代码
Rectangle.max+=300
//r.max
//Rectangle.height
//注释上面2行 会报错
3.延迟存储属性
当第一次被调用的时候才会计算其初始值，使用@lazy标志，属性的值在实例构造完成之前可能为空，而常量要求构造完成之前必须有初始值，所以延迟属性必须是变量
主要是不经常使用的加载,减缓内存压力.达到优化作用
class LargeData {
var data:String="延迟加载"
}
class DataProcessor{
lazy var myData=LargeData()
}
let dp=DataProcessor()
print(dp.myData.data)
4.属性监督者;
willSet在改变前调用
didSet在改变后调用
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
====================
方法
全局函数
//全局函数
func add(data1:Int, data2:Int)-> Int{
return data1+data2
}
var result=add(100,data2:200)
成员函数就是 在class,struct内的函数,大致与全局函数规范相似
class number{
func add(data1:Int, data2:Int)-> Int{
return data1+data2
}
}
var result =number()
result.add(100,data2:200)
*inout参数
加入inout 后,方法内部数据就可以相互更改变量
class MyClass{
//inout参数
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)")
========================
初始化器
*一个类可以有多个初始化器,但是最少需要一个
*如果一个雷没有提供初始化器,那么编译器会自动生成初始化器
*默认初始化器,无参数形式init()
class Point{
var x=101
var y=201
init(){
x=1000
y=2000
}
init(x:Int, y:Int){//带x,y参数
self.x=x
self.y=y
}
init(x:Int, y:Int) -> Int{//带x,y参数,并返回Int形式数据
self.x=x
self.y=y
}
}
var 1pt=Point()//你猜猜输出是多少?
var 2pt=Point(x:20,y:20)
*指定初始化器Vs 便捷初始化器
指定初始化器为类的主初始化器,负责初始化所有属性.必须调动其父类的主初始化器
便捷初始化器为类的辅助初始化器.必须调用同类的指定初始化器
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)//调用1号初始化器
}
//初始化器3号
convenience init(){
self.init(x:0,y:0,z:0)//调用1号初始化器
}
======================
析构器
析构器:1没有参数2没有返回值2一个class只有一个.
归属权,只有实例析构器,没有类型析构器
自动释放:运行时根据ARC的释放规则,自动释放
析构器样子
class FileStream{
init(){
print("open file...")
}
func process(){
print("process file...")
}
//析构器
deinit{
print("close file...")
}
}
说道析构器, 这里一定也会说道Swift ARC
//楼主刚开始学习ARC的文档
1号传送门
//大牛的详细讲解
2号传送门
==================
下标
1.下标:可以类比"含参数计算的属性",其实本质是一堆带索引参数的访问器(get/set)
2.归属权:只能定义实例下标,不能定义类型下标(静态也是不行)
3.定义读写(get/set):可以读写并存(get/set), 也可以只读下标(get)
下标例子
class Vector{
var datas = [Int](count:100,repeatedValue:0)
//subscript下标(关键字) (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])
}
==============================
标准操作符
这里说一下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的结果是 real =-10 image =-20
//中缀操作符
//如果不实现这个操作, C3 就会报错
func + (left: Complex, right: Complex) -> Complex {
return Complex(real: left.real + right.real,
imag: left.imag + right.imag)
}
var c4=c1+c2
C4的结果是 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的结果是 real =200 image =400
//复合赋值操作符 参数加上inout
func += (inout left: Complex, right: Complex) {
left = left + right
}
c1+=c2
//C1的结果是 real =110 image =220
//值相等操作符,创建==,就要创建!=
//插一个 `(==,!==)`是指值,`(===,!==)`是指引用
func == (left: Complex, right: Complex) -> Bool {
return (left.real == right.real) && (left.imag == right.imag)
}
func != (left: Complex, right: Complex) -> Bool {
return !(left == right)
}