Nullable type
var Demo2:we_demo = Nil
The syntax for this code string above is wrong.
Why, then?
In Swift, the default value of all properties defined by a type cannot be nil
Whether it's a normal simple value type or a reference type
Then I'm going to make this property default value is null, nil
What to do, very simple, with syntax, when defining this property, declare one after the type?
This means that this property can be a nullable type in addition to the default value of the specified type
In Java, the most common type of error is nullpoinexecption,
Why is there a null attribute to assign a null value to a property?
The properties in Java are defined.
The value may be an indeterminate, not specific, impractical data
So, in Java, defining a property is going to give an initial value of NULL
In the back, give a new value.
Types that can be empty
Defines the type of the attribute after the add?, which indicates that the property is nullable type property
Swift code:
var zsname:string? = Nilzsname = "Alien" Zsname = "1002" zsname = Nilzsname = "Mars man" zsnamezsname = Nilzsname = "John Doe" zsname!if let d = zsname{ p Rint (d)}
When defining a property, add it after the type, indicating that the default value for the property can be null nil
Nil in Swift can be a null type and is packaged
Swift has made a wrapper for this type
When using this property, separate the attribute from nil
When using a property with a default value that can be empty, add it after the property!
Enumeration
The definition of an enumeration is a type that can have a
Defines an enumeration of color
Swift code:
Enum Color : string{case Red case Blue case Green}
Define a constant save a case
Swift code:
Let color = Color.green
Use switch to make multi-branch judgments
Determine if the situation exists in the color show
Do the right thing if you exist
Swift code:
The switch color { //In the color enumeration, //Defines the case in 3 //Red Blue Green//is the one that determines whether color is a color enumeration of red cases . Red: print ("red") //Determines if color is a green case in the color enumeration . Green: print ("green") //default : print ("no")// * Color enumeration is saved in 3 cases In the above switch judgment only listed 2 kinds to make the judgement so, in the judgment body must have a default *// If you do not want to specify a default //will be enumerated in the color 3 in the case of all the enumeration to determine/ Case . red:// print ("red")//Case . green:// print ("green")//Case . blue:// print ("Blue")}
Enumerates native values (RawValue)////////////
RawValue keywords
Using the RawValue keyword to enumerate native worthwhile actions
PS native worth the premise of the operation, the enumeration must be of type string and int to
Swift code:
Define an enumeration Scoreenum score:int{case A case b case C}//Access enumeration Scorelet score_a = Score.init (rawvalue:0) Let score _b = Score.init (rawvalue:1) Let Score_c = Score.init (rawvalue:2) score.init (rawvalue:6)
/*
Summary:
In the practice of the above code, the case of enumeration is native worth the initial value is 0
Call the Init method of the enumeration, pass an enumeration of native values, and you can get the case where the native value corresponds in the enumeration
PS Invoke enumeration Enum method Init, if the original value passed RawValue in the enumeration corresponds to the case is undefined
The Init method returns nil
*/
The default initial value for an enumeration of type int is worth 0
Native values can be customized
The following code exercises an enumeration of type string
Swift code:
Defines an enumeration classenum class:string {case name = "Tom" Case Age }//Access and manipulate enumeration ClassClass.name.rawValueClass.init ( RawValue: "Name") Class.init (rawValue: "Age") Class.init (rawValue: "Sex")
/**************************************************
Summarize:
1>
An enum of type int, string, has a native value
Also, the native value has an initial value,
Enum native Value initial value of type int is 0
Enum native Value initial value of string type, what is the case defined in the enumeration, and what is the initial value of the enumeration native value
2>
However, the enumeration native values have an initial value,
The initial value can also be defined by itself
Case Casename = 123
Case casename = "ZS"
Specify a custom native value for the enumeration case with an equal sign after the condition name
What type is the PS enumeration, and what type is the native value of the custom enumeration case?
3>
Use of enumerations
Enumname.casename,[gets the case in the enumeration]
Enumname.casename.rawvalue,[gets the native value of the enumeration case]
Enumname.init (rawValue: "")
Enumname.init (rawvalue:2333) [Get Case of enum native value]
**************************************************/
Enumerate associated values//
Defines an enumeration of student
Swift code:
Enum Student {case name (string) Case age (Int) Case Sex (string) case test (string,int)}// The operation uses Student this enumeration student.name ("Tom") student.age ("the") Student.sex ("Demon")
/***********************************************************
In an enumeration, each case can have an associated value, and the associated value can have more than one, and the type can be different
Specify the type of the associated value with parentheses
***********************************************************/
That's a super point.
Recursive enumeration///
Let's start with a test.
Learn what is good, first get an introduction to take care of it first
It's not hard in the back.
Action>>>
To define a simple recursive enumeration
Syntax: If the defined enumeration is a recursive enumeration, you need to use the INDIRECT keyword before the keyword that defines recursion
The indirect keyword is used to identify that the current enumeration is a recursive enumeration
/*
Recursive features:
themselves call themselves
*/
Swift code:
Indirect enum recurrenceenum{case A (String) case D (int.) case T (recurrenceenum)}// Use this recursive enumeration RECURRENCEENUM.A ("I am recursive enumeration of Case_a") RECURRENCEENUM.D (RECURRENCEENUM.A ("Call Yourself") recurrenceenum.t ("self")
/***********************************************
to really understand and be proficient in this recursive enumeration
It technology < tree > concepts are important and important, just understand this < tree >
Recursive enumeration This knowledge point only takes 3 minutes!!
< trees >
To explain in simple words:
Himself [a father, a mother]
Father [Father's father, mother of father]
Mother [Mother's father, Mother's mother]
Keep going back.
This is the tree.
More concise words to describe:
Computer domain, the tree has only one root node, and must have a root node, otherwise it becomes "graph" this data structure
***********************************************/
Define an enumeration and call yourself
Write an enumeration that can be used to represent an operation
Note that this is a recursive enumeration,
Using the INDIRECT keyword
Swift code:
Indirect enum operation{case Num (int.) Case Additive (left:operation,right:operation) case Multiplication (left:operation,right:operation)}//5 * (3+9)//5let exp5 = Operation.num (5)//3let exp3 = Operation.num (3) 9let EXP9 = operation.num (9)//3+9let exp3joinexp9 = operation.additive (LEFT:EXP3, RIGHT:EXP9)//Integrated Let Finalexp = Operat Ion.multiplication (LEFT:EXP5, RIGHT:EXP3JOINEXP9)
________________________________over
Swift_ Enumeration | Nullable type | Enumerate Associated values | Enumeration Recursion | The concept of a tree