// main.swift
// Swift(二)
// Created by on 15/11/3.
// Copyright © 2015年 All rights reserved.
//
import Foundation
// 可选类型(?)其根源是一个枚举型，里面有None和Some两种类型。其实所谓的nil就是Optional.None, 非nil就是Optional.Some.
// ? 可选类型: 有值，没值（nil）
// 如果可选类型没值，再强制解包的话，就会崩溃
var intNumber:Int? = 8
// ! 表示强制解包
var intNumber1 = intNumber!
print(intNumber1)
// 可选绑定, 不用强制解包
if var intNumber2 = intNumber {
print(intNumber2)
}
// ! 隐式解析可选类型 ： 有值，没值（nil）
var intNumber3: Int! = 10
//var intNumber4 = intNumber3
//print(intNumber4)
// 可选绑定
if var intNumber5 = intNumber3 {
print(intNumber5)
}
/*******结构体(struct)***********/
//1.声明一个结构体
struct Rect{
//声明结构体变量的属性(存储属性)
var x:Float
var y:Float
var width:Float
var height:Float
//声明结构体的类属性
//注意:需要使用static关键字修饰,
static var description:String?
//计算属性(专门用于计算其他属性的值,并不存储值)
var centerX:Float{
//setter方法
set{
x = newValue - width/2
}
//getter方法
get{
return x + width/2
}
}
var centerY:Float{
get{
return y + width/2;
}
}
//声明方法
//声明一个结构体对象(结构体变量)方法[类似于类中的实例(对象)方法]
func info(){
print("x:\\(x) y:\\(y),width:\\(width),height:\\(height)")
}
//声明结构体方法[类似于类中的类方法]
static func info1(){
print("这是一个结构体方法");
}
}
//1.根据结构体类型(Rect),用结构体自带的构造方法创建结构体对象(结构体变量)
var rect1 = Rect(x: 0, y: 0, width: 100, height: 100)
//注意:如果结构体对象是常量,内部的属性是不允许修改的
//访问结构体对象的属性(x,y,width,height)
rect1.x = 20
print(rect1.x)
//访问结构体属性
Rect.description = "我是结构体属性"
print(Rect.description!)
//访问结构体对象的计算属性
rect1.centerX = 100 //在调用centerX中的setter方法
let value = rect1.centerX //在使用centerX中的getter方法
//使用结构体对象方法
rect1.info()
//使用结构体方法
Rect.info1()
/***********类(class)***********/
//class Person {
// var name:String?
// var age:Int?
// //构造方法
// init(name:String,age:Int){
// self.name = name
// self.age = age
// }
//}
////创建一个Person对象
//var p1:Person = Person(name: "张三", age: 20)
////访问类中的属性
//print(p1.name!)
class Person {
//声明对象属性(存储属性)
var name:String?
var age:Int?
//声明类属性
static var introduce:String?//(存储属性)
//声明计算属性(类,结构体,枚举)
var number:Int{
get{
return age!
}
set(value){ //这种写法表示在调用number的set方法时,传过来的参数赋值给value
age = value //切记:set,get方法中不能使用self.属性,会造成递归
}
}
//声明类方法
//static修饰的类方法,不能被子类重写.class修饰的类方法,可以被子类重写
static func sayHi(){
print(introduce)
//注意类方法中不能使用对象属性,只能使用类属性
}
class func sayHi2(){
print(introduce)
}
//声明构造方法
init(name:String ,age:Int){
self.name = name;
self.age = age;
}
init(name:String){
self.name = name;
}
//声明对象方法
func sayHello(){
print("Hello,我是对象方法!!")
}
}
let person = Person(name: "李四", age: 25)
person.sayHello()//使用对象方法
Person.sayHi2() //使用的是类方法
//继承
class Student:Person{
//重写父类的类方法，一定要在方法前加override
override class func sayHi2(){
print("我是Student类,重写父类的类方法")
}
}
class collegeStudent: Student {
}
Student.sayHi2()//使用的Student中重写父类的那个类方法
person.number = 20
//创建Student对象
let student:Student = Student(name: "小王", age: 23)
/************值类型与引用类型*************/
//struct animal {
// var name:String?
// var age:Int?
//}
//var dog = animal(name: "小黄", age: 2)
//var dog1 = dog //此时,dog1是从dog拷贝过来的值,是一份新值
//dog.name = "小花"
//print("\\(dog.name!),\\(dog1.name!)")
class animal {
var name:String?
var age:Int?
init(name:String,age:Int){
self.name = name
self.age = age
}
}
var dog = animal(name: "小黄", age: 3)
var dog1 = dog //此时,dog1是从dog拷贝过来的值,是一份新值
dog.name = "小花"
print("\\(dog.name!),\\(dog1.name!)")
/*************** 协议(protocol) *****************/
//当协议中有可选实现的方法时,该协议前要用关键字@objc修饰,可选实现方法前,用optional修饰
@objc protocol MerrayDelegate{
func cook() //做饭
func wash() //洗衣服
optional func hitDouDou() //打豆豆
}
protocol DividDeletate{
func lookAfterChild()
}
class Man: Person,MerrayDelegate,DividDeletate {
@objc func cook() {
print("还好学了几年手艺!!")
}
@objc func wash() {
print("老婆衣服很贵,我得用手洗!!")
}
func lookAfterChild() {
print("照顾孩子!!!")
}
}
extension Man{
@objc func hitDouDou() {
print("打豆豆")
}
}
//
let man:Man = Man(name: "黄海波", age: 40)
man.cook()
man.hitDouDou()
/************* Extension(扩展)**********/
//1.扩展一个类遵循的协议中的方法
//extension Man{
// @objc func hitDouDou() {
// print("打豆豆")
// }
//}
//2.扩展一个类 的方法(给某个类添加一个方法),类似于OC中Category类目
extension Man{
//扩展一个对象方法
func sing(){
print("老婆,我爱你!")
}
//扩展一个类方法
class func eat(){
print("吃饭!!!")
}
}
man.sing()
Man.eat()
/************** 闭包 *************/
//求两个整型数中的最大值
//func maxValue(a:Int,b:Int)->Int
//这个函数的类型是:(a:Int,b:Int)->Int
var maxResult:((a:Int,b:Int)->Int)
//第一种方式,实现闭包
maxResult = {
(a:Int,b:Int)->Int in
return a>b ? a:b
}
//第二种方式
maxResult = {
a,b in
return a>b ? a:b
}
//第三种
maxResult = {
a,b in
a>b ? a:b
}
//第四种
maxResult = {
$0 > $1 ? $0:$1
}
//第五种
maxResult = {
(a,b) -> Int in
return a>b ? a:b
}
print(maxResult(a: 3, b: 5))
