(OC and Swift Mixed)

After the swift language comes out, it may be possible for new projects to be developed directly using swift, but there may be situations in which some classes that have been written with OC or packaged modules are not ready to be written again in Swift, which uses a mash-up. This is allowed in the IOS8.

First of all, first of all, research in the same project directory under the mixed use situation.

For demonstration. Prepare two classes first

The first is the Swift language class, the file name is Act.swift

[CPP]View Plaincopy

2. Import Foundation
6. Class Act:nsobject
8. {
10. Func hasact (tag:int), String
12. {
14. switch (TAG)
16. {
18. Case 1:return "Movie"
20. Case 2:return "CCTV"
22. Case 3:return "Sport TV"
24. default:return "area TV"
26. }
28. }
32. Init ()
34. {
36. println ("Act constructor is called.")
38. }
42. Deinit
44. {
46. println ("Act destroyed is called.")
48. }
50. }

The second is the class header file written with OC as OCChannel.h, implementing the file as OCCHANNEL.M

Header file

[CPP]View Plaincopy < param name= "wmode" value= "Transparent" >

1. #import <Foundation/Foundation.h>
3. @interface Occhannel:nsobject
5. @property (Nonatomic,retain) NSString *channelname;
7. -(NSString *) Channelchange: (Nsinteger) channels;
9. @end

Implementation file

[CPP]View Plaincopy

2. #import "OCChannel.h"
4. #import "Swiftmodule-swift.h"
8. @interface Occhannel ()
10. {
12. ACT *act; Class of//swift
14. }
16. @end
20. @implementation Occhannel
24. -(ID) init
26. {
28. if (self = [super init]) {
30. NSLog (@"OC Constructor is called.");
32. //Use Swift class
34. act = [[Act Alloc]init];
36. }
38. return self;
40. }
44. -(void) Dealloc
46. {
48. NSLog (@"OC destroyed is called.");
50. //[act Release];//arc not use
52. //[super Dealloc];//arc not use
54. }
58. -(NSString *) Channelchange: (Nsinteger) channels
60. {
62. return [Act Hasact:channels];
64. }
68. @end

This occhannel is a class act written by Swift. Mainly to demonstrate that in the same project, the Swift class calls OC, while the OC class also calls Swift. Thus forming a mixed-writing pattern.

Here are the specific steps:

1. Create a new Swift project: I'm here for the project named Mixdemo.

Built after the project:

2. Is the introduction of the previous two classes, we first to each one. Because it's swift, we'll start by referencing OC files in Swift Engineering

Using OC in Swift

First, the way the header files and. m files are no longer used in swift. Therefore, you do not need to import the header file using import "". How swift can access the class declaration of the OC.

In fact, Swift also needs to be accessed with a header file, but it is no longer necessary to import it explicitly using import. There are two ways to implement the generation of this header file.

mode one: in a new swift, the bridge header file is automatically added using the first new prompt.

Click OK this will generate a header file with <produceName-Bridging-Header.h>.

After the construction of the project:

Here is a place to note is the Targets->build settings->object-c bridging header is set to which bridge header file can be.

After the above steps, the bridge file is ready to be

Let's get the OC header file you want to call in the Swift class and use the import "" to write to this bridging file. Just like:

[CPP]View Plaincopy < param name= "wmode" value= "Transparent" >

1. //
2. Use the This file to import your target's public headers so would like to expose to Swift.
3. Mixdemo/mixdemo-bridging-header.h
5. #import "OCChannel.h"

Similarly, once you know the relationship of this swift search header file, you don't need to bother with this-bridging-header.h file. You can build one by hand and take your favorite name. Such as:

Way two:

Create a new header file named: OCContainerHeader.h

Well, the above setup will completely satisfy the class that Swift uses OC to write.

[CPP]View Plaincopy

2. Import UIKit
6. Class Viewcontroller:uiviewcontroller {
10. Override Func Viewdidload () {
12. Super.viewdidload ()
14. additional setup after loading the view, typically from a nib.
18. //Call OC class
20. var channel = Occhannel ()
22. println (channel. Channelchange (10))
24. println (channel. Channelchange (2))
26. }
30. Override Func didreceivememorywarning () {
32. Super.didreceivememorywarning ()
34. //Dispose of any resources, can be recreated.
36. }
42. }

Okay, here's another look at how OC calls the Swift-written class . (In fact, if you are 1:1 copy me this demo, which congratulations you, in the above you will compile does not pass.) Because my OC class refers to a class written by Swfit, you have to comment on which act's class you want to run. ）

How OC invokes Swift-written classes

To use OC, you must have a header file. The swift file does not have a header file, where we must also produce a header file. However, the header file for the OC call to Swift is quite special. Because the mechanism inside the header file is automatically generated, in unfamiliar, not recommended handwriting.

How to produce this header file. (Note that the system-Set header file is not visible in the project.) ）

Production steps:

Select targets->build Settings->packing->product module name, which is important the name of the swift header is named after this.

Although you see this import "Swiftmodule-swift.h" in the picture, but you can not find this file in the entire project, but the use of cmd+ mouse click to see the contents of this header file.

In this way, in the case of Swift to use OC in the project, the need to use the OC class header file, all written in the mixdemo-bridging-header.h. Also if the use of the Swift class OC, only need to clean one, and then make up, but do not forget to import swiftmodule-swift.h Oh (name pick, but-swift.h is fixed), there is another need to pay attention to the reader.

Note:

If a class that is written with Swift does not follow a derived class from NSObject or NSObject, then the corresponding transformation class will not be generated after compilation. This makes it possible for OC to not find the corresponding declaration.

As in my example, class Act would not be compiled into Swiftmodule-swift.h, but written as Class Act:nsobject, you can compile the corresponding declaration. You can also use @objc to declare, but this is still the same, the class best inherit nsobject down. Just like the following:

[CPP]View Plaincopy

2. Import Foundation
6. @objc (ACT)
10. Class Act
12. {
14. Func hasact (tag:int), String
16. {
18. switch (TAG)
20. {
22. Case 1:return "Movie"
24. Case 2:return "CCTV"
26. Case 3:return "Sport TV"
28. default:return "area TV"
30. }
32. }
36. @objc (init)//Originally thought to add this alloc can be found, but not ...
38. Init ()
40. {
42. println ("Act constructor is called.")
44. }
48. Deinit
50. {
52. println ("Act destroyed is called.")
54. }
56. }

But when it comes to use, you'll find

act = [[Act Alloc]init]; Error, can not find alloc, it is recommended that everyone still inherit nsobject.

Well, write it up today and look at the mixing of frameworks .....

(OC and Swift Mixed)