swift 接收oc返回的参数_ios swift接收oc的回调事件 - CSDN
  • 本文分别介绍这2种方式.1:Storyboard的方式 跳转,传递参数 首先选中 一个Button –> 按住 control 键–> 然后拖拽到需要跳转的 ViewController接着选中中间的曲线, 在右边的属性窗口中 为segue添加 identifier ...

    UIViewController的跳转,可以在Storyboard里面通过拖拽Segue进行跳转,也可以在代码中进行跳转.

    本文分别介绍这2种方式.

    1:Storyboard的方式 跳转,传递参数
    首先选中 一个Button –> 按住 control 键–> 然后拖拽到需要跳转的 ViewController

    接着选中中间的曲线, 在右边的属性窗口中 为segue添加 identifier (唯一哦)
    这里写图片描述

    之后,在Button所在的ViewController中重写prepareForSegue方法

    override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
    if segue.identifier == "navTest" {//注意此处.
        var params: String
        params = "参数"
    
        //主要就是通过类型强转,然后通过拿到的对象进行成员变量的赋值,相对于Android,这真的是简单粗暴
        let nav2Controller = segue.destinationViewController as! ViewController2
        nav2Controller.param = params
        }
    }

    2:通过代码的方式 跳转,传递参数

    首先,选中一个 ViewController, 为 Storyboard 添加一个唯一标识id
    这里写图片描述

    @IBAction func onTestNav() {
    if let testVC = self.storyboard?.instantiateViewControllerWithIdentifier("testStory") {
        let vc = testVC as! TestViewController
        vc.modalTransitionStyle = .CrossDissolve // 选择过渡效果
        vc.params = "参数传递" // 参数赋值
    
        self.presentViewController(vc, animated: true, completion: nil)
    }

    3:返回参数

    首先在需要接受返回值的ViewController中,添加一个func(如下)

    @IBAction func onClose(segue: UIStoryboardSegue) {
        //同样也是暴力的强转...
        let nav2 = segue.sourceViewController as! ViewController2
        print(nav2.backParam)
    }

    其次在Storyboard中(操作如下):
    选中需要返回的Button, 然后按住 control键, 拖拽到exit图标处, 放手后,会出现刚刚在上面的步骤中出现的方法.选中它,即可.
    这里写图片描述

    4:通过delegate返回参数
    首先,定义个protocol,用来表示delegate
    这里写图片描述

    其次,在跳转的时候, 为delegate 赋值.
    这里写图片描述

    ViewController还需要实现这个Protocol
    这里写图片描述

    这样就完成了,delegate的参数返回传递.


    至此: 文章就结束了,如有疑问: QQ群 Android:274306954 Swift:399799363 欢迎您的加入.

    展开全文
  • 该项目主要介绍了ocswift之间、swift内部几种常见的传值方式(属性传值、代码块传值、代理传值、通知) 如果ocswift之间的桥接有疑问请参考:OCswift桥接互调 项目介绍 1、swift之间的页面跳转与返回...

    该项目主要介绍了oc与swift之间、swift内部几种常见的传值方式(属性传值、代码块传值、代理传值、通知)

    如果oc与swift之间的桥接有疑问请参考:OC与swift桥接互调

    项目介绍

    • 1、swift之间的页面跳转与返回
    • 2、oc监听swift推送的通知
    • 3、swift内部推送接收的通知
    • 4、oc调用swift的代理方法
    • 5、swift调用oc代码块
    • 6、oc对swift的属性传值、方法调用、代码块调用
    • 7、swift对oc的属性传值、方法调用、代码块调用
    • 8、swift之间的传值

    1、swift之间的页面跳转与返回

    1、present方式跳转

     @objc func btnAction(_ sender:UIButton){
            let subVC  = SubVC();
            self.present(subVC, animated: true) {
                NSLog("������:%@", subVC);
            };
            NSLog("������:%@____%@",sender,self);
        }

    2、返回

    self.dismiss(animated: true) {
                    NSLog("返回");
                };

    2、oc监听swift推送的通知:

    • swift发送通知
     func postNotifition(){
            NotificationCenter.default.post(name: NSNotification.Name(rawValue: "XMNotification"), object: "通知方法");
        }
    • oc接收通知
    -(void)addNotification{
        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(notiAction:) name:@"XMNotification" object:nil];
    }
    
    -(void)notiAction:(NSNotification *)sender{
        NSLog(@"oc:%@",sender.object);
    }
    
    -(void)removeNotification{
        [[NSNotificationCenter defaultCenter] removeObserver:self name:@"XMNotification" object:nil];
    }
    

    3、swift内部推送接收的通知:

     func postNotifition(){
            NotificationCenter.default.post(name: NSNotification.Name(rawValue: "XMNotification"), object: "通知方法");
        }
    
        @objc func addNotification(){
            NotificationCenter.default.addObserver(self, selector: #selector(notificationAction(_:)), name: NSNotification.Name(rawValue: "XMNotification"), object: nil);
        }
        @objc func removeNotifition() {
            NotificationCenter.default.removeObserver(self);
        }
    
        @objc private func notificationAction(_ noti : Notification){
            let str:String = noti.object as! String;
            print("swift:" + str);
        }

    通知打印结果

    4、oc调用swift的代理方法:

    • 编辑协议方
    ///1、编辑协议
    @objc(FourVCDelegate)
    protocol FourVCDelegate {
        func backSuperVC(str:String)
    }
    
    ///2、定义协议对象
    @objc var myDelegate:FourVCDelegate?;
    
    ///3、调用协议
    let str:String = "代理方法"
    self.myDelegate?.backSuperVC(str: str);
    • 签署协议方
    ///1、调用协议
    @interface FirVC ()<FourVCDelegate>
    
    ///2、签署协议
    -(SecVC *)seVc{
        if (!_seVc) {
            _seVc = [SecVC new];
            _seVc.myDelegate = self;
        }
        return _seVc;
    }
    
    ///3、协议实现
    -(void)backSuperVCWithStr:(NSString *)str{
        NSLog(@"%@", str);
    }
    

    代理协议打印结果

    5、swift调用oc代码块

    • oc文件类
    ///代码块定义
    @property(nonatomic,strong)void (^thiBlock)(NSString *str);
    
    ///代码块实现
    !self.thiBlock?:self.thiBlock(@"swift调用oc代码块");
    • swift文件类
    
    let vc  = ThiVC();
    ///代码块调用
    vc.thiBlock = {(str) -> () in
        print("代码块方法");
    }
    
    self.present(vc, animated: true, completion: {
    
    });

    提示

    6、oc对swift的属性传值、方法调用、代码块调用

    • swift方法类
    import UIKit
    
    class FourVC: UIViewController {
    
        ///数组
        @objc var arr0:NSArray = NSArray()
    
        ///无参数无返回值
        @objc func swMethod0(){
            print("无参数无返回值");
        }
        ///有参数无返回值
        @objc func swMethod1(str: String)  {
            print("有参数无返回值:\(str)");
        }
        ///有参数有返回值
        @objc func swMethod2(str: String) -> (String){
            return "有参数有返回值:" + str;
        }
    
        /// mark - 代码块
        ///无返回参数
        @objc func bkBlock0(response:() -> ()){
            response();
        }
        ///返回一个字符串参数
        @objc func bkBlock1(response:(_ res : String) -> ()) {
            response("返回一个字符串参数");
        }
        ///返回多个任意类型参数
        @objc func bkBlock_2_(response:(_ res : Any,_ res1 : Any) -> ()) {
            response(self.arr0, "无参数,返回多个任意类型参数:");
        }
        ///传入多个参数 并返回多个任意类型的参数
        @objc func bkBlock3(p1:Any,p2:Any,p3:Any,res:(_ res0 : Any ,_ res1 : Any ,_ res2:Any,_ res3:Any) -> ()) {
            res("传入多个参数 并返回多个任意类型的参数:\n",p1, p2, p3);
        }
        ///Block带返回值
        @objc func bkBlock4(res:() -> ()) -> (String){
            res();
            return "Block带返回值"
        }
    
    
        //定义block
        typealias fucBlock = (_ backMsg : String?) ->()
        func bkBlock4(cmdStr:String?,blockProperty:fucBlock){
            blockProperty("backMsg---by block inside func")
        }
    
        override func viewDidLoad() {
            super.viewDidLoad()
            self.view.backgroundColor = UIColor.yellow;
            print("属性传值结果:",self.arr0[0],self.arr0[1],arr0[2]);
        }
    
        override func didReceiveMemoryWarning() {
            super.didReceiveMemoryWarning()
            // Dispose of any resources that can be recreated.
        }
    
        override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
            self.dismiss(animated: true) {
    
            };
        }
    }
    
    • oc方法类:
        FourVC *vc = [FourVC new];
        // --- 属性传值 ---
        vc.arr0 = @[@"可以",@"可以",@"可以"];
    
        /// ------ 方法调用 -----
    
        //无参数无返回值
        [vc swMethod0];
        //有参数无返回值
        [vc swMethod1WithStr:@"dasda"];
        //有参数有返回值
        NSString *str = [vc swMethod2WithStr:@"sdfasda"];
        NSLog(@"%@",str);
    
        /// ------ 代码块调用 -----
    
        [vc bkBlock0WithResponse:^{
            NSLog(@"无返回数据代码块");
        }];
    
        //有一个返回值
        [vc bkBlock1WithResponse:^(NSString * str) {
            NSLog(@"%@", str);
        }];
    
        //有两个返回值
        [vc bkBlock_2_WithResponse:^(id str, id str1) {
            NSLog(@"%@\n%@",str1,str);
        }];
    
        //有参数有返回值
        [vc bkBlock3WithP1:@"ds" p2:@"dsa" p3:@"das" res:^(id p0,id p1, id p2, id p3) {
            NSLog(@"%@\n%@\n%@\n%@",p0,p1,p2,p3);
        }];
    
        [self presentViewController:vc animated:YES completion:^{
    
        }];
    

    此处输入图片的描述

    7、swift对oc的属性传值、方法调用、代码块调用

    • xxx.h文件
    @interface OcVC : UIViewController
    ///代码块
    @property(nonatomic,strong)void (^clickBlock)(void);
    ///字符串
    @property(nonatomic,copy)NSString *titStr;
    ///方法
    -(void)testAction;
    @end
    
    • xxx.m文件
    - (void)viewDidLoad {
        [super viewDidLoad];
        NSLog(@"%@",self.titStr);
        !self.clickBlock?:self.clickBlock();
    }
    
    -(void)testAction{
        NSLog(@"调用方法");
    }
    
      xxx.swift文件
    
    let sub  = OcVC();
    //属性传值
    sub.titStr = "属性传值";
    //方法调用
    sub.testAction();
    
    //代码块调用
    sub.clickBlock = { () -> () in
         print("不带参数代码块")
    };
    
    sub.clickBlock();
    self.present(sub, animated: true, completion: {
    
    });

    打印结果

    8、swift之间的传值

        func jumpToNextVC(){
            ///mark - =============
            let foVC =  FourVC()
    
            let dic:NSDictionary = ["key":1,"key1":2];
            let arr0:NSMutableArray = ["你好","好不好"];
    
            // mark -  属性传值
            foVC.arr0 = arr0;
    
            //方法调用
            foVC.swMethod0();
            foVC.swMethod1(str: "da");
            let str = foVC.swMethod2(str: "ddd");
            print(str);
    
            // mark -  代码块回调
            foVC.bkBlock0 {
                print("你可以的");
            };
            foVC.bkBlock1 { (res) in
                print(res);
            }
            foVC.bkBlock_2_{ (res, str) in
                print(res, "+", str);
            }
            foVC.bkBlock3(p1: "1", p2: "2", p3: "3") { (res0, res1, res2, res3) in
                print(res0,res1,res2,res3);
            }
            self.present(foVC, animated: true) {
    
            };
        }

    原文地址:https://blog.csdn.net/weixin_38633659/article/details/81569207

    展开全文
  • OCSwift混编

    2016-01-26 10:16:30
    Swift发展势头越来越好,而很多公司很难一下子从OC全部切换到swift,这个时候混编就显得那么的重要,本人也在逐渐的尝试混编然后逐步取代OC,从而全部转到swift上。 其实,从2014年swift刚出来的时候就开始研究swift...

    Swift发展势头越来越好,而很多公司很难一下子从OC全部切换到swift,这个时候混编就显得那么的重要,本人也在逐渐的尝试混编然后逐步取代OC,从而全部转到swift上。

    其实,从2014年swift刚出来的时候就开始研究swift的相关语法及定义了,但是由于公司很难转变,所以一直也没有运用到实践当中,这个时候就非常佩服那些小公司,或者应该叫初创公司,没有任何的烦恼,新开发的app都是运用swift。。。非常羡慕。。。

    好了,废话不多说,看看用法吧。。

    首先,我们有一个OC项目的工程,我这边叫MixDemo,这个时候需要新增一个swift的类,与添加OC类一样,只是选择的语言选择swift。


    由于我的工程是OC的工程,添加一个swift文件的时候,苹果会问开发者要不要添加一个bridge,我们需要添加这样一个桥接。


    这个时候我们会看到我们的工程里面多了一个MixDemo-Bridging-Header.h的文件

    我们在swift文件中添加一个方法,返回一个字符串:

    class Test4SwiftVC: NSObject {
        func f1() -> String {
            return "Test Mix"
        }
    }
    那么问题来了,如何在OC的.m文件中调用该方法呢?

    我们先看看工程文件里面的build Settings:

    看到红色标注出来的地方,默认是工程名称-Swift.h,我们自定义为SwiftModule-Swift.h,以方以后修改工程名称的时候出错。这个文件就是我们在OC类中调用swift类的引用头文件,这个类在工程中看不到,但是我们可以Command+点击查看这个类的内容:


    此时需要将工程Clean下,然后在OC的实现文件中,引用该头文件,即可调用swift中的类了:

    - (void)viewDidLoad {
        [super viewDidLoad];
        Test4SwiftVC *VC = [[Test4SwiftVC alloc] init];
        [VC f1];
        // Do any additional setup after loading the view, typically from a nib.
    }
    这样我们就可以在OC中调用swift中的f1方法了。


    那么在swift中怎么调用OC的方法或者变量呢?

    我们在ViewController中定义一个字符串:

    #import <UIKit/UIKit.h>
    
    @interface ViewController : UIViewController
    @property (strong, nonatomic) NSString *str;
    
    @end

    还记得我们一个的桥接文件么?似乎我们还没用到吧,这个时候就派上用场了。

    我们在MixDemo-Bridging-Header.h中添加OC的头文件:

    #import "ViewController.h"

    然后在swift文件中就可以引用啦。。。

    func f2() {
            var vc = ViewController()
            var str: String = vc.str
        }

    我们在swift中定义了第二个函数,定义一个变量vc去初始化ViewController这个类,然后定义一个String类型的变量来接收OC类中的参数,这样就可以互相调用啦,调用OC中的函数也是同样的道理,大家可以自己去研究。。。





    展开全文
  • 但是目前苹果公司还在不端更新和改变swift,甚至在语法层面还在不断探索,虽然xcode提供一些直接适配新版本swift语法的快捷键,但给我们学习不免造成一些影响,这里是基于swift3.0和oc的一些基础性知识的比较。

    swift无疑是IOS程序员的未来,但是目前苹果公司还在不端更新和改变swift,甚至在语法层面还在不断探索,虽然xcode提供一些直接适配新版本swift语法的快捷键,但给我们学习不免造成一些影响,这里是基于swift3.0和oc的一些基础性知识的比较。

    一 基础部分

    1.Swift的类型是在C和Objective-C的基础上提出的,Int是整型;Double和Float是浮点型;Bool是布尔型;String是字符串。Swift还有两个有用的集合类型,Array和Dictionary,(类型第一个字母大写)

    2.Swift还增加了Objective-C中没有的类型比如元组(Tuple)。元组可以让你创建或者传递一组数据,比如作为函数的返回值时,你可以用一个元组可以返回多个值。

    元组(tuples)把多个值组合成一个复合值。元组内的值可以使任意类型,并不要求是相同类型。

    let http404Error =(404,"Not Found")

    (404,”Not Found”)元组把一个Int值和一个String值组合起来表示HTTP状态码的两个部分:一个数字和一个人类可读的描述。这个元组可以被描述为“一个类型为(Int,String)的元组”。

    你可以把任意顺序的类型组合成一个元组,这个元组可以包含所有类型。只要你想,你可以创建一个类型为(Int,Int,Int)或者(String,Bool)或者其他任何你想要的组合的元组。

    你还可以通过下标来访问元组中的单个元素,下标从零开始:

    println("The status code is \(http404Error.0)")

    你可以在定义元组的时候给单个元素命名:

    let http200Status =(statusCode: 200,description: "OK")

    给元组中的元素命名后,你可以通过名字来获取这些元素的值:

    println("The status code is \(http200Status.statusCode)")

    注意:元组在临时组织值的时候很有用,但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用,请使用类或者结构体而不是元组。

    3.Swift还增加了可选(Optional)类型,用于处理值缺失的情况。可选表示“那儿有一个值,并且它等于x”或者“那儿没有值”。可选有点像在Objective-C中使用nil,但是它可以用在任何类型上,不仅仅是类。可选类型比Objective-C中的nil指针更加安全也更具表现力,它是Swift许多强大特性的重要组成部分。

    Swift定义的常量和变量是没有默认值的,所以引入了可选的概念,用?修饰变量,标示该变量的值可能为空也可能为某个值,然后获取的时候用!强制解析,此时必须有值,否则报运行时错误。

    比如你定义一个String类型的变量

    var str:String?
    
    str="ass"
    
    print("str=\(str!)")

    如果不使用!强制解析,可以使用可选绑定(optional binding)来判断可选是否包含值,如果包含就把值赋给一个临时常量或者变量。

    if let realstr = str
    {
    print("realstr=\(realstr)")
    }else
    {
    print("str为空")
    }

    有的函数的返回值就是可选类型,默认是使用?修饰的,也需要!强制解析或者可选绑定解析。

    let convertedNumber = possibleNumber.toInt()
    
    // convertedNumber被推测为类型"Int?",或者类型"optional 
    Int"
    if convertedNumber {
    println("\(convertedNumber!)")
    }else{
    println("could not be converted")
    }

    隐式解析可选

    有时候在程序架构中,第一次被赋值之后,可以确定一个可选总会有值。在这种情况下,每次都要判断和解析可选值是非常低效的,因为可以确定它总会有值。

    这种类型的可选被定义为隐式解析可选(implicitly unwrapped optionals)。把想要用作可选的类型的后面的问号(String?)改成感叹号(String!)来声明一个隐式解析可选。

    let possibleString: String?= "An optional string."
    
    println(possibleString!)//需要惊叹号来获取值
    
    //输出"An optional string."
    
    let assumedString: String! = "An implicitly unwrapped optional string."
    
    println(assumedString)//不需要感叹号
    
    //输出"An implicitly unwrapped optional string."

    自判断链接

    自判断链接(Optional Chaining)是一种可以请求和调用属性、方法及子脚本的过程,它的自判断性体现于请求或调用的目标当前可能为空(nil)。如果自判断的目标有值,那么调用就会成功;相反,如果选择的目标为空(nil),则这种调用将返回空(nil)。多次请求或调用可以被链接在一起形成一个链,如果任何一个节点为空(nil)将导致整个链失效。

    如果用!解析一个可选类型为空时会报运行时异常

    如果改用?解析就可以避免

    print(stu.room!.person.name)
    
    //所以报运行时错误
    room==nil 
    
    print(stu.room?.person.name)

    就打印nil

    更正规的写法可以使用if let

    如果numberOfRooms为Int类型,john.residence?.numberOfRooms就是Int?类型

    if let roomCount = john.residence?.numberOfRooms
    {
    }else
    {
    }

    如果printNumberOfRooms()返回值为Void类型,john.residence?.printNumberOfRooms()就是Void?类型

    if john.residence?.printNumberOfRooms()
    {
    }else
    {
    }

    4.常量的值一旦设定就不能改变,而变量的值可以随意更改。常量和变量必须在使用前声明,用let来声明常量,用var来声明变量。所谓改变,对于基本数据类型而言,值改变就是改变,而对于引用数据类型而言,指针指向改变才是改变。

    Swift中整数(Integer)、浮点数(floating-point)、布尔值(Booleans)、字符串(string)、数组(array)和字典(dictionaries),都是值类型,并且都是以结构体的形式在后台所实现。

    var arrcopy =arr
    //此时arr-“a,b,c”arrcopy-“abc”
    
    arrcopy[0]=“fuck”
    //此时arr-“a,b,c”arrcopy-“fuck,b,c”
    
    class Person
    {
    varname:String=“a”
    }
    
    var arr=[person1,person2,person3]
    var arrcopy =arr
    //此时arr,arrcopy指向一块区域,一同改变

    5.类型别名(type aliases)就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。

    当你想要给现有类型起一个更有意义的名字时,类型别名非常有用。假设你正在处理特定长度的外部资源的数据:

    typealias AudioSample = UInt16

    定义了一个类型别名之后,你可以在任何使用原始名的地方使用别名:
    varmaxAmplitudeFound = AudioSample.min

    6.控制流

    两种形式的for循环

    //传统获取index的语法
    for i in 010
    {
    }
    
    //快速访问对象的语法
    for obj in arr
    {
    }

    二 函数

    普通函数定义和使用

    func add(param1:String,param2:String)->String
    {
    return param1+param2
    }
    print(add(param1: "w",param2: "q"))

    可以给参数添加默认值,使用时也可以不传此参数

    func add2(param1:String,param2:String="q")->String
    {
    return param1+param2
    }
    print(add2(param1: "w"))

    inout修饰函数参数

    变量形参只能在函数本身内改变。如果你想让函数改变形参值,并想要在函数调用结束后保持形参值的改变,那你可以把形参定义为in-out形参。

    func change(param:inout String)
    {
    param="wowo"
    }
    var kaka:String="kaka"
    change(param: &kaka)
    print(kaka)//此时kaka=“wowo”

    复杂函数定义和使用
    函数可以作为形参和另一个函数的返回值

    三 类

    class Person: NSObject {
    //普通属性方法定义
    var name:String?
    func sayHi(mes:String)->String{
    return "person\(mes)"
    }
    //静态属性方法定义(属性用static修饰,方法用static或class修饰)
    static var age:String?
    class func sayMessage()
    {
    print("i am person\(age!)")
    }
    }

    属性

    lazy修饰的属性必须初始化它会在使用该属性的时候才去执行初始化的代码一般用在消耗不少时间的变量上比如文件打开

    lazy特性;局部范围的常量或变量不会延迟计算。

    set get方法

    //既有set又有get方法
    var firstName:String
    {
    get
    {
    return "first"+self.name!
    }
    
    //newValue代表set参数值
    set
    {
    self.name="setName:"+newValue
    }
    }
    
    //只有get方法
    var lastName:String
    {
    return "last"+self.name!
    }

    属性监视器

    willSet didSet方法

    willSet在设置新的值之前调用

    didSet在新的值被设置之后立即调用

    //需要设置默认值
    var idcard:Double = 0.0
    {
    
    willSet
    {
    print("willSet")
    }
    didSet
    {
    print("didSet")
    }
    
    }

    继承

    如果子类实现和父类相同的方法或者属性就是重写。必须用overriding关键字表明。

    重写overriding方法

    class Student: Person {
    override func sayHello(mes: String)-> String {
    
    //可以使用super关键字调用父类方法
    return super.sayHello(mes:mes)
    }
    
    }

    重写overriding属性

    override var name: String?
    {
    
    set
    {
    }
    get
    {
    return super.name
    }
    
    }

    原则:你可以将一个继承来的只读属性重写为一个读写属性,只需要你在重写版本的属性里提供getter和setter即可。但是,你不可以将一个继承来的读写属性重写为一个只读属性。

    防止重写

    你可以通过把方法,属性或附属脚本标记为final来防止它们被重写

    构造方法

    与Objective-C中的构造器不同,Swift的构造器无需返回值,它们的主要任务是保证新实例在第一次使用前完成正确的初始化。

    构造器分位指定构造器和便利构造器

    原则:指定构造器是向上调用的,便利构造器是横向调用的.

    规则1:指定构造器必须调用其父类的指定构造器

    规则2:便利构造器必须调用同一类中调用的其他构造器

    规则3:便利构造器必须以调用一个指定构造器结束

    //指定构造器(默认构造方法),因为父类也有该方法,所以用override
    override init()
    {
    super.init()
    print("Student init")
    }
    
    //指定构造器(自定义构造方法,父类没有该方法,不需要override)
    init(size:Double)
    {
    super.init(size: size)
    print("Student init with size")
    }
    
    //便利构造器(使用关键词convenience,需要调用自己的构造方法)
    convenience init(size:Double,friendNums:Double){
    self.init(size:size)
    self.friendNums=friendNums
    }

    类扩展

    相当于OC分类

    Swift中的扩展可以:

    1.添加计算型属性和计算静态属性

    注意:扩展可以添加新的计算属性,但是不可以添加存储属性,也不可以向已有属性添加属性观测器(property observers)

    2.定义实例方法和类型方法

    3.提供新的构造器

    4.定义下标

    5.定义和使用新的嵌套类型

    6.使一个已有类型符合某个接口

    extension Room
    {
    
    var newSize:Double
    {
    return self.size+100
    }
    
    func sayExtensionRoom(){
    print("sayExtensionRoom\(self.newSize)")
    }
    }

    四 自动引用计数

    总体基本和oc一致,在解决循环引用的问题有点区别。

    可以使用弱引用weak和无主引用unowned修饰一方变量。

    1.两个属性的值都可能是nil,并有可能产生强引用环。这种场景下适合使用弱引用。

    var a:A?
    weak b:B?

    2.一个属性可以是nil,另外一个属性不允许是nil,并有可能产生强引用环。这种场景下适合使用无主引用。

    var a:A?
    unowned b:B
    override init(){
    self.b=B()
    }

    3.两个属性都必须有值,且初始化完成后不能为nil。这种场景下,则要一个类用无主引用属性,另一个类用隐式展开的可选属性。

    var a:A!
    override init(){
    self.a=A()
    }
    unowned b:B
    override init(){
    self.b=B()
    }

    五 类型转换

    检查类型

    用类型检查操作符(is)来检查一个实例是否属于特定子类型。类型检查操作符返回true若实例属于那个子类型,若不属于返回false。

    library中添加Movie和Song

    for iteminlibrary {
    
    ifitem is Movie {
    
    ++movieCount
    
    }elseifitem is Song {
    
    ++songCount
    
    }
    
    }

    向下转型(简称下转)

    某类型的一个常量或变量可能在幕后实际上属于一个子类。你可以相信,上面就是这种情况。你可以尝试向下转到它的子类型,用类型转换操作符(as)

    如果强制转型肯定成功,可以使用as!,如果使用as?,那么返回结果成功则为该转的类型,失败则为空,此时可以使用if let来接收判断

    Any和AnyObject的转换

    Swift为不确定类型提供了两种特殊类型别名:

    1. AnyObject可以代表任何class类型的实例。

    2. Any可以表示任何类型(基础类型和class类型),除了方法类型(function types)。

    六 闭包

    Swift中的闭包与C和Objective-C中的blocks有点类似。

    闭包表达式语法

    {(parameters)-> returnTypein
    statements
    }

    捕获

    闭包可以在其定义的上下文中捕获常量或变量。即使定义这些常量和变量的原作用域已经不存在,闭包仍然可以在闭包函数体内引用和修改这些值。

    //makeIncrementor函数返回值是一个()->Int类型的函数
    func makeIncrementor(amount: Int)->()-> Int {
    var runningTotal = 0
    func incrementor()-> Int {
    runningTotal += amount
    return runningTotal
    }
    return incrementor
    }
    
    //闭包捕获amount参数的值,然后每次都可以使用
    let incrementByTen = makeIncrementor(amount: 10)
    print(incrementByTen())//10
    print(incrementByTen())//20
    print(incrementByTen())//30

    七 应用

    swift读取文件为String类型

    let path:String = Bundle.main.path(forResource: "demo2.js",ofType:nil)!
    if let spath = try?String.init(contentsOf: URL.init(fileURLWithPath: path),encoding:String.Encoding.utf8)
    {
    }else
    {
    }
    展开全文
  • OCswift的数据传输

    2018-08-10 20:02:33
    如果ocswift之间的桥接有疑问请参考:OCswift桥接互调 项目介绍 1、swift之间的页面跳转与返回 2、oc监听swift推送的通知 3、swift内部推送接收的通知 4、oc调用swift的代理方法 5、swift调用oc代.....
  • 转自译者:wongzigii(Github主页) ...Swift 会自动将一些 Objective-C 类型转换为 Swift 类型,以及将 Swift 类型转换为 Objective-C 类型。在 Objective-C 和 Swift 中也有一些具有互用性的数据类型。那些
  • 本文旨在帮助开发者快速从OC开发过渡到Swift开发,挑选了一些比较浅显的但是比较常用的Swift语法特性,在介绍的过程中,通常会拿OC中的语言特性作比较,让大家更好的注意到Swift的不同。 另外需要说明的是,笔者也...
  • 这篇文章主要给大家介绍了关于Objective-C和Swift的转换速查手册的相关资料,文中通过示例代码介绍的非常详细,非常推荐给大家参考学习使用,盛情邀请读者进入小编交流群:624212887,一起交流学习 前言 如果你正要...
  • // 对象作为方法的参数和返回值传递 #import /*  事物名称:士兵soldier  属性:姓名 身高 体重  方法:打手枪 打电话    事物名称:手枪gun  属性:弹夹 型号  方法:上弹夹    事物名称:...
  • Ocswift区别

    2016-06-17 10:13:44
    Ocswift区别 Ocswift区别(文件结构) 1.文件后缀名 oc的文件后缀名为:头文件.h 主体文件.m swift文件后缀名为:.swift   2. 代码分隔符 oc中使用分号;作为代码分隔符 swift中无需使用代码分隔符,以...
  • OC返回的是ID类型,而swift返回的是 Unmanaged! 类型,见下图。 在以前OC中,使用performSelector,直接接受返回值,然后转成需要的类型进行操作就可以了,但是在swift中是不行的,下面是按OC直接翻译成...
  • OCSwift

    2016-02-25 16:02:22
    这篇文章是自己学习Swift的笔记与深化。希望这篇文章能够帮助已经有Objective-C经验的开发者更快地学习Swift。同时也品味到Swift的精妙之处。 结论放在开头:我认为Swift比Objective-C更优雅,更安全同时也更现代,更...
  • Swift与Objective-C交互

    2019-08-10 14:36:50
    在同一个工程中是可以同时使用SwiftOC的,但不可以同时出现在同一个文件中。 OC调用Swift相关信息的方法 在***.m文件中导入工程名-Swift.h即可。 如工程名为ABC,则在需要使用Swift相关信息的.m文件中#import ...
  • import Foundation func ave(num: Array&lt;Double&gt;) -&gt; Double { var sum: Double = 0 for x in num{ sum += x } return sum / Double(num.count) } print(ave(num: [1, 2, 5])) ......
  • Swift 各种闭包各种使用 && 设置参数,函数传值
  • 学习swift第一步打印Hello World print("Hello World") swift是不用加分号的 什么是常量? 常量是在程序运行过程中不能改变值的量 什么时变量? 变量是可以在程序运行过程中不断变化的量 在swift当中常量和...
  • OC与JS互相调用并传值

    2018-01-19 11:39:43
    OC与JS间相互调用的几种方式#####第一种:使用JavaScriptCore,iOS7之后系统的原生方法,能够实现一些比较复杂的参数互传及参数返回。使用也比较简单,有以下几篇文章有比较详细的介绍。基本看完就能够熟练的使用了...
  • 目前正在学习中,只知道三种界面跳转方式 1、通过Main.storyboard 用鼠标拖拽控件到需要跳转的页面,选择 Present Modally 实现界面跳转 2、跳转到Main.storyboard 创建了 View Controller 关联代码ViewController...
1 2 3 4 5 ... 20
收藏数 1,310
精华内容 524
关键字:

swift 接收oc返回的参数