Swift再浪一波，快来快来

自己理解老师所说的！

var myset: Set<Int> = [1,2,3,3];//set集合是无序集合

var arr = [1,2,3];//Array有序集合

var dic = [1:"a",2:"b"];//字典是无序集合

for item in arr { //1.得到Array的长度

print(item)

}

for (index,value) in arr.enumerate() { //2.得到Array的长度

print("index is\(index) value is\(value)")

}

for (key,value) in dic { //得到字典里的长度

print("\(key) \(value)")

}

for k in dic.keys { //遍历字典里面所有的键

print(k);

}

for v in dic.values {//遍历字典里面所有的值

print(v);

}

//类的声明

//类是一个引用类型，也就是说类的实例是分配到堆中

//类：属性，方法，构造函数，析构函数，索引器（subscript）

class Person {

//存储属性,在创建的时候就回给其值

//属性观察器

var p = 20;

let p2 = 40;

var name = "ch" {

willSet {//赋值之前会调用willSet里面的内容

print("before");

print(newValue); //这是新赋的值

print(name);//这是原本name的值

}

didSet(old) {//赋值之后会调用willSet里面的内容。这里（old）是自定义print(old)里的名字的

print("after");

print(old);//这是原本的name值

print(name);//这是新赋值的name

}

}

//计算属性，get,set

//不能只有set，只有get的时候,表示只读计算属性，可以简写

//计算属性是没有属性观察者的

//计算属性是只能是var定义，不能用let定义，也不需要一开始就复制,没有必要

//计算属性是不需要属性观察器的，里面是可以写多行代码的

var age: Int {

get {

return 100;

}

set {

}

}

//只读计算属性

var readOnlyAge: Int {

get {

return 100;

}

}

//只读计算属性还可以这样定义

var readOnlyAge2: Int {

//这里是可以写多行代码的

return 100;

}

init() {

//这是Swift的初始化时调用的方法（自动）

print("init");

}

deinit {

//这是Swift的销毁时调用的方法（自动）

print("deinit");

}

}

var p = Person();

p.name = "cx";

p.age = 30;

p = Person();

//p.p2 = 50; //这里报错 let定义的p2的值是不可以被修改的

let p2 = Person();//常量指针

p2.p = 60;

//p2.p2 = 70;//这里报错 let定义的p2的值是不可以被修改的

//p2 = Person;let p2 = Person() 表明p2的值不能改变了，这个p2 = Person就是表示重新给p2赋值了。 所以错误

//三个等号是判断两个变量是否指向同一个对象

var p3 = Person();

p === p3;

var p4 = p ;

p4 === p;

class A {

init() {

print("a init");

}

}

class B {

lazy var p = A();

}

let b = B();// 使用lazy可以使不必要或复杂的初始化不总是进行，一些储存属性的初始化很费时，加lazy时合理的

//修饰为静态可以用这两个属性:class,static

//存储属性，只能用static,计算属性两个关键字都可以用

//方法也是两个关键字都可以

//区别在于：class修饰的表示子类继承父类后可以重写这些静态成员

class Image {

static var name = "my";//存储属性

//sclass var name2 = "aaa";//错误 存储属性不能用class修饰

static var Age:Int {

get {

return 100;

}

set {

}

}

static func someMethod() {

//静态方法中的self不是指类的实例，而是指类本身

　　//self出现在静态成员中时self指的是类本身，否则就是实例

}

class func someMethod2() {

}

}

class xiangCe {

var images = [1,2,3,4,5];

//下标 subscript,可以有多个参数

subscript(index: Int) ->Int {

get {

return images[index];

}

set {

images[index] = newValue;

}

}

func getImage(index: Int) -> Int {

return images[index];

}

}

var xc = xiangCe();

xc[0] = 1200; //通过下标修改下标对应的值

xc[0];

xc.getImage(0)

//全局变量和本地变量的定义

//全局变量：在类外面定义，作用于整个项目

//本地变量:在类里面或者方法里面定义，作用于类，和方法里