1，首先来看看如何在Swift中定义一个类和类里面的属性、构造函数、方法及类方法

import Foundation

class Hello{
    //成员属性
    var _name:NSString?="jikexueyuan"
    //构造函数
    init(){      
    }
    //重载构造函数
    init(name:NSString){
        _name = name
    }
    //方法
    func sayHello(){
        PRintln("Hello \(_name)")
    }
    //类方法
    class func sayHi(){
        println("Hello Swift")
    }
}
var hello = Hello(name: "chen")
hello.sayHello()
Hello.sayHi()

2，在Swift中继承是跟C#一样使用冒号的形式来表示。一旦某个类继承了它的父类，就同时有了父类的属性和方法。在子类中可以重写父类的方法也可以调用父类的方法。

class Hi:Hello {
    //重写父类方法
    override func sayHello() {
        super.sayHello()//调用父类方法
        println("Hi \(_name)")
    }
}
var hi = Hi()
hi.sayHello()

3，在程序编写的过程中有的时候我们会使用到第三方类库或者使用系统的类库的时候，发现这些类库中某些类需要扩展则可以使用extension关键词来实现。若子类继承带有extension扩展的父类，相应的子类也应该会有扩展的方法。

//类的动态扩展
extension Hi{
    func sayHaha(){
        println("Haha")
    }
}
hi.sayHaha()

4，在Swift中接口使用protocol关键字来定义

protocol Person{
    func getName()->NSString
}

class Man: Person {
    func getName() -> NSString {
        return "jikexueyuan"
    }
}
var man = Man()
var hiMan = Hi(name: man.getName())
hiMan.sayHello()

5，由于多态的继承特性，使得编码中有了子类与父类的转型，即向上转型和向下转型。有向上转型是把一个子类的实例直接赋给一个父类的引用变量、不用任何的类型转换。引用变量只能在编译时才能转换为实际的类型，这种强制转换为向下转型。

//向上转型
let obj : NSObject = "Hello"
println(obj)
//向下转型
let objStr : NSString = obj as! NSString
println(objStr)

6，在Swift中命名空间使用类的嵌套的方法去实现，但是当命名空间嵌套很复杂且命名空间里的类会非常多的时候会显得很臃肿。这个时候可以在一个Swift文件中定义命名空间的嵌套，在另外一个Swift文件中使用extension关键字来扩展命名空间，最后在使用到的文件中直接调用就可以了。

//---Space.swift
class com{
    class jikexueyuan{
    
    }
}
//---Hello.swift
extension com.jikexueyuan{
    class Hello {
        func sayHello(){
            println("Hello")
        }
    }
}
//---Hi.swift
extension com.jikexueyuan{
    class Hi  {
        func sayHi(){
            println("Hi")
        }
    }
}
//---Main.swift
var spaceHello = com.jikexueyuan.Hello()
spaceHello.sayHello()
var spaceHi = com.jikexueyuan.Hi()
spaceHi.sayHi()