2016-07-28 21:39:52 rhythmkay 阅读数 2682
  • 由浅入深学习PHP面向对象

    面向对象程序设计简称oop是英文全称“Object-Oriented Programming”,面向对象程序设计更加符合人的思考逻辑和对事物处理。面向对象程序设计的语言为编程人员开了一扇大门,使代码更简洁,便于维护,可强的重用性。 课程难点: 面向对象的编程思想,在开发过程中对于新手从“面向过程”到“面向思想”转变。

    2254 人正在学习 去看看 李强

目录

前言

当我们开始接触一门新语言时,我们难免避免不了类型和基本语法规则。我们会急切的想知道如何用新的语法规则写我们原先所熟知的语句。本文旨在对于Object-C和Swift做一些基本的对比。通过阅读本文,您能快速的了解Swift3.0和Object-C的一些差别。

  • 基本类型
    同所有的面向对象语言一样,Swift里也只有两种类型:

    1.值类型
    2.引用类型

    值类型包括struct,enum;
    引用类型主要是class,嗯还有闭包也是引用类型哦。

  • 代码不再需要分号结尾

    Swift代码单行结束,不需要强制加分号,但也可以选择加

  • 类型推断

    Swift可以自动根据上下文为一个变量推断出其类型;

  • 强类型语言

    尽管Swift可以支持类型推断,可以用var来声明变量。但Swift是强类型语言。这样意味着,只要涉及不同类型之间的运算,都需要进行强制类型转换

  • 变量、常量定义

    let constant name : type = expression
    var variable name : type = expression

在开始所有介绍前,我们先看简单的几行代码.大家采一些预期结果是什么?

    var num=3.0
    var integer=6
    print(num+integer) //输出结果是?

结果:编译不过。因为Swift是一个强类型语言


从Object-C向Swift过渡

接下来将会从Protocol,block,GCD等大家在Object-C里熟知的内容开始,一步步过渡到Swift3.0。

**1.protocol
2.block
3.GCD
4.property
5.函数
6.extension,category
7.可选类型?与??
8.类型判断与转换
9.id类型与Any,AnyObject,nil
10.typedef与typealias
11.宏定义
12.混合编程
13.API设计与函数命名对比**

1.protocol

Swift也和OC一样有protocol,但不同的是Swift的protocol可以被class,struct,enum实现,甚至还能进行extension扩展。
参考:Protocols

  • Protocol以及optional protocol定义

//Object-C
@protocol RefreshHeaderDelegate <NSObject>
@optional
   - (void)willBeginRefresh:(PullRefreshHeader*)header;
   - (void)didRefresh:(PullRefreshHeader*)header;
@required
   - (void)didFinishRefresh:(PullRefreshHeader*)header;
@end

//Swift
@objc protocol RefreshHeaderDelegate {
    @objc optional func willBeginRefresh(header:PullRefreshHeader) -> Void
    @objc optional func didRefresh(header:PullRefreshHeader) -> Void
}

//加了classprotocol才能被使用在类的delegate模式中,因为protocol不加class标记则还可以被enum,struct实现
protocol RefreshHeaderDelegate :class{
    func willBeginRefresh(header:PullRefreshHeader) -> Void
    func didRefresh(header:PullRefreshHeader) -> Void
}
  • 定义了optional方法后,如何判断delegate是否实现了该方法?
//Object-C
if([self.delegate respondsToSelector:@selector(willBeginRefresh:)]){
  //执行delegate的方法
  [self.delegate willBeginRefresh:self];
}

//Swift中我们可以更优雅的实现,optional是很方便的
self.delegate?.willBeginRefresh?(header: self)

2.block

Swift中任何两个{}之间的代码都算是闭包,因此函数也是一种特殊的闭包。
参考:closure-expressions-in-swift

  • 闭包定义
//Swift闭包定义
{ (obj:AnyObject) ->Void in
  //闭包内容开始
  print(obj)
  pring($0)
  //可以用$<index>来指向闭包的形参,下标从0开始
}
  • 如何避免闭包中的循环引用?
