1.枚举
有的变量只要几种取值的选择,在swift中对这种比较特殊的变量,可以定义为枚举类型
枚举的定义
//enum 枚举名称{
// 此处放置枚举的成员
//}
枚举的代码
enum UserLever{
case 总经理
case 业务员
}
enum UserLever1
{
case 总经理,业务员,哈哈
}
print(UserLever1.哈哈)
//注意:枚举和Swift不同的是他们的值并不会隐式等于0，1，2,3
枚举值的遍历
let caseValue=UserLever1.哈哈
switch caseValue{
case UserLever1.哈哈:
print("哈哈")
case UserLever1.总经理:
print("总经理")
default:
print("呵呵")
}
枚举的原始值
enum sex:Int
{
case man=1
case female=2
case unknow=3
}
//另一种写法
enum sex1:Int
{
case man=1,female,unknow
}
print(sex1.man.rawValue)
//给枚举添加方法
enum sex2:Int
{
case man,female,unknow
func fun()
{
print("哈哈")
}
}
//调用枚举中的方法
let gender=sex2.man
gender.fun()
2.结构体
结构体的定义
//struct 结构体名称{
// 此处放置结构体的内容
//}
struct People{
var name="大保健"
var sex="男"
//给结构体添加方法
func getName() {
print("name:\(name) sex:\(sex)")
}
}
let people1=People()
people1.getName()
people1.name
3.类
Swift 类是构建代码的一种通用而灵活的构造体,类是属于用户自定义的数据类型,并且该类型的数据具有一定的行为能力，也就是类中所描述的方法
类的创建
//class 类名
//{
// 属性列表
// 方法别表
//}
class people
{
var name = "小明"
var sex = "男"
func fun(){
print("name:\(name)")
}
}
let p=people()
p.fun()
print(p.name)
其中可以在定义类的时候,给它指定自定义的init初始化方法
class people2
{
var name = "小明"
var sex = "男"
//自定义的init初始化方法
init() {
self.name="哈哈"
self.sex="女"
}
//带参数的实例化
init(name:String,sex:String) {
self.name=name
self.sex=sex
}
}
let pp1=people2(name:"呵呵",sex:"女")
print(pp1.name)
类属性的set和get方法，使用get和set来间接获取/改变其他属性的值
class people3
{
var name = "小明"
var getpeopleName: String {
get {
return name
}
set {
name = newValue
}
}
}
let pp3 = people3()
pp3.getpeopleName="呵呵呵呵呵呵"//set
pp3.name//get
类属性的willSet和didSet方法,可以给类添加属性观察者
属性观察者可以观察属性值得变化,并对此作出相应的鹅反应，当设置属性值时,属性观察者就被调用,即使当新值和原值相同时也就会被调用
可以单独或者同时使用下面的方法,以进行属性观察者的定义:willset方法在设置属性值之前被调用。而didset方法则在设置属性值之后被调用
当实现willset观察者时,新的属性值作为常量参数被传递。可以为这个参数起一个名字，如果不命名,则这个参数就被默认命名为newValue
注意:set get 方法和willSet,didSet不能一起用 好像
class people4
{
var name = "小明"
{
willSet{
print("即将设置为新值\(newValue)")
}
didSet{
print("新值设置成功\(name)")
}
}
}
let pp4 = people4()
pp4.name="======哈哈"
类的静态方法
静态方法为类所有,需要通过类来使用,因此静态方法不必建立类的实例就可以使用,在Swift环境中可以为类,结构体和枚举等类型定义静态的方法,也称为类型方法
class people5
{
//定义静态方法
class func GetName(name:NSString)->NSString {
return name;
}
}
print(people5.GetName(name:"哈哈哈"))
类的析构
与构造工程相反,实例最后释放的时候,需要清除一些资源,这个过程就是析构的过程。在析构过程中也会调用一个特殊的方法deinit，称之析构函数。析构函数deinit没有返回值,也没有参数,也不需要参数的小括号,所以不能重载
class people6
{
var name:String
init(name:String) {
self.name=name
}
deinit { //定义了析构函数
print("调用析构函数...")
}
}
var pp6:people6? = people6(name:"小明")
print(pp6!.name)
pp6 = nil
类的继承
在Swift环境中，类的继承不同于结构体和枚举类型，继承是类所特有的。当一个类继承其他类时,继承类就被称为子类，被继承类称为父类或者超类
类的继承具有以下特点
1.继承是在一些通用类的基础上构造,建立和扩充新类的最有效的手段
2.继承能清晰体现相关类之间的程词机构关系
3.继承提供了软件复用功能
4.继承通过增强一致性,来减少模块间的接口和界面,大大增加了程序的易维护性
class people7{
func say(){
print("我要大保健")
}
}
class peopleSon:people7{
var name:String
init(name:String) {
self.name=name
}
func say1(){
print("我们一起大保健")
}
override func say() {//重写
print("我是：\(name)要去保健")
}
}
let pp7=peopleSon(name:"麻痹戒指")
pp7.say()
pp7.say1()
类的延迟加载属性lazy
延迟加载属性是指当第一次被调用的时候,才会对其进行初始化的属性(就是懒加载)
class people8{
lazy var name="小明"
}
let pp8=people8()
pp8.name
类的引用特征
class people9
{
var name:String
init(name:String) {
self.name=name
}
}
var pp9 = people9(name:"呵呵")
pp9.name="麻痹戒指"
var pp91=pp9
pp91.name="古天乐麻痹戒指"
print(pp91.name)
类型的检测
类型检测在swift中是一种检测实例类型的方式，同时也是让实例作为它的父类或者子类的一种方式
class people10
{
var name:String
init(name:String) {
self.name=name
}
}
class peopleson1:people10
{
func say() {
print("古天乐麻痹戒指")
}
}
let pps10 = peopleson1(name:"呵呵")
// is操作符是一个类型检査操作符,在Swift中,对它的定义是:检测一个实例是不是特定类的子类型,如果是,则该操作符返回true,如果不是,则返回false.
if (pps10 is people10){
print("是这种类型")
}
// as操作符是一个类型转换操作符,主要用于实例在子类和父类间的转换
if let item=pps10 as? people10{
item.name="====古天乐麻痹戒指"
item.name
}
anyObject和any
Swift为不确定类型提供了两种特殊类型别名：
AnyObject可以代表任何class类型(即类类型)的实例。
Any可以表示任何类型，包括方法类型（function types）。用来修饰任意类型的实例,包括AnyObject修饰的实例.
注意：
只有当你明确的需要它的行为和功能时才使用Any和AnyObject。在你的代码里使用你期望的明确的类型总是更好的.
AnyObject类型
AnyObject任意实例类型
Any 其实Any是AnyObject的总类,完全覆盖AnyObject.
class Evil{
var name = ""
}
var hiter = Evil()
hiter.name = "保健"
var hiter1 = Evil()
hiter1.name = "大保健"
var array = [AnyObject]()
array=[hiter,hiter1]
if let item=array[1]as?Evil {
item.name
}
4.扩展
Swift中的扩展功能（Extension）,可以动态地给类增加功能,类似JavaScript中prototype，这包括在没有权限获取原始源代码的情况下,扩展某个类型的功能。而在object-C中,则是通过runtime中来实现动态调用或者添加功能的
现有的类,结构或枚举类型的方法,可以在扩展的帮助下进行添加。类型的功能可以使用扩展加入，但重写的功能不能使用扩展
在Swift中使用扩展可以完成以下任务
添加计算型属性和计算型静态属性
定义实例方法和类型方法
提供新的构造器
定义下标
定义和使用新的嵌套类型
使一个已有类型符合某个协议
注意：
扩展可以对一个类型添加新的功能，但是不能重写已有的功能。
示例代码
extension String{
//添加属性
var name: String{
return "呵呵"
}
func getname(name:String) -> String {
return name;
}
}
print("名字".name)
print("名字".getname(name:"麻痹戒指"))
//添加构造器
/*
其实构造器就是一个特殊的方法,所以扩展构造器方法就是添加方法,不过要注意两点:
1:如果扩展类类型,我们只能够增加便捷构造器,而不能够增加指定构造器和析构器.
2:对于值类型,比如结构体,枚举,在扩展其构造器时,务必保证所有的属性都被初始化.
*/
struct people{
var name = "小明"
}
extension people
{
func say() {
print("麻痹戒指")
}
}
let p = people()
p.name
p.say()
5.协议定义
协议是为方法,属性等定义一套规范,没有具体的实现,类似Java中的抽象接口，它只是描述了方法或者属性的骨架,而不是实现。
协议可以通过一个类,结构或枚举，来提供协议中要去的具体实现
示例代码
// 协议定义
//协议定义通过关键字protocol
protocol protocol1{
// 协议的内容
}
// 协议可以继承一个或者多个协议
protocol protocol2:protocol1
{
// 协议的内容
}
struct ppstruct:protocol2,protocol1
{
// 结构体定义
}
// 类实现协议和继承父类,协议一般都写在父类后面
class Superclass {
// 父类定义
}
class sonclass:Superclass,protocol1,protocol2
{
//子类的定义
}
//属性要求
//协议不指定是否该属性应该是一个存储属性或者计算属性，它只指定所需的属性名称和读写类型。属性要求总是声明为变量属性，用var关键字做前缀。
protocol classprotocol{
static var peoplename:String{get set}
var peoplename1:String{get }
var peoplename2:String{set }
}
// 定义类来实现协议
class Myclass:classprotocol
{
static var peoplename="呵呵"
var peoplename1="呵呵"
var peoplename2="呵呵"
func getName() -> String {
return peoplename1
}
}
var class1=Myclass()
print(class1.getName())
网友评论