5.Swift Enumeration | struct | class | attribute | method | Subscript Script | inherit

1. Enumeration:

In Swift, the integer is still applied to indicate the enumeration value, and it needs to be paired with the case keyword

Enum celebrity{Case Dongxie,xidu,nandi,beigai}//left-to-right corresponds to 0,1,2,3

Enum CompassPoint {

Case North

Case South

Case East

Case West

Methods can be defined in enum

Func Show () {

Print (self)

}

}

Defining enum variables

var p = Compasspoint.north

var P2 = Compasspoint.south

P.show ()

P2.show ()

var point:compasspoint =. West

Switch point{

Case. North:

Print ("North")

Case. South:

Print ("South")

Case. East:

Print ("East")

Case. West:

Print ("West")

}

Enum Week:int {

Case Sun, Mon, Tur, Wen, Thu, Fri, Sat

}

The original (bare value) requires a type callout,

Notice: Here the enumeration member is called by invoking the enumeration type Week the Sun bare value (and the enumerated integer value as described in C), the type-marking symbol to be added after the assigned variable

var weekday:int = Week.Sun.rawValue

The current enumeration member can also be invoked directly through the week RawValue method

var week:week? = Week (rawvalue:7)//here if RawValue exceeds the return of the enumeration value, the return is empty, so Week need to use optional values to receive

You can also use the tuple attribute to set the associated enumeration member

Enum BarCode {

Case UIPCA (Int,int,int)//Barcode

Case QRCode (String)//two-D code

}

Defining an enumeration variable

var barcode = BARCODE.UPCA (690,3322323,2)

Barcode = Bar.qrcode ("http://fdsafdsfa.com")

Switch Barcode {

Case BARCODE.UPCA (Let (Num,id,check)):

Print ("This is a barcode \ (num)-\ (ID)-\ (check)")

Case Barcode.qrcode (Let string):

Print ("This is a two-dimensional code corresponding to the string is: \ (String)")

}

}

/** uses a new notation, specifying conditional judgments at the same time as binding variables, similar to sql*/

Switch Apoint {

When binding a variable, you can bind x = = y

Case let (x, y) where x = = y:

Print ("x equals y x = y" on equal Slash)

Case let (x, y) where x = =-Y:

Print ("x and y slash x = y")

Default

Print ("other")

}

2. Structs and classes:

Same point:

Structural problems and classes, all defining a type

Properties and methods can be defined internally

You can define the subscript operator

Can define initialization methods (Int initializer, constructor construction method)

Can be used to extend existing functionality (there are classifications in OC, no classification in Swift, called extensions)

Can follow the established protocol.

Different points:

Classes can inherit, structs cannot

The class is polymorphic and the struct has no

The memory of the class supports automatic reference technology, the struct does not support the reference technology, the struct variable allocates the memory space in the stack, does not need to manage manually

Class is a reference type struct body is a value type

The initialization of a property provides an parameterless and uniform initializer

struct Resolution {

var width = 0.0

var height:float = 0.0

}

class declares that the property must be initialized, unless it is an optional value

Class Videomode {

var resolution = Resolution ()

var interlocaed = False

var framerate = 0.0

var name:string?

}

struct is a value class class is a reference type

var res = Resolution ()

var res2 = Res

Res.width = 1024

Res2.width

var vmode = Videomode ()

var vmode2 = Vmode

Vmode.name = "Zhanshang"

Vmode2.name

/** = = = Compare address Equality */

if Vmode = = = Vmode2 {

Print ("Two references are the same value")

}

If Vmode2!== Vmode {

Print ("Two references are not of the same address")

}

The unified initializer for the/** structure, which is very familiar with the structure problem nesting in C, tightly refers to changing the way variables are defined, and also supports the point syntax to access hierarchical nested properties */

struct Point {

var x:float

var y:float

}

struct Size {

var w:float

var h:float

}

struct Rect {

var origin:point

var size:size

}

var rect = rect (Origin:point (x:100, y:20), Size:size (W:2, H:3))

Rect.size.w

Rect.origin.x

3. Attributes, properties in Swift are categorized in two ways

The first way:

/**

1. There are two ways to categorize properties in Swift

The first way:

Storage attributes (Stored properties): Use variables or constants to save property values

(Calculate properties): calculated.

Example:

Date of birth: storage tree, Age: two time to calculate

The second classification method:

Instance properties and Type properties

*/

Store Properties

struct MyRange {

var location:int

Let Length:int

}

var myrnage = MyRange (location:0, length:100)

struct Point {

var x = 0.0, y = 0.0

}

struct Size {

var w = 0.0, h = 0.0

}

struct Rect {

Store properties, use variables or constants to save stored properties

var orign = point ()//Create point Object

var size = size ()

var Center:point {

get{

Let CenterX = orign.x + SIZE.W * 0.5

Let CenterY = orign.y + size.h * 0.5

Return point (X:centerx, y:centery)//Returns a point type

}

If there are no parameters, use the default NewValue

set{

Let Neworignx = NEWVALUE.X-SIZE.W * 0.5

Let Neworigny = newvalue.y-size.h * 0.5

Orign = Point (X:neworignx, Y:neworigny)//implementation of Origin assignment

}

/* Set (Newcenter) {

Let Neworiginx = NEWCENTER.X-SIZE.W * 0.5

Let Neworiginy = newcenter.y-size.h * 0.5

Origin = Point (X:neworiginx, Y:neworiginy)

} */

Suppose to do a read-only computed property

}

If the computed property is read-only, only one line of code can omit the return

var Center2:point {

get {

Return point (x:500 + 100,y:100)

}

}

}

var rect = rect (Orign:point (x:0, y:0), Size:size (w:300,h:200))

Rect.center.x

Rect.center.y

Rect.center = Point (x:200, y:200)

Rect.orign.x

Rect.orign.y

/** delay properties like OC lazy loading, or deferred loading */

Class Dataimporter {

Init () {

Print ("Dataimporter create")

}

var fileName = "Data.txt"

This needs to be used only to load

}

Class DataManager {

Lazy var dataimporter = Dataimporter ()

}

Create the DataManager object

var DataManager = DataManager ()

/** Add layz*/before the property needs to perform lazy loading

Datamanager.dataimporter

4. Property Monitor: A piece of code that is automatically called when a property changes

--compute properties, deferred properties, cannot set monitor, only storage properties to set monitor

Property monitor, which is not called when the property is initialized

There are two types of property monitor, Willset,didset

Class Stepcounter {

var labelText = "Text content"

/**storeage property*/

var a:int = 10

Read-only computed properties

var B:int {

Return 10

}

Adding Property Monitors to attributes

var totalsteps:int = 10 {

Willset (NewValue) {

Print ("The property will change when called to change to \ (newvalue) is now \ (totalsteps)")

}

didset{

Print ("The property value has changed when the whine is using the original value \ (oldValue) is now \ (totalsteps)")

LabelText = "changed value \ (totalsteps)"

}

}

}

var propertyname:int = 10{Willset (newvalue) {//insercode here} didset{//insertcode here}}

var stepcounter = Stepcounter ()

Stepcounter.totalsteps = 50

Stepcounter.labeltext

Stepcounter.totalsteps = 20

Stepcounter.labeltext

5. Type properties:

In structs or enumerations, properties that use the static adornment and properties that are decorated with the class keyword in the classes are called type properties and are independent of the entire class and object.

A type attribute defined in a struct, either a stored property or a computed property

The type attribute defined in class can only be computed (if you need to use the storage tree seat design type attribute, add the static keyword)

struct Somestrut {

Store Properties

var a = 10

Calculated properties

var B:int {

Return 10

}

Type property

static var x = 10

static Var y:int {

Return 10

}

}

var someStruct1 = Somestrut ()

somestruct1.a//10

var someStruct2 = Somestrut ()

somestruct2.a//10

Somestrut.x//10

Somestrut.y//10

Class SomeClass {

var a = 10

var B:int {

Return 10

}

/** type attribute, too wonderful */

static Var y:int {

Return 100

}

class Var X:int {

Return 100

}

static var Storeageporperty:int = 10//compile pass. Priority use of static

Swift compilation does not pass? class var storageporperty1:int = 100

}

Someclass.y

Someclass.storeageporperty = 123

Someclass.x

6. Example methods, class methods, almost the same as OC

Instance methods and class methods, instance methods in classes are almost the same as OC

instance method of the/** class type */

Class counter{

var count = 0

Func increment () {

count++

}

Func IncrementBy (amount:int) {

Count + = Amount

}

Func IncrementBy (Amount:int, Numberofftimes:int) {

Count + = Amount * Numberofftimes

}

}

/** Create a instance */

var counter = counter ()

/** Invoke Instance method*/

Counter.increment ()

instance method for/** value type */

struct Point {

var x = ten, y = 10//instance value type attribute, called by object, or object self pointer

var z = 250

static var SX = 10//class-type attribute, called by class, or class self pointer

Func Show () {

print ("Dot \ (x)")

POINT.SX = 1111

}

instance method of a value type, the instance property cannot be modified by default, plus mutating if it is not to be modified

mutating func SetX (Px:int,andy y:int) {

x = px

self.x = px

Prevent parameter and attribute names

Self.y = y

POINT.SX = 111

}

}

Enum statusswitch{

Case Study,dining,review,sleep

Func Show () {

Switch self{

Case. Study:

Print ("learning")

Case. Dining:

Print ("Eating Now")

Case. Review:

Print ("reviewing")

Case. Sleep:

Print ("Sleeping")

}

}

/** Toggle State, here if you want to modify self need to add mutating*/in front

mutating func Nextstatus () {

Switch Self {

Case. Study:

Print ("Next meal")

Self =. Dining

Case. Dining:

Print ("Next to Review")

Self =. Review

Case. Review:

Print ("Go to Sleep Next")

Self =. Sleep

Case. Sleep:

Print ("Next to learn")

Self =. Study

}

}

}

var ss = Statusswitch.study

Ss.show ()

Ss.nextstatus ()

Ss.nextstatus ()

Ss.nextstatus ()

Ss.nextstatus ()

Ss.nextstatus ()

Ss.nextstatus ()

Ss.nextstatus ()

Ss.nextstatus ()

7. Type method:

Type method and class method in OC, meaning the same

Class SomeClass {

var prop:int = 0//instance property must have an object to be able to position

class var A:int {//Type property, class can also use the static

Return 10

}

Func Instancemethod () {

Print ("This is a instance method")

Self.prop

Someclass.a

SELF.A A is a class property, so it cannot be called

}

Class Func Typemethod () {///class Func stands for defining a class method

Print ("This is a type method")

Same OC, class method cannot access instance properties, but can access type properties

Self.prop

SELF.A//self The object that calls this method with a table, self equals the object that invokes the class method, the Class object

Someclass.a

}

}

var p = SomeClass ()

P.prop

Someclass.a

Invocation of a class method

Someclass.typemethod ()

First, create a class object-"

var instanceobject = SomeClass ()//class name + () can create an object of a class

Instanceobject.prop

Instanceobject.prop = 10

Instanceobject.prop

struct SomeStruct {

var prop:int = 0

/** declares a static storage property */

static var a:int = 0

Func Show () {}

Func Instancemethod () {

The instance property here can be read but cannot be modified by prop = 1000, if you need to modify the

Self.show ()

Print (prop)

}

In a/** struct, class methods use static, which can be used in classes to define class methods and variable methods in C + +, which is called a static method, but only static in the struct */

static Func Typemethod () {

Print ("This is a type method")

Self.show () instance method,?, cannot be used here

}

}

/** enumeration in the type method */

Enum Statusswitch {

Case Study,dinig,review,sleep

static Func Typemethod () {

Print ("This is a type method")

}

static func Create ()->statusswitch {

return self. Study//statusswitch class calls the Create class method, self points to statusswitch, so returns to the Statusswitch type

}

Func Show () {

Print ("This is an instance method")

}

}

Statusswitch.create (). Show ()//

StatusSwitch.Study.show ()///with the above equivalent//enumeration member can invoke the enumeration class method, so that understanding will be good to remember, do not understand the temporary as a format to remember, and so on the amount of code accumulation went back to study.

8. Subscript script, mainly used to check whether array bounds are out of bounds, how to use assertions

Class MyArray {

Private, cross-border return true, no cross-border return false

pravate var array = [0,1,2,3,4,5,6,7,8,9]

Func indexisvalid (index:int)-bool {

If index < 0 | | Index >array.count-1 {return ture} else {return false}

/** Add Data */

Func Addobjectatindex (Index:int, Object:int) {

ASSERT (Indexisvalid (index))

Array.insert (Object,atindex:index)

}

Func Show () {print (array)}

}

Let the myarray support subscript, the wording of a

Defines a subscript function that constructs an integer by subscript, creates a set and get method, where the NewValue and array assignments in the Set method, the external parameter

Subscript (Index:int)->int {

get {return Array[index]}

set {Array[index] = newvalue}

}

Method Two: By rewriting the Set method

Subscript (index:double)->int {

get{return Array[int (index + 0.5)]}

set{Array[int (index + 0.5)] = newvalue}

Here the NewValue is a set method call when the outer band parameter is similar to (int) Setnewvalue: (int) newvalue

}

var MyArray = MyArray ()

Myarray.show ()

Myarray.addobjectatindex (1, object:100)

Myarray.show ()

Myarray.array + [30,300]

MyArray.array.removeAtIndex (5)

Myarray.show ()

MYARRAY.ARRAY[0]

9. Inheritance:

Parent class Subclass (base class, derived class)

Features in Swift: A class can have no parent class, unlike OC all classes inherit from the Nsobject,swift class, a class can consist of only one parent class, but can have multiple subclasses.

Class Vehicle {

Storage Attributes Storage Properties

var currentspeed = 0.0

Calculate attribute Calculate Properties

var description:string {

Return "Current speed is per hour \ (currentspeed) km"

}

Func makenoise () {

Print ("How the Parent class occurs")

}

Func Show () {

Print ("method shown by the parent class")

}

}

/** inheritance*/

Class Bicycle:vehicle {

/** extension propertie*/

var Hasbasket = False

/** extension method*/

Func Test () {

Print ("Subclass extension method")

}

/** Override Parent method*/

Override Func Makenoise () {

Print ("Subclass Dong Dong ...")

}

}

var bike = Bicycle ()

Bike.show ()

Bike.makenoise ()

Bike.hasbasket

Bike.currentspeed

/** the parent type points to the subtype, before obj is the traffic object, Makenoise overrides, and the subclass method is called first

*/

var obj:vehicle = Bicycle ()

Obj.makenoise ()

}

5.Swift Enumeration | struct | class | attribute | method | Subscript Script | inherit