swift 如何写IDFA代码 swift decimal

9.类析构方法（deinit）的使用

//系统会自动释放不再需要的实例，以释放各种资源，在一个类的实例被释放之前，析构函数会被调用
class
{
var name: String
var age: Int
    
init(name: String, age: Int)
    {
self.name
self.age = 0
    }
    
func
    {
print("I am \(name).")
    }
    
    //使用关键词deinit来定义析构函数，析构函数是在实例释放发生之前被自动调用的
    deinit
    {
        print("I'm deinited")
    }
}

var animal5: Animal4? = Animal4(name: "Jerry", age: 33)
animal5?.say()
animal5 = nil

10.给类添加下标（subscript）

//下标是访问集合、列表、序列中的元素的快捷方式，结构体、枚举和类都可以定义下标。
class
{
var name: String = "Rocky"
var age: Int = 20
var height: Double = 130
    
    subscript(index: Int) -> AnyObject //添加一个下标操作，该下标拥有一个整型参数，并返回任意类型的对象。
    {
switch
        {
case 0:
return name as AnyObject
case 1:
return age as AnyObject
case 2:
return height as AnyObject
default:
return name as AnyObject
        }
    }
}

let person5 = Person2()
person5[0]
person5[1]
person5[2]

11.类的静态方法（class func）

//类的静态方法，也称为类型方法。实例方法是被类型的某个实例调用的方法，而静态方法则是被类型本身调用的方法。
class
{
func
    {
        print("Caculating...")
    }
func sum(num1: Int, num2: Int) -> Int
    {
alert()
return
    }
    
    //使用关键词class定义一个静态方法
class func multiply(num1: Int, num2: Int) -> Int
    {
return
    }
}

let tool = MathTool()
tool.sum(num1: 1, num2: 1)
//当需要调用静态方法时，需要使用类型而不是实例。静态方法使用方便，项目中的工具类，往往包含大量的静态方法。
MathTool.multiply(num1: 2, num2: 3)


12.讲一个类的实例作为另一个类的属性
class
{
var name: String = "Lovely Dog"
var age: Int = 1
}

class
{
var name: String = "Jerry"
var age: Int = 33
    lazy var pet: Animal5 = Animal5() //初始化一个懒加载的属性，具有懒加载特性的对象，只有在使用到它时，才会真正被加载到内存中。
}

var person7 = Person3()
person7.age = 11
person7.pet = Animal5()
person7.pet.name = "Sweety Cat"
person7

13.类的继承以及方法的重写（override）

//一个类可以继承另一个类的方法、属性和其他特性。当一个类继承其他类时，继承类叫子类，被继承类叫父类。继承是区分类和其他类型的一个重要特性。
class
{
func
    {
        print("I'm animal.")
    }
}

//父类的名称位于子类名称的后方，并用冒号进行分割
class Dog: Animal6
{
var name: String
    
init(name: String)
    {
self.name
    }
    
    //子类可以为继承来的实例方法、静态方法、实例属性或下标，提供自己定制的实现。我们把这种行为叫做重写。
    override func say()
    {
super.say()
        print("I'm a dog, my name is \(name).")
    }
}

var dog = Dog(name: "Nono")
dog.say()

14.父类在实例类型转化时的应用

class
{
var name: String
init(name: String)
    {
self.name
    }
}

class Dog1: Creature
{
var master: String
init(name: String, master: String)
    {
self.master
super.init(name: name)
    }
}

//创建作为父类的生物类型的数组
let creatures:[Creature] =
    [
Dog1(name: "Nono", master: "John"),
Dog1(name: "BAILEY", master: "Smith"),
Dog1(name: "TOBY", master: "Bill")
]

for object in creatures
{
    //通过as!标识符将遍历到的元素，将他们的类型从父类，强制转换为子类的类型。
let dog = object as! Dog1
    print("Dog: '\(dog.name)', belongs to \(dog.master)")
}

for dog in creatures as! [Dog1]
{
    print("Dog: '\(dog.name)', belongs to \(dog.master)")
}

15.使用is语句检查实例的类型

//类型检查是一种检查类实例的方式，并且也是让实例作为它的父类或者子类的一种方式
//类型检测使用is和as操作符实现。这两个操作符提供了一种简单达意的方式，去检查值的类型或者转换它们的类型。
class
{
var name: String
init(name: String)
    {
self.name
    }
}

class Dog2: Creature1
{
var master: String
init(name: String, master: String)
    {
self.master
super.init(name: name)
    }
}

class Bird: Creature1
{
var food: String
init(name:String, food: String)
    {
self.food
super.init(name: name)
    }
}

let creatures1:[Creature1] =
    [
Dog2(name: "Nono", master: "John"),
Bird(name: "MAX", food: "Bugs"),
Dog2(name: "BAILEY", master: "Smith"),
Bird(name: "CHARLIE", food: "Spider"),
Dog2(name: "TOBY", master: "Bill")
]

var dogCount = 0
var birdCount = 0

for item in creatures1
{
if item is Dog2
    {
dogCount += 1
    }
else if item is Bird
    {
birdCount += 1
    }
}

dogCount
birdCount

for item in creatures1
{
if let dog = item as? Dog2
    {
        print("Dog: \(dog.name), belongs to \(dog.master)")
    }
else if let bird = item as? Bird
    {
        print("Bird: '\(bird.name)', loves \(bird.food)")
    }
}

16.使用Any表示任意值类型

//Anyobject可以代表任何class类型的实例。此外还有一个Any，它可以表示任何类型，除了方法类型。
var anythings = [Any]() //定义一个Any类型的数组，该数组可以装载各种类型的数据。

anythings.append(8)
anythings.append(3.14156)
anythings.append("hello")
anythings.append((3.0, 5.0))
anythings

for item in anythings
{
switch
    {
case let someInt as Int:
        print("An integer value of \(someInt)")
case let someDouble as Double:
        print("A double value of \(someDouble)")
case let someString as String:
        print("A string value of \(someString)")
case let (x, y) as (Double, Double):
        print("An (x, y) point at \(x), \(y)")
    default:
        print("Something else")
    }
}