Swift从入门到放弃实例【三】
四十、 Swift从入门到放弃实例【二】
四十一、Any 和AnyObject的区别
在这里插入代码片//Any 和AnyObject的区别
//Any 可以表示任何类型包括类类型、结构体类型
//AnyObject 只能表示类类型
class Person{
var name: String
init(name: String) {
self.name = name
}
}
struct Data {
var data:String
init(data :String) {
self.data = data
}
}
var a:Any = 1
print(type(of: a))
var b:Any = true
print(type(of: b))
var c:Any = "Hello"
print(type(of: c))
var d:Any = Person(name: "小张")
print(type(of: d))
var e:Any = Data(data: "小张")
print(type(of: e))
print("------------")
var f:AnyObject = Person(name: "小张")
print(type(of: f))
//var g:AnyObject = Data(data: "小张") //报错了!!,因为AnyObject 不嫩表示结构体类型
//print(type(of: g))
//var g:AnyObject = "asd"//报错了!!,因为AnyObject 不嫩表示字符串类型
四十二、类的继承
class Person{
private var name:String
private var age:Int
init(name:String, age:Int) {
self.name = name
self.age = age
}
public func getName() ->String{
return self.name
}
public func getAge() -> Int{
return self.age
}
public func setName(param:String){
self.name = param
}
public func setAge(param:Int){
self.age = param
}
}
class Student: Person{
func play() -> String {
return "子类自己的方法"
}
}
var per = Person(name: "小张", age: 10)
print(per.getAge())
print(per.getName())
print("--------------")
var stu = Student(name: "学生", age: 2)
print(stu.getName())
print(stu.getAge())
print(stu.play())
四十三、重载
//重载
class Person{
func play(param: String) {
print("Person Play Func ... String")
}
func play(param: Int) {
print("Parson Play Func ... Int")
}
func play(params: Int) {
print("Parson Play Func ... params")
}
}
var person = Person()
person.play(param: "hello")
person.play(param: 1)
person.play(params: 1)
四十四、重写
class Person{ //不想被继承 加上 final
var name:String = ""
private var age:Int = 0
init(name:String ,age:Int) {
self.age = age
self.name = name
}
public func setName(name:String){
self.name = name
}
public func setAge(age: Int){
self.age = age
}
public func getAge() ->Int{
return self.age
}
public final func getName() ->String{ //无法重写此方法
return self.name
}
}
class Student: Person {
override var name: String{
set{
super.name = super.name + "!!" + newValue
}
get{
return super.name
}
}
override init(name: String, age: Int) {
super.init(name: name, age: age)
self.name = name
}
override func getAge() -> Int {
print("重写了getAge方法")
return super.getAge()
}
override func setAge(age: Int) {
print("重写setAge方法 ,年轻10岁")
super.setAge(age: age - 10)
}
}
var per = Person(name: "小敏", age: 100)
print(per.getName())
print(per.getAge())
var stu = Student(name: "小滨", age: 20)
print(stu.name)
stu.setAge(age: 100)
print(stu.getAge())
四十五、类型判断处理、对象相等性判断
//类型判断
class A{
}
class B: A {
var name:String
init(name:String) {
self.name = name
}
func printName() {
print("this is B name = " + self.name)
}
}
class C: A {
var name:String
init(name:String) {
self.name = name
}
func printName() {
print("this is C name = " + self.name)
}
}
func getObject(param: Int) -> A {
if param > 10 {
return B(name: "小B")
}else{
return C(name: "小C")
}
}
var t1 = A()
var t2 = A()
print(t2 === t1) //false
var t3 = t2
print(t2 === t3) //true
print("-----------")
var obj = getObject(param: 5) //var obj:A = B(name:"")
print(type(of: obj))
if(obj is B){
let p = obj as! B
p.printName()
}else if (obj is C){
let p = obj as! C
p.printName()
}
print("--------")
//可选项绑定
if let t1 = obj as? B{
t1.printName()
}else if let t2 = obj as? C{
t2.printName()
}
四十六、extension
class A{
}
extension A{
var name: String{
// get{
// return "Hello"
// }
return "Hello" //简写、等同上面
}
func print() {
Swift.print("A extension Print")
}
static func print() {
Swift.print("A extension Print")
}
}
extension String{
func toString() -> String {
return "长度:" + String(self.count)
}
}
var a = A()
a.print()
A.print()
print(a.name)
var s = "Hello"
print(s.toString())
四十七、泛型
func toString<T>(param: T) -> T{
return param
}
print(toString(param: "Hello"))
print(toString(param: 1))
print(toString(param: ["Hello","World"]))
var array:Array<Int> = [1,2,3,41,2]
四十八、协议protocol
//协议 protocol ->intface
class TestClass{
}
protocol protocol1 {
var value:String{set get}
func play1() -> String
}
protocol protocol2 {
var value2:String{get} //必须是变量。具体是不是变量由实现类决定
func play2() -> String
}
class Data: TestClass,protocol1,protocol2 {
var value: String
var value2: String{
return "Value2"
}
init(value:String) {
self.value = value
}
func play1() -> String{
return "实现play1" + value
}
func play2() -> String{
return "实现play2" + value2
}
}
var data = Data(value: "Hello")
print(data.play1())
print(data.play2())
四十九、lazy 延迟加载
//延迟属性 lazy
class Data{
init() {
print("data init")
}
func play() -> Void{
print("data play 方法")
}
}
class Test {
lazy var data:Data = Data()
init() {
print("Test Init")
}
}
var test = Test()
print("-----")
test.data.play()
/*
不加延迟加载的输出:
data init
Test Init
加延迟加载的输出:
Test Init
*/
五十、普通初始化器、可失败初始化器
//普通初始化器、可失败初始化器
class Test{
var name:String
//普通初始化器
init(name:String) {
self.name = name
}
}
var t = Test(name: "Hello")
print(t.name)
print("---------")
class Test2{
var name:String
//可失败初始化器
init?(name:String) {
if name == "unknow" {
return nil
}else{
self.name = name
}
}
}
var t1:Test2? = Test2(name: "unknow")
if t1 == nil{
print("初始化失败")
}else{
print(t1!.name)
}
print("----------")
if let p = t1{
print(p.name)
}else{
print("初始化失败2")
}
五十一、必要初始化器、 结构体成员初始化器、闭包设置初始值
//必要初始化器
class Test{
var name:String
required init(name:String) {
self.name = name
}
}
class T: Test {
required init(name: String) {
super.init(name: name)
}
}
var t = T(name: "hello")
print(t.name)
struct A{
var name: String
var age: Int
//默认系统自动生成。-> 结构体成员初始化器
// init(name:String, age:Int) {
// self.name = name
// self.age = age
// }
}
var a = A(name: "", age: 1)
print(a.age)
class B{
//闭包设置初始值
var name:String = {return "IOS"}()
var score:Int = {
var a = 10
var b = 10
return a + b
}()
var age:Int = 100
}
五十二、ARC
//必要初始化器
class Test{
var name:String
init(name:String) {
self.name = name
}
deinit {
print("对象被销毁了!" + name)
}
}
var t1:Test? = Test(name: "Hello")
var t2:Test? = t1
var t3:Test? = t2
print(t1!.name)
print(t2!.name)
print(t3!.name)
print("--------")
t1 = nil
t2 = nil
t3 = nil
print("--------")
var a:Test? = Test(name: "123")
a = nil
print("--------")
五十三、循环引用
//循环强引用
class TestA{
var name:String
weak var ref:TestB? = nil
init(name:String) {
self.name = name
}
deinit {
print("TestA 实例被释放 - " + self.name)
}
}
class TestB{
var name:String
weak var ref:TestA? = nil
weak var ref2:TestA? = nil
init(name:String) {
self.name = name
}
deinit {
print("TestB 实例被释放 - " + self.name)
}
}
var testA:TestA? = TestA(name: "A")
print(testA!.name)
print("----------")
var testB:TestB? = TestB(name: "B")
print(testB!.name)
print("---循环引用了-------")
testB?.ref = testA
testB?.ref2 = testA
testA?.ref = testB
testA = nil
testB = nil
五十四、无主引用unowned
//无主引用 unowned
//使用unowned时 永远不会为nil 使用weak时 则是可选值
class TestA{
var name:String
var ref:TestB? = nil
init(name:String) {
self.name = name
}
deinit {
print("TestA 实例被释放 - " + self.name)
}
}
class TestB{
var name:String
unowned var ref:TestA// 无主引用,不会阻止释放对象。与弱应用不同的是 他不会是nil
init(name:String,ref:TestA) {
self.name = name
self.ref = ref
}
deinit {
print("TestB 实例被释放 - " + self.name)
}
}
var testA:TestA? = TestA(name: "A")
testA?.ref = TestB(name: "B", ref: testA!)
print("----------")
//print(testA!.ref)
//testA?.ref = nil
//print(testA!.ref) //这里销毁TestB
testA = nil
//testA? = nil
//print(testA!.ref) //报错 上一部为nil了
五十五、闭包循环引用
//闭包循环引用,定义捕获列表
class TestA{
var name:String
lazy var data:() -> Void = {[unowned self]() -> Void in //weak self
//闭包持有引用
print(self.name)
}
init(name:String) {
self.name = name
}
deinit {
print("TestA 实例被释放 - " + self.name)
}
}
var t:TestA? = TestA(name: "hello")
t?.data()
t = nil
五十六、可选链展开
class Data{
var name:String
func play() {
print(self.name)
}
init(name:String) {
self.name = name
}
deinit {
print("Data 被销毁了")
}
}
class Test {
var name:String
var data:Data? = nil
init(name:String,data:Data) {
self.data = data
self.name = name
}
deinit {
print("Test 被销毁了")
}
}
var test:Test? = Test(name: "hello", data: Data(name: "world"))
(test!.data)?.play()
五十七、尾随闭包
import UIKit
//尾随闭包
func play(param:String, param2:(String) -> Void){
param2(param + "SWift")
}
play(param: " Hello1 ", param2: {(data:String) -> Void in
print(data)
})
play(param: " Hello2 ", param2: {(data) -> Void in
print(data)
})
play(param: " Hello3 ", param2: {data in
print(data)
})
//尾随闭包
play(param: " Hello4 ") { (data) in
print(data)
}
func play2(param:(String)->String) {
let value = param("swift")
print("返回值 = " + value)
}
play2(param: {(data:String) -> String in
return data + "IOS "
})
//尾随闭包
play2 { (data) -> String in
return data + "IOS "
}
func play3(param:() -> Void){
param()
}
//尾随闭包
play3 {
print("HHAHAHA")
}
func play4(param:() -> String){
let value = param()
print(value)
}
//尾随闭包
play4 { () -> String in
return "OC"
}
func play5(param:(Int) ->Void , param2: Int){
param(param2 * 2)
}
play5(param: { (data) in
print(data)
}, param2: 20)
五十八、错误捕获和处理
//错误捕获和处理
enum TestError: String, Error{
case error1 = "错误1"
case error2 = "错误2"
}
func play(parma:Int) throws -> String{
if parma < 0 {
throw TestError.error1
}else if parma >= 0 && parma <= 10{
throw TestError.error2
}
print("正常执行")
return "Hello"
}
do{
let value = try play(parma: 110)
print(value)
}catch TestError.error1{
print(TestError.error1.rawValue)
}catch TestError.error2{
print(TestError.error2.rawValue)
};defer {//5.1之后defer之前都要加;
print("defer")
}
print("---------")
let value = try? play(parma: 10)
print(value)
print("---------")
五十九、枚举简写
enum TestError: String, Error{
case error1 = "错误1"
case error2 = "错误2"
}
//枚举简写
func play(paramError:TestError){
print("hhaha")
}
play(paramError: TestError.error1)
play(paramError: .error1)
六十、补充
泛型类型的限定
class Data{
var name: String
init(name:String) {
self.name = name
}
}
//泛型类型的限定
func play<T:Any>(param:T){ //如果这里写Data就没事
let a = param as! Data
print(a.name)
print(param)
}
play(param: Data(name: "Hello"))
协议的限定
class Data{
var name: String
init(name:String) {
self.name = name
}
}
protocol Test {
associatedtype D //由实现类具体规定D的类型
func play(param: D)
}
class Student:Test {
func play(param:String) {
print(param)
}
}
var stu = Student()
stu.play(param: "Hello")
访问权限
private(方法里) < fileprivate(Swift当前文件内) <internal (默认、框架内) < public < open(可以被任何人继承、重写)