自己理解老师所说的！

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)

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

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

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