类的创建和使用

类的创建

class TV{
    
    var working=false
    
    func open(){
        self.working=true
    }
    
    func close(){
        self.working=false
    }
}


let tv=TV()
tv.open()
print(tv.working)//false

get是别的语言的getter,set是别的语言的setter

//将这些参数类型写在结构体中，方便函数进行调用
struct Specification{
    //规格参数
    let width=1079.3
    let height=695.8
    let thickness=216.0
    let listingDate="2016-03-04"
    let hz=60
    
    var volumn:Double{
        get {
            return width*height*thickness
        }
        set(volumn){
            
        }
    }
}

class TV{
    private var working = false
   
    //规格信息
    var specification:Specification=Specification()
    
}

var tv=TV()
tv.specification.volumn

lazy property:调用的时候才初始化

func loadSpecification() ->Specification{
    return Specification(w:1079.3,h:695.9,t:216.9)
}



class TV{
    private var working = false
   
    //规格信息 //用法在要使用的函数前加上lazy前缀，必须使用var关键字
  lazy  var specification:Specification=Specification()
    
}

Type property：static 关键字

func loadSpecification() ->Specification{
return Specification(w:2,h:3,t:4)
}

class TV{
  private var working=false
//物理尺寸  //static修饰默认这个属性就是lazy属性，线程安全只会初始话一次
static var specification=loadSpecification()
...
}

TV.specification.width //直接通过类名进行调用

//这样不需要实例化，也能实现类的属性
struct Specification{
    var w=1
    var h=2
    var t=3
}


class TV{
    private var working=false
    
    static var specification = TV.loadSpecification
    //static 定义一个函数
    static func loadSpecification() -> Specification{
        return Specification(w:1,h:2,t:3)
    }
}
TV.specification

比较两个变量的大小

//三个等号判断两个实例是否指向同一份内存地址，两个等号判断他们的内容是否相等
//Identity: === 指向同一份实例，对象
//Equal : == 值相等 :String、Struct等

//有些时候需要重构等号来判断两个结构体是否相等
struct Measure{
    var width=1
    var height=2
    var thickness=3
}

class tv1{
  static  var measure=Measure()
}

class tv2{
 static  var measure=Measure()
}

func == (left:Measure,right:Measure) ->Bool{
    return (left.width==right.width)&&(left.height==right.height)&&(left.thickness==right.thickness)
}

if(tv1.measure==tv2.measure)
{
    print("ddddddddd")
}

继承

class TV{
   

    func description() -> String {
//        return "width:\(self.Specification.width),height:\(self.Specification.height),thickness:\(self.Specification.thickness)"
        return "0"
    }

 var shuxing:String{
  return "width"
}
}
// :TV  这里是继承基类TV的意思
class GameTV:TV{
    //方法继承
    //override  看见这个关键字一定是重写基类的方法
    override func description() -> String {
        
        return "GameTV\(super.description())"
    }
//属性继承
 //重写shuxing的属性
  override var shuxing:String{
  return "GameTV:\(super.shuxing)"
}
}

let gameTV=GameTV()
gameTV.description()//会返回调用的super.description()这个方法，调用到基类的description()方法