swift 如何强转对象类型

2016-07-05 10:14:34 yxys01 阅读数 1579

swfit和OC间的区别

  1. swift句尾不需要分号 ,除非你想在一行中写三行代码就加分号隔开。
  2. swift不要写main函数 ,程序默认从上往下执行
  3. swift不分.h.m文件 ,一个类只有.swift一个文件
  4. swift不在有地址的概念
  5. swift数据类型都会自动判断 , 只区分变量var 和常量let
  6. 强制转换格式反过来了 OC强转:(int)a Swift强转:int(a)
  7. 整数的数据类型可以通过 .min.max获得最大和最小值
  8. 定义类型的别名语法改变 OC:typedef int MyInt Swift:typealias MyInt = int
  9. swift的模除取余运算符支持小数了 。 如 5%1.5 = 0.5
  10. 关于BOOL类型更加严格 ,swift不再是OC的非0就是真,而是true才是真false才是假
  11. 与第10点相联系的就是, swift的赋值运算符没有返回值 。防止误用“=”和“==”
  12. swift可以多对多赋值 。 let(x,y) = (1,2)
  13. swift的 循环语句中必须加{} 就算只有一行代码也必须要加
  14. swift的switch语句后面以前只能跟整数, 现在可以跟各种数据类型了 ,如浮点字符串都行,并且里面不用写break,如果不想要没break的效果 即后面的都想执行 那就写上关键字 fallthrough(注意:在fallthrough后面就不能再定义常量变量了)

接下来都是一些 swift独有 的性质了

1、swift独有的范围运算符

a...b 表示 [a,b]  如3...5  就是范围取345

a..<b 表示[a,b)  如3..<5 就是取范围34

可以直接写在 for-in 循环中,或者if判断中 如 for x in 0...5 {}

2、swift独有的溢出运算符

默认情况下,当你往一个整型常量或变量赋于一个它不能承载的大数时,Swift不会让你这么干的,它会报错。这样,在操作过大或过小的数的时候就很安全了。

var potentialOverflow = Int16.max
// potentialOverflow 等于 32767, 这是 Int16 能承载的最大整数
potentialOverflow += 1
//  出错了

当然,你有意在溢出时对有效位进行截断,你可采用溢出运算,而非错误处理。Swfit为整型计算提供了5个&符号开头的溢出运算符。

&+,&-,&*,&/,&%

这里用上溢出做个举例

var willOverflow = UInt8.max          // willOverflow 等于UInt8的最大整数 255

willOverflow = willOverflow &+ 1      // 这时候 willOverflow 等于 0

大概原理是 进了一位 物极必反

这里写图片描述

3、swift独有的元组类型

var point = (x:15,y:20.2)

就是元组名是 point ,里面有两个元素x和y。有点类似于结构体但是不是。

想取出里面的x的值赋值就是 point.x = 30 或者point.0 = 30 (注:元组里面的许多元素可以看作有数组的下标)

可以省略内部元素的名称 var point = (15,20.2) 但是这样的话,想取出值就只能用point.0 = 30 这一种方法了,因为人家没有元素名了好吧。

也可以明确指定元组内每一个元素的类型,假如那个20.2我不想要double类型 我想要是float类型。可以 var point = (Int,String) = (15,20.2)

注意:元组名称和类型不能共存 ,比如你指定类型了 后面就不可以再指定名称了 var point = (Int,String) = (x:15,y:20.2)

如果你想打印的话就写println(point) 打印出来就是(10,20.2)

并且在初始化的时候也可以用下划线省略不需要的元素 如 var point = (_ ,20.2);

4、在switch语句中使用元组类型时还可以用类似SQL语句的语法 添加过滤条件

switch point{

  case let(x,y) where x== y:

      println("x与y的值相等");

  等等。。。。。。

}

5、函数的外部参数名

函数原来的格式是这样(箭头后面是返回值) func Sum (num1:Int,num2:Int) -->Int{}

调用时是 Sum(20,20)

加外部参数名的话在方法调用时可读性更好,是写在原参数名的前面, 调用时也必须书写

func Sum(numone num1:Int,numtwo num2:Int) -->Int{}

调用时写 Sum(numone:20,numbertwo:20)

如果觉得这样有点麻烦,可以让外部参数名和内部参数名一样

就是 func Sum (#num1:Int,#num2:Int) -->Int{}

调用时写 Sum(num1:20,num2:20)

6、函数的默认参数值

func addStudent (name:string,age:Int = 20) -->string{}

设置了默认的年龄为20 所以再调用时只需要写个名字

addStudent("james")

要注意的是,使用了默认参数值, 系统会自动生成一个外部参数名。

想改名字也就要写外部参数名了 即 addStudent("james",age:18)

7、函数的输入输出参数

在函数声明时就用inout代替var 这样以后可以在函数内部修改外面的值 类似于C语言的传入指针

func change (inout num:Int) {
  num = 10
}
var a = 20
change(&a)

得到的结果就是10

(注意:写了输入输出参数就不能再用默认函数值的语法了)

用输入输出参数,实现多个返回值功能

func SumAndMinus(num1:Int,num2:Int,inout sum:Int,inout minus:Int){
  sum = num1 + num2
  minus = num1 - num2
}
var sum = 0 ,minus =0
SumAndMinus(20,5,∑,−)

原文:swift与OC之间不得不知道的21点

其他变化:

一、

       swift终于放弃了objective-c那幺蛾子般的 [ obj method:x1 with:x2] 的语法,终于跟随了大流,变成了obj.method( )的顺眼模式。虽然对于objective-c的程序员来说,这些[ ]看上去特显酷 , 你们知道就是这个中括弧吓跑了多少c++, java , c#的程序员嘛?所以说这个小小的变化,可以让苹果的开发更平易近人,对有其他开发语言基础的人来说更友好。
       但苹果不会这么自甘平庸,我们知道objective-c里方法的调用有种语法是其他主流语言没有的,那就是标签。我们在使用java, c++, c, c#等语言时,如果使用 rect.set( 10, 20, 100, 500 ), 虽然在写set方法的时候,IDE有提示四个形参的含义,但写完后,鬼知道这句代码中10, 20, 100, 500是啥意思?(我是举了个简单的例子,不要因此怀疑我的智商!)。所以代码的可读性就变的很差, 而objective-c很完美的解决了这个问题 :

  [ rect setX:10 y:20 width:100 height:500 ]

       看看!多棒!swift当然不会丢弃这么好的传统, 在swift中是这个样子的

rect.set( 10, y:20, width:100, height:500 )

       看看!!!完美吧!
       对于调用方法时,标签的使用需要注意以下两点:

1、全局函数的调用,不可以使用标签

fun( 11, 22 , 33 ) //正确✅
 fun( n1:11, n2: 22, n3: 33 ) //错误❌

2、类的函数,第一个参数不可以加标签 。

rect.set( 100, y:100, width:300, height: 200 ) //正确✅
rect.set( x:100, y:100, width:300, height: 200 ) //错误❌

其实swift中对类的定义和java, c#几乎一样,再也不分头文件和.m文件了。
一个类的定义语法如下:

class Weapon
{
    var name:NSString
    var power:int
    init( name:NSString, power:int )
    {
        self.name = name
        self.power = power
    }
    func shoot( )
}

       注意:swift中的语句不需要分号结束( swift在吸引幼齿入swift大法方面无不用其极!)
       其次,终于有构造函数和析构函数了!!!objective-c也有?no no no!!!objective-c中才没有构造函数,真正的构造函数是系统自动调用的,而不是强迫程序员去调用。以前要强迫程序员[ [ Obj alloc ] init ], 傻哇? 如果程序员比较笨比较呆忘记写init咋办? 现在终于终于终于系统自动调用了!!!

Weapon weapon = Weapon( name:“人间大炮”, power: 100000000000 )

       我才没有写错, 对的!现在和java, c#一样!虽然weapon是一个指针,但不要写那颗星号!!因为这颗星号吓死过好多人!“ 啥?指针?!!啊。。。。。”(吓死了)

       c, c++的程序员注意了,这个weapon对象不是分配在栈内存上的, 仍然是alloc出来的, 在堆上呢。

二、最期待的语法终于加入了!

       对于override在java,c++,objective-c中都有问题,举个栗子:

@interface Weapon
-(void)shoot;
@end

@interface Gun : Weapon
-(void)Shoot;
@end

       在大项目中经常会遇到这个问题,程序员的本意是希望覆盖父类的shoot ,结果手潮。。。。写成了Shoot,这既没有语法错误,也没有逻辑错误,结果在

Weapon*  currentWeapon = [ Gun new ];
[currentWeapon shoot ]; 

中调用的却是父类的shoot方法( 因为子类根本没有覆盖啦,子类大小写不小心写错了 ), 这种小错误如果出现在超大型项目种还真是很难找呢!!现在,swift终于解决这个问题啦! 子类覆盖父类方法的时候,一定要在方法前写上override

override func shoot{
}

这样,编译器一看方法前写了override, 它就会在父类中去查找是否有shoot方法, 如果你写错成override func Shoot, 那编译器就立刻能发现报错啦!
原文:http://www.cocoachina.com/bbs/read.php?tid-204294-page-1.html

2015-08-24 21:33:55 u010586842 阅读数 3016

异常处理、类型转换 ( Any and AnyObject )

注:本文为作者倾心整理 , 希望对大家有所帮助!


1、错误处理 (异常处理)

swift 提供第一类错误支持 ,包括在运行时抛出 ,捕获 , 传送和控制可回收错误。在swift中 ,错误用复合 ErrorType 协议的值表示 。 Swift枚举把一系列相关的错误组合在一起。同时可以把一些相关的值和错误关联在一起 。 因此

编译器会为实现ErrorType协议的Swift枚举类型自动实现相应的合成

这里看个很简单的小例子。

enum WrongName:ErrorType{
    case NoName
}

错误处理 1、抛出
在方法后面加上throws 关键字

func doSomeThing(name:String) throws ->String {
    if(name.isEmpty){
        throw WrongName.NoName
    }
    print("no error")
    return name
}

当字符位空 , 我们就 throw 这个异常 。
在调用一个抛出函数的时候 需要在调用前面加上try

try doSomeThing("eat")    //这里并没有出现异常  会输出 no error
try doSomeThing("")  //会产生运行时错误 error caught in main()

这里抛出了错误但是没有处理 。

2、捕捉和处理错误 do-catch 语句来捕捉和处理错误

语法 :

do {

}catch parttern{

}

如果一个错误被爆出 , 这个错误会被传递到外部域 ,直到被catch捕捉处理 ,pattern 是用来匹配错误和相应的执行语句。

swift处理异常和别的语言不同的是swift不会展开调用堆栈 。 那样会带来很大的性能损耗 。 在swift中 throw 语句的性能几乎和return一样

do{
    try doSomeThing("")
}catch WrongName.NoName{
    print("NoName error!")
} //输出NoName error!

通过try!来调用抛出函数或者方法 来禁止错误传输 。并把调用包装在运行时断言,这样就不会抛出错误啦。如果帧抛出错误, 会触发运行时错误

func willThrowIfTru(value:Bool) throws{
    if value {
        throw NotTrue.BeTrue
    }
}

do{
    try willThrowIfTru(true)
}catch {
    print("不能为true呀")
}
//这里会输出 不能为true呀 --没有疑问 
try! willThrowIfTru(false)  //这块禁止了错误传输 意思断言肯定不会有异常 , 如果有 就会报错

收尾操作

使用defer 执行的语句 不管有没有出错都回执行到 。相当于其他的finally

defer 语句和的执行顺序和它定义顺序相反 也就是说 , 第一个difer语句中的代买在第二个后执行 。

    func willThrowIfTru1(value:Bool) throws{

        if value {
            throw NotTrue.BeTrue
        }
    }
  do{
            try willThrowIfTru1(true)
        }catch {
            print("不能为true呀")
        }


        defer{
            print("我后执行")
        }

        defer{
            print("我先执行")
        }
        print("我第一个执行")
        结果:
        不能为true呀
        我第一个执行
        我先执行
        我后执行

2、类型转换

Swift 中使用is 和 as操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型

  • 用类型检查操作符(is)来检查一个实例 是否属于特定子类型
class Person{
    var name:String
    init(name:String){

        self.name=name
    }
}

var  p = Person(name: "wangwu")
if p is Person
{
    print("yes")
}

这里输出yes , 转换这种明显的没有什么意思 。来看看下面的、


class Student: Person {

}
class Teacher: Person {

}

let list = [ Student(name: "张三") , Student(name: "李四") , Teacher(name: "王五") ]

这里会推断出是一个[Person] 数组

var stuCount = 0
var teaCount = 0

for item in list {

    if item is Student {
        stuCount++
    }
    if item  is Teacher{
        teaCount++
    }
}
print("stu :\(stuCount) , tea: \(teaCount)")
//stu :2 , tea: 1

这里利用is推断出具体类型

  • 向下转型
    某类型的一个常量或变量可能在幕后实际上属于一个子类 这时候 你可以尝试向下转型 用as! 或者 as? 向下转型可能会失败 。as? 返回你试图转型的可选值 。 as! 强制转型 ,非常确定的时候再用 否则会运行时错误 。

所以上面的例子还能这么写

stuCount = 0
teaCount = 0

//这里使用了可选绑定 以前的章节有讲过
for item in list {

    if let s = item as? Student {
        stuCount++
    }
    if let t = item  as? Teacher{
        teaCount++
    }
}
print("stu :\(stuCount) , tea: \(teaCount)")
//stu :2 , tea: 1

结果是一模一样的

  • Any 和 AnyObject 的类型
    Swift为不确定类型提供了两种特殊类型别名:
    AnyObject可以代表任何class类型的实例。
    Any可以表示任何类型,包括方法类型(function types)。(2.0新特性)
let student:[AnyObject] = [Student(name: "ww"),Student(name: "aa"),Student(name: "dd")]
//这里定义了一个[AnyObject] 类型的数组  ,但是确定是放得student  所以你可以强制转型
let stu = student[0] as! Student
print(stu.name)  //aa
let stus = student as! [Student]
//你可以直接强制转换成一个Student数组
print(stus.count) //3

下面看下 Any类型

var things = [Any]()

things.append("str")
things.append(0.9)
things.append(stu)
things.append(stus)


for item in things {
    switch item {
    case let val as Double:
        print("\(val)  是个数字类型")
    case let val as String:
         print("\(val)  是个字符串")
    case let val as Student:
        print("\(val)  是Student对象")
    case let val as [Student]:
        print("\(val)  是个[Student]数组")
    default:
        print("啥都不是")
    }
}

结果 :

str  是个字符串
0.9  是个数字类型
Student  是Student对象
[Student, Student, Student]  是个[Student]数组

再不确定类型的时候才使用这两个 ,确定的时候最好使用确定类型

2017-07-12 17:20:45 xuzenghuifeng 阅读数 1795

AnyObject

官方api中AnyObject的介绍分为三方面内容,看完相信你会有所收获

The protocol to which all classes implicitly conform. //隐含类型确认协议

You use AnyObject when you need the flexibility of an untyped object or when you use bridged Objective-C methods and properties that return an untyped result. AnyObject can be used as the concrete type for an instance of any class, class type, or class-only protocol.
当你需要灵活的类型或者当你调用返回未知类型结果的oc方法和属性时,你需要使用AnyObject。
AnyObject可以作为任何类,类的类型(type),或者是类协议的有型的类型来使用。
For example:
//例如

     class FloatRef {
         let value: Float
         init(_ value: Float) {
             self.value = value
         }
     }
     let x = FloatRef(2.3)
     let y: AnyObject = x
     let z: AnyObject = FloatRef.self

AnyObject can also be used as the concrete type for an instance of a type that bridges to an Objective-C class.
Many value types in Swift bridge to Objective-C counterparts, like String and Int.
AnyObject也可以被用作为一个oc对象的有型的类型。swift中的许多值类型和oc里面的是相通的,比如StringInt

 let s: AnyObject = "This is a bridged string." as NSString
     print(s is NSString)
     // Prints "true"

     let v: AnyObject = 100 as NSNumber
     print(type(of: v))
     // Prints "__NSCFNumber"

The flexible behavior of the AnyObject protocol is similar to
Objective-C’s id type. For this reason, imported Objective-C types
frequently use AnyObject as the type for properties, method parameters,
and return values.
AnyObject协议的灵活性与oc中的id是类似的。由于这个原因,AnyObject被频繁地作为oc类的属性、方法参数的类型来使用

Casting AnyObject Instances to a Known Type //抛出AnyObject对象给一个已知类型

Objects with a concrete type of AnyObject maintain a specific dynamic type and can be cast to that type using one of the type-cast operators
(as, as?, or as!).
This example uses the conditional downcast operator (as?) to conditionally cast the s constant declared above to an instance of Swift’s String type.
固定的类型的AnyObject对象具有一个具体的动态类型,并且可以使用(as, as?, or as!)被抛向那个具体的类型。下面的例子使用(as?)抛向上面声明的Swift中String 类型的对象s

     if let message = s as? String {
         print("Successful cast to String: \(message)")
     }
     // Prints "Successful cast to String: This is a bridged string."

If you have prior knowledge that an AnyObject instance has a particular
type, you can use the unconditional downcast operator (as!). Performing
an invalid cast triggers a runtime error.
如果你事先知道AnyObject 对象的详细类型,可以使用 (as!)。执行无效的抛向操作会引起运行时错误。

  let message = s as! String
     print("Successful cast to String: \(message)")
     // Prints "Successful cast to String: This is a bridged string."

     let badCase = v as! String
     // Runtime error

Casting is always safe in the context of a switch statement.
但在switch 语句中抛向操作是不会引起运行时错误的。

    let mixedArray: [AnyObject] = [s, v]
     for object in mixedArray {
         switch object {
         case let x as String:
             print("'\(x)' is a String")
         default:
             print("'\(object)' is not a String")
         }
     }
     // Prints "'This is a bridged string.' is a String"
     // Prints "'100' is not a String"

Accessing Objective-C Methods and Properties //访问OC方法和属性

When you use AnyObject as a concrete type, you have at your disposal every @objc method and property—that is, methods and properties imported from Objective-C or marked with the @objc attribute. Because Swift can’t guarantee at compile time that these methods and properties are actually available on an AnyObject instance’s underlying type, these @objc symbols are available as implicitly unwrapped optional methods and properties, respectively.

当你使用 AnyObject 作为一个有型的类型,你必须处理每一个带 @objc 标记或者来自于oc的方法和属性。因为Swift不能保证 潜在类型的AnyObject对象的这些方法和属性是真正可用,带有@objc 标记的方法和属性会分别在暗中被解绑。

This example defines an IntegerRef type with an @objc method named
getIntegerValue().
这个例子定义了一个IntegerRef ,它有一个标记了@objc 方法 getIntegerValue()

     class IntegerRef {
         let value: Int
         init(_ value: Int) {
             self.value = value
         }

         @objc func getIntegerValue() -> Int {
             return value
         }
     }

     func getObject() -> AnyObject {
         return IntegerRef(100)
     }

    let obj: AnyObject = getObject()

In the example, obj has a static type of AnyObject and a dynamic type of IntegerRef. You can use optional chaining to call the @objc method getIntegerValue() on obj safely. If you’re sure of the dynamic type of obj, you can call getIntegerValue() directly.
这个例子中 ocj有一个AnyObject静态类型和一个IntegerRef动态类型。 你可以使用可选链通过 obj调用带有 @objc标记的方法getIntegerValue()。如果你确定obj的动态类型,你可以直接调用。

  let possibleValue = obj.getIntegerValue?()
     print(possibleValue)
     // Prints "Optional(100)"

     let certainValue = obj.getIntegerValue()
     print(certainValue)
     // Prints "100"

If the dynamic type of obj doesn’t implement a getIntegerValue()
method, the system returns a runtime error when you initialize
certainValue.
Alternatively, if you need to test whether obj.getIntegerValue() exists, use optional binding before calling the method.
如果动态类型obj没有getIntegerValue()方法,当你初始化certainValue的时候,系统会出现运行时错误。除非,你调用这个方法之前,先使用可选的绑定检验下obj.getIntegerValue()是否存在

  if let f = obj.getIntegerValue {
         print("The value of 'obj' is \(f())")
     } else {
         print("'obj' does not have a 'getIntegerValue()' method")
     }
     // Prints "The value of 'obj' is 100"
2019-08-29 09:46:07 YoYo_Newbie 阅读数 105
//单个值操作,例如data是个Any类型,要强转成String
    func test( data:Any?)->String{
        guard let dataStr = data as? String else {return "" }
        return dataStr
    }
    func test( data:Any?){
        //获取引用并访问,例如data是个Any,但本质是个字典类型
        guard  let argumentsG =  data as? Dictionary<String, String>,
            let val1 =  argumentsG["xxx"],
            let val2 =  argumentsG["xxx"]
            else {return }
        print(val1)
        print(val2)
    }

 

2015-08-28 15:13:57 lwjok2007 阅读数 4310

Swift 中对象是可以转换的,因为面向对象就会涉及继承,子类,父类等等

有几点规则我们先说一下

子类对象可以直接转换为父类对象的

父类对象可以有条件的转换为子类对象,这个我们下边在讲


首先我们创建三个类  人 Homan  男人 Man  男孩 Boy

Man 继承 Homan 

Boy 继承 Homan


那么,就可说  Man 是 Homan 的子类 

Boy 是 Homan的子类

Homan  是 Man的父类

Homan 是 Boy的父类


class Homan{
    var name=""
    init(homanName:String){
        name=homanName
    }
    //自我介绍
    func Introduce(){
        println("I'm Homan My name is \(name)")
    }
}


class Man:Homan {
    var workName=""
    override func Introduce() {
        println("I'm Man  My name is \(name)  My workname is \(workName)")
    }
}


class Boy:Homan {
    var schoolName=""
    override func Introduce() {
        println("I'm Boy My My name is \(name)  schoolname is \(schoolName)")
    }
    
}


首先我们看 子类转为父类

        //1,子类对象可以直接转换成父类对象(向上转型,直接转)
        var h:Homan=Man(homanName: "张三")
        h.Introduce()
        
        var h1:Homan=Boy(homanName: "小马")
        h1.Introduce()


接下来 我们讲子类转为父类

        //2,父类对象转为子类对象 as!   as?
        
        //父类对象转换为子类对象 需要使用as!(如果当前对象是父类对象,但是他如果是子类对象转化过来的,那么可以转化回去
        var man1=h as! Man
        man1.workName="ios 开发"
        man1.Introduce()
        
        //如果要转化为子类对象,但是当前对象并不是这个子类对象转化过来的,那么会出现运行时错误:Could not cast value of type
//        var man2=h1 as! Man
        
        //如果我们需要将当前父类对象转为子类对象但是并不确定 当前对象是否为子类对象转化过来的,该如何处理? Swift为我们提供一个方法 as?
        if let a = h as? Man{
            a.workName="iOS 测试"
            a.Introduce()
        }else{
            println("非子类对象")
        }
        
        if let a = h1 as? Man{
            a.workName="iOS 测试"
            a.Introduce()
        }else{
            println("非子类对象")
        }
        
        

还有一种情况是 不知道当前对象是否为子类对象转为父类对象的

        //3 如何判断某一个对象是不是这个类的对象 可以 使用 对象 is 类 来判断
        
        //我们会发现判断子类对象是不是父类对象返回也是true
        println(h is Homan)
        println(h is Man)
        println(h is Boy)
        



好了 基本完成,有问题可以继续讨论

苹果开发群 :414319235  欢迎加入  欢迎讨论问题