//Object-C
__weak __typeof(self) __weak_self = self
[button onClicked:^(MttTopBannerButton * button) {
    MttBottomBanner *banner=[[MttBottomBanner alloc] init];
    [__weak_self.view addSubview:banner];
    [banner show];
    button.hidden=YES;
 }];

 //Swift更优雅
button.onClicked({
    [weak self]
    (button:MttTopBannerButton) ->Void in
    var banner = MttBottomBanner()
    self?.view.addSubview(banner)
    banner.show()
    button.hidden=true
})
  • weakself,strongself
//Swift
DispatchQueue.main.sync(execute: {
    [weak self]
    (_:AnyObject?) ->Void in
    self?.draw()
    self?.color=UIColor.white()
    DispatchQueue.main.sync(execute: {
        if let strongSelf=self {
            strongSelf.lock.lock()
            strongSelf.layer.contents=strongSelf.display?.cgImage
            strongSelf.lock.unlock()
        }
    })
})

//请思考为何此处我是NSLock来加锁?
//因为Swift里没有@synchonized关键字的替代品了啊,需要的话,得自行调用GCD接口实现了.

//Object-C
__weak __typeof(self) __weak_self = self
dispatch_async(dispatch_get_main_queue(),^{
    [self draw];
    self.color=[UIColor whiteColor];
    __typeof(__weak_self) strongSelf = __weak_self
    dispatch_async(dispatch_get_main_queue(),^{
        [strongSelf.lock lock];
        strongSelf.layer.contents=strongSelf.display.CGImage;
        [strongSelf.lock unlock];
    })
});

3.GCD

Grand Dispatch Queue在Object-C中是一组C语言接口,虽然在swif1,swift2中仍保留了这种用法习惯,但它毕竟不太符合一门强类型与面向对象的语言的要求(就像这些人取消了++,–运算符一样,无时无刻不再想着摒弃老式的C语言编程思维),于是Swift3中GCD终于也面向对象了.

  • dispatch_async
//Swift
DispatchQueue.main.async(execute:{blk(nil)})

//Object-C
dispatch_async(dispatch_get_main_queue(),^(id obj){
});
  • dispatch_after
//Object-C
- (void)performBlockOnMainThread:(void (^)())block afterDelay:(CGFloat)delay
{
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        block();
    });
}

//block参数可为空,因为是optional
func performOnMainThread(_ block:AsyncLoaderTask? ,delay:Double) -> Void {
    if let blk=block {
        let time=DispatchTime.now()+delay
        //DispatchWorkItem相当于之前的dispatch_queue_t所以直接用
        DispatchQueue.main.after(when:time,execute:{blk(nil)})
    }
}

4.Property属性

在Swift中类里定义了的变量或常量即是属性

属性分为2种:

  • 存储型属性
    跟Object-C的property基本差不多
  • 计算型属性
    比较特别,并不是用于真正的存储一个值或变量,而是提供了getter和setter方法来间接的获取其他属性或变量的值。其本身的存在价值是依赖于其它属性或变量的存在

1.属性定义
2.属性观察器
3.getter,setter
4.delegate模式
5.普通属性
6.lazy标记
7.optional属性
8.completion block模式
9.初始化

typealias AsyncLoaderTask = (_:AnyObject?) ->Void
class PullHeaderTable: UITableView {

    // MARK: Public Properties
    //////////////
    //1.标准属性定义方式
    //常量属性,以及属性定义的两种方式,可以隐身让Swift自行推断类型,也可以明确指定类型
    let source=PullHeaderTableSource()
    let src : PullHeaderTableSource = PullHeaderTableSource()
    var s : PullHeaderTableSource = PullHeaderTableSource()

    //////////////
    //2.property观察器
    var data : [AnyObject]?{
        didSet{
            source.data=data
            print(oldValue)
        }
        willSet{
            print(newValue)
        }
    }

    //////////////
    //3.getter,setter,通过getter返回的,叫做计算型属性
    var src : PullHeaderTableSource  {
        get{
            return PullHeaderTableSource()
        }
        set{
            print(newValue)
        }
    }

    //////////////
    //4.delegate模式
    weak var tableDelegate : PulllHeaderTableDelegate?

    //////////////
    //5.普通属性,必须在init方法里最先被初始化
    var header : UIView

    //////////////
    //6.lazy标记,该属性只会在被调用时自动调用初始化赋值,而不是在init之前就初始化了,thread unsafe
    lazy var footer = UIView()

    //7.optional属性
    var listener : AnyObject?

    //8.optional block属性(和OC的completion block模式)
    var completion : AsyncLoaderTask?

    //////////////
    //9.对于非optional的属性,在init时必须要初始化,否则会出错
    //init初始化与OC的不一样,是先把当前实例的非optional属性初始化完毕,然后再调用父类的init
    //原因在于Swift定义了的任何类型property编译器都不会给默认值,因此非optional property必须在init中有优先初始化

    init(frame:CGRect) {
        header=UIView()
        super.init(frame:frame, style:UITableViewStyle.plain)
        self.onCreate()
    }

    required init?(coder aDecoder: NSCoder) {
        header=UIView()
        super.init(coder: aDecoder)
        self.onCreate()
    }

    override init(frame:CGRect,style:UITableViewStyle){
        header=UIView()
        super.init(frame: frame, style: style)
        self.onCreate()
    }

    deinit {
        self.dataSource=nil
        self.delegate=nil
    }

    // MARK: Private Functions
    private func onCreate() -> Void {
        self.scrollsToTop=false
        self.separatorColor=UIColor.clear()
        self.separatorStyle=UITableViewCellSeparatorStyle.none
        self.contentOffset=CGPoint.zero
        self.delegate=source
        self.dataSource=source
    }
}

5.函数

使用 func 来声明一个函数,使用名字和参数来调用函数。使用 -> 来指定函数返回值的类型。
参考:Functions

1.如何让函数返回多个返回值?
2.如何传入1个或N个参数
3.重构->函数内嵌套函数
4.函数类型与函数返回值,函数参数

Swift的函数相比较于OC发生了很多很好的改进,我们可以更自由的使用定义函数了.
同时还加入了函数类型。
参考:函数类型

class App: NSObject {

    func test() {
        print(calculate(scores: [0,1,2,3,4,5]))
        print(sumOf(numbers: 0,1,2,3,4,5))
        runAnotherFunction(longlongFunction)
    }

    // MARK:Function Usage
    //1.使用元组返回多个返回值
    //下述函数从数组中返回最小,最大,求和.返回值是一个元组.
    //其中调用了Swift里的min,max函数,全局泛型函数,用于比较大小返回结果.
    //min,max函数类似于OC宏定义的MIN(),MAX()
    func calculate(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
        var vmin=scores[0]
        var vmax=vmin
        var sum : Int = 0
        for val in scores {
            vmin=min(vmin, val)
            vmax=max(vmax, val)
            sum+=val
        }
        return (vmin,vmax,sum)
    }

    //2.传入可变个数的参数
    func sumOf(numbers: Int...) -> Int {
        var sum=0
        for val in numbers {
            sum+=val
        }
        return sum
    }

    //3.嵌套函数,用于部分代码的重构,其实也可以里面定义一个block一样的。不过比OC多了个选择
    func longlongFunction() {
        var x=10
        //猜猜看 _ 这里下划线的作用?看看如何调用的你就会明白了
        func increament(_ val:Int) -> Int {
            return val+1
        }
        print(increament(x))
        func add() {
            //x++
            //Swift 3.0不支持++,--了哦
            x=x+1
        }
        add()
    }

    //4.函数作为参数,当然函数也可以作为返回值的.函数类型
    func runAnotherFunction(_ fun: () -> ()) {
        fun()
    }
}

6.extension,category

Swift中没有category的概念,因为Swift中的extension基本涵盖了所有原先Object-C中需要的一切

1.添加计算型属性和计算型静态属性
2.定义实例方法和类型方法
3.提供新的构造器
4.定义下标[]
5.定义和使用新的嵌套类型
6.支持协议

参考:下标运算符

extension String {
    func toHex() -> String {
        return ""
    }
}

protocol AppProtocol: class {
    func app() -> Void
}

class App: NSObject {
    var data : Array = Array<Int>()
    static var instance = App()
    private override init() {
        for i in 0...8 {
            self.data.append(i)
        }
    }
}

extension App: AppProtocol {

    //////////////
    //1.添加计算性属性,存储型的不可以啊
    var hashCode : Int {
        return Int(Date.timeIntervalSinceReferenceDate)+8
    }

    //非法,存储性属性不能再extension里存在
    //var newProperty : Int = 0

    //////////////
    //2.添加新的构造函数
    convenience init(_ id:Int, time:Int) {
        self.init()
    }

    //////////////
    //3.函数或实现协议
    func app() -> Void {
        print("app")
    }

    //////////////
    //4.为对象实现下标运算符
    subscript(index: Int) -> Int {
        get{
            return self.data[index]
        }
        set{
            self.data[index]=newValue
        }
    }

    //////////////
    //5.嵌套类型,class,enum,也就是相当于定义内部类
    class UI : NSObject {
    }
}

func testApp() -> Void {
    let app = App.instance
    app[0]=1
    print(app[1])
}

7.可选类型?与??

可空链式调用(Optional Chaining)
这个名词太专业了,我们就简单的来谈谈吧

定义属性或变量时,如果要允许一个属性为空即nil,像Object-C一样的话。那么我们需要制定其位optional类型
只需定义结束末尾在加一个?符号即可,如下

var obj : AnyObject?
//定义了一个相当于Object-C的 id obj=nil;东西

对于optional类型的变量或方法(如optional protocol method)我们在调用时需要把optional类型的值/对象取出来,这一步叫做unwrap;反之定义时就叫wrap;
通过?来unwrap或者直接利用!来强制unwrap(强制的前提是你能确保变量是有有效值的),如下

var str : String?
str="value"
//前面已经为str赋值过了,所以我们是已知强制unwrap是不会有异常的
if str!.characters.count>0 {
}

//如果签名没有为str赋值,或者不确定有值与否,需要尝试unwrap
if str?.characters.count>0 {
}

var count : Int
count=str?.characters.count ?? 0
print(count)

大家是否在好奇上述的??符号到底是什么意思呢?很简单,如果你理解选择表达式,那么可以把它看做对于optional类型的选择表达式吧
等价于如下代码

if str != nil {
    count=str!.characters.count
}
else
{
    count=0
}

8.类型判断与转换

1.在Object-C中我们经常会对一个id类型或者不确定具体类型的实例对象做类型判断,如isKindOfClass;在Swift中我们可以更简单来实现

参考:Type Casting

is类型检查运算符

//Object-C判断类型
UIView *v=XXX;
if([v isKindOfClass:[UIWindow class])
{
}

//Swift
var v=XXX
if v is UIWindow {
}

2.在Object-C中我们要做类型转换可以直接使用C语言的方式来强制类型赋值,但在Swift中需要用as运算符实现

as 用于向上转型(upcasts)
as? 和as! 用于向下转型(Downcasting)

备注:
1.向上转型:由派生类转为父类对象
2.向下转型:有父类对象转为具体子类对象

当不确定类型转换是否成功时,用类型转换的条件形式( as? )
as?如果失败会返回nil
当确定一定是时,用强制形式式( as! )

//Object-C
for(UIViewController *ct in controllers)
{
    if([ct isKindOfClass:[MttBaseViewController class]])
    {
        NSLog(@"MttBaseViewController");
    }
    else if([ct isKindOfClass:[MttRootViewController class]])
    {
        NSLog(@"MttRootViewController");
    }
}

//Swift
for ct in controllers {
    if let mtt = ct as? MttBaseViewController {
            print("MttBaseViewController")
    } else if let nav = ct as? MttRootViewController {
            print("MttRootViewController")
    }
}

9.id类型与Any,AnyObject,nil

Any 和 AnyObject 是 Swift 中两个妥协的产物;

AnyObject 可以代表任何 class 类型的实例
Any 可以表示任意类型,甚至包括方法 (func) 类型

AnyObject用于在Swift中替换Object-C的id类型;
Swift中编译器不会对 AnyObject 实例的方法调用做出检查,甚至对于 AnyObject 的所有方法调用都会返回 Optional 的结果。因此使用AnyObject实例之前我们务必需要检测对象是否存在和类型有效性。
参考:ANY 和 ANYOBJECT

nil:
Swift中的nil与Object-C的nil是不一样的。Object-C中,nil是一个指针指向一个不存在的object。在Swift中,nil不是指针,而是对于特定类型的缺省值。任何optional类型都可以设置为nil,而不仅仅是对象类型;
optional类型变量的值默认就是nil;

10.typedef与typealias

typealias相当于Object-C中的typedef,用来为已经存在的类型重新定义名字。通过命名,可以使代码变得更加清晰。
参考:swift-typealias,typelias

//重命名闭包,和Object-C一样
typealias AsyncLoaderTask = (_:AnyObject?) ->Void
func submit(_ block:AsyncLoaderTask?,completion:AsyncLoaderTask?) -> Void {
    if let blk=block {
        self.queue.async(execute:{
            blk(nil)
            if let cmp=completion {
                cmp(nil)
            }
        })
    }
}

//protocol组合
protocol changeName{
    func changeNameTo(name:String)
}
protocol changeSex{
    func changeSexTo(sex:String)
}
typealias changeProtocol = protocol<changeName,changeSex>
struct Person:changeProtocol{
  func changeNameTo(name:String){
  }
  func changeSexTo(sex:SEX){
  }
}

//swift中很多类型别名即是typealias定义的
public typealias AnyClass = AnyObject.Type
public typealias NSInteger = Int

11.宏定义

很抱歉,Swift中终于不支持宏定义了。
Object-C中的宏暴露到Swift中的话,只有简单展开宏会被直接变为同名常量。
参考:converting-complex-objective-c-macros-swift-functions,Objective的宏到swift

//Object-C
#defien MTT_DEBUG 1

//Swift
let MTT_DEBUG = 1 
//以上二者等价

其余复杂的宏定义以及宏嵌套都无法被翻译到Swift里,也无法在Swift中调用或使用。
所以要使用宏,只能在Object-C中使用.

12.混合编程

处于某些目的,我们还是有必要在Swift代码中使用Object-C,或者在Object-C代码中装一下样子,搞点Swift。那这时就涉及到混合编程了。
参考:混和编程

1.OC中使用Swift
在工程的 Build Settings 中把 defines module 设为 YES.即可.(如需必要,再把把 product module name 设置为项目工程的名字。理论上不需要了,XCode 8.0已经默认是这样了)
最后一步,在你的OC文件中导入 ProjectName-Swift.h.即(productModuleName-Swift.h)

2.Swift中使用OC
Swift代码引用OC,需依靠 Objective-C bridging header 将相关文件暴露给Swift。
创建 Objective-C bridging header 有两种方法

a.当你在Swift项目中尝试创建OC文件时,系统会自动帮你创建 Objective-C bridging header
b.自己创建 Objective-C bridging header
File > New > File > (iOS or OS X) > Source > Header File
切记,名字 一定要 是 项目工程名-Bridging-Header.
然后还有一步,在项目的 Build Settings 选项里,要确保Swift Compiler 选项里有这个 Bridging Header 文件的设置,路径必须指向文件本身,而不是目录!

13.API设计与函数命名对比

篇幅原因,这里就不copy&&paste了,大家可以自行看原文或者译文。这是一篇很好的API设计指导,终于可以抛弃Object-C的冗长命名了。
参考:Swift API设计 , 译文


参考资料

结语

如果你在一门语言上,可以看到很多让你曾痴狂,压抑,热爱,也失望的特性时。那就一定是Swift了。
本文比较了Swift3.0和Object-C在开发中主要的一些差别,限于篇幅(已经很长了)与作者本人认知能力,并未对Swift中更多特性做介绍或深究。如有疏漏或错误还望指正。
Swift就像一个四不像,因为var而像javascript,因为@objc而又保留了Object-C特性,因为内部类而多了点Java的影子,因为deinit而带了些c++的气味。但无论如何,Swift必定是将来!
参考:About Swift

2015-05-11 15:33:30 xiao562994291 阅读数 2564
  • 由浅入深学习PHP面向对象

    面向对象程序设计简称oop是英文全称“Object-Oriented Programming”,面向对象程序设计更加符合人的思考逻辑和对事物处理。面向对象程序设计的语言为编程人员开了一扇大门,使代码更简洁,便于维护,可强的重用性。 课程难点: 面向对象的编程思想,在开发过程中对于新手从“面向过程”到“面向思想”转变。

    2254 人正在学习 去看看 李强

Object-C调用Swift,

创建Swift文件,然后在需要调用Swift文件的地方加上

#import "工程名-Swift.h"

Swift调用 Object-C

创建Swift文件的时候,会出现问是否要创建Bridging-header.h.当然点击Yes。

把你要引用的oc文件头文件写到里面就可以了。在Swift文件里就可以引用了。

调用C++

把Object-c文件改成Object-C++。就是把.m改成.mm。然后就可以写C++代码了。

Swift引用C++必须首先引用object-c;


悦览播放器

2015-06-12 15:26:13 love_monkey 阅读数 757
  • 由浅入深学习PHP面向对象

    面向对象程序设计简称oop是英文全称“Object-Oriented Programming”,面向对象程序设计更加符合人的思考逻辑和对事物处理。面向对象程序设计的语言为编程人员开了一扇大门,使代码更简洁,便于维护,可强的重用性。 课程难点: 面向对象的编程思想,在开发过程中对于新手从“面向过程”到“面向思想”转变。

    2254 人正在学习 去看看 李强

新建的项目默认使用的swift语言,创建后,需要引入object-c的代码,这时候需要

1.创建一个 header文件

工程名-Bridging-Header.h

2.设置path

在target-Build Settings-Swift Compiler -Code Generation中的Object-c Bridging Header 填入此文件的路径,这个路径是基于项目工程文件夹的,写的时候注意,如果出错,看日志查路径即可。

3.import文件

在header文件中import相应的oc文件即可。

2016-02-01 23:49:24 zlk961616596 阅读数 374
  • 由浅入深学习PHP面向对象

    面向对象程序设计简称oop是英文全称“Object-Oriented Programming”,面向对象程序设计更加符合人的思考逻辑和对事物处理。面向对象程序设计的语言为编程人员开了一扇大门,使代码更简洁,便于维护,可强的重用性。 课程难点: 面向对象的编程思想,在开发过程中对于新手从“面向过程”到“面向思想”转变。

    2254 人正在学习 去看看 李强
随着现在Swift语言的崛起,很多人已经开始用Swift语言做开发了,但是由于现在很多第三方框架仍然使用object-c开发,所以这个时候Swift和object-c混合编程显得举足轻重了。

object-c 调用 swift:
1.创建好object-c语言的工程后,新建一个swift语言的cocoa touch class文件(这里取名为HelloSwift)
2.在swift文件中编写好需要被调用的代码。
3.在需要调用swift的object-c文件中引入一个头文件#import “你的项目工程名-Swift.h”
4.初始化HelloSwift *hello = [[HelloSwift alloc] init]; 就可以用hello变量调用Swift中的函数了
swift 调用 object-c:
1.创建好swift语言的工程后,在项目工程目录中创建一个object-c语言的cocoa touch class文件,并同意创建桥接文件.
2.在你的object-c语言的文件中编写你要给swift调用的代码。
3.在桥接文件中引入object-c语言文件的头文件import "xxx.h"(xxx是你的object-c文件名)
4.在swift中的调用之需要定义一个类的变量 var object = xxx(),就可以用变量object去调用xxx中的函数了。

2015-08-18 15:27:49 jinglijun 阅读数 5002
  • 由浅入深学习PHP面向对象

    面向对象程序设计简称oop是英文全称“Object-Oriented Programming”,面向对象程序设计更加符合人的思考逻辑和对事物处理。面向对象程序设计的语言为编程人员开了一扇大门,使代码更简洁,便于维护,可强的重用性。 课程难点: 面向对象的编程思想,在开发过程中对于新手从“面向过程”到“面向思想”转变。

    2254 人正在学习 去看看 李强

1、创建一个Object-C工程:SwiftInObjectC


2、创建一个Object-C的类:SwiftLan(注意选择)


当创建完成后,Xcode提示下面警告,会提问我们需不需要创意一个Bridge,当然我们选择“Yes”。


这样会在工程中看到一个“SwiftInObjectC-Bridging-Header.h”文件。这个文件的作用可以根据注释看出来:


//
//  Use this file to import your target's public headers that you would like to expose to Swift.
//

3、下面一步是我们要修改“Bulid Setting” 中的 Defines Module 设置为“Yes” ,同时再看看Product Name 是不是工程的名字。如果是就不用管了

如果不是就改为工程名字。


4、在ViewController中引入头文件 #import "SwiftInObjectC-Swift.h"SwiftInObjectC是设置的Product Name

5、在修改我们创建的SwiftLan 类如下:

class SwiftLan: NSObject {

    /*
    // Only override drawRect: if you perform custom drawing.
    // An empty implementation adversely affects performance during animation.
    override func drawRect(rect: CGRect) {
        // Drawing code
    }
    */
    @objc(initWithData:)
    init(data: String){
        println(data);
    }

}

6、在ViewController类中创建实例子如下:

   SwiftLan *tempString = [[SwiftLan alloc] initWithData:@"Test Swift"];
   NSLog(@"%@",tempString);

7、然后Build & Run 可以在 控制台看见:


运行OK,说明我们已经成功在OC中使用了Swift 方法和类。

8、下面看看二个动效的Swift类,同样的方法:

[self.view addSubview:({
        NVActivityIndicatorType type  = NVActivityIndicatorTypePacman;
        NVActivityIndicatorView *temp = [[NVActivityIndicatorView alloc] initWithFrame:CGRectMake(0,0,80,80) type:type];
        temp.center = self.view.center;
        [temp startAnimation];
        temp;
    })];
    
    [self.view addSubview:({
        _testLabel = [[LTMorphingLabel alloc]initWithFrame:CGRectMake(0,200,self.view.bounds.size.width,80)];
        _testLabel.text = @"";
        _testLabel.textAlignment = NSTextAlignmentCenter;
        _testLabel.textColor = [UIColor whiteColor];
        _testLabel.font = [UIFont systemFontOfSize:28];
        _testLabel;
    })];
效果如下:


9、说明的一点是Swift的 Enum和 OC的 Enum 的 转换 :

原来的:

public enum NVActivityIndicatorType  {
    case Blank
    case BallPulse
    case BallGridPulse
    case BallClipRotate
    case SquareSpin
}

添加新的:

@objc public enum NVActivityIndicatorType :Int{
    case Blank
    case BallPulse
    case BallGridPulse
    case BallClipRotate
    case SquareSpin
}
做了上面的转变后在OC中就可以使用Swift的Enum类型了

使用方法如下:

       //NVActivityIndicatorType type  = NVActivityIndicatorTypePacman;
       //NVActivityIndicatorType type  = NVActivityIndicatorTypeBallClipRotate;
       //NVActivityIndicatorType type  = NVActivityIndicatorTypeBallScale;

注意是NVActivityIndicatorType无缝连接 具体某个枚举的类型Pacman,变为了“NVActivityIndicatorTypePacman”


源代码下载





没有更多推荐了,返回首页