About unity in C # Basic Learning

First, the program contains

1. Data: Generated during the operation

2. Code: Code directive

Both the data and the code are stored in memory, and the code instruction is put into memory when the program is loaded, the data is dynamically generated in memory when the program is running, and is recycled at any time, and variables are defined to hold the data.

The smallest unit of memory storage is bytes, in memory is a binary number, only 1 or 0, called bits, 1 bytes can hold 8 bit,8 bits binary 11111111

II. basic data types for C #

1. Integer (sbyte 1-byte integer with symbol, byte unsigned 1-byte integer) (short signed 2-byte integer/ushort unsigned 2-byte integer) (int with signed 4-byte integer/unit unsigned 4-byte integer) (zero). (Long signed 8-byte integer/ulong 8-byte integer without a symbol)

2. Floating-point number (float 32bit=4 byte/doouble 64bit=8 bytes)

3. Logic number (TRUE/FALSE)

4. Character type (16-bit Unicode)

5. A reference variable of a complex type (pointer in c), with a 100-byte variable A and variable b pointing to variable A, then B is called a reference variable of a complex type (64-bit. NET then 64-bit, 32-bit. NET then 32-bit)

Like Monobehaviour is a complex type, string-defined strings are also complex types

Third, C # permission modifiers

1.public class and modifiers for type members

Modifiers for 2.private type members

Modifiers for 3.protected type members

4.internal class and modifiers for type members

A type member consists of a data member (an instance of a class) and a method of a class (a function member), a data member that does not belong to a class, an instance of a class, how many data members are defined in a class, and how many data member properties are in an instance of the class. The method of the class is logical, generic, belongs to the class, the code exists in a fixed place, only a single piece of logic, no matter how many instances are called this logic

Human

Data members: mouth, teeth, tongue

Class method: Eat (call mouth, tooth, tongue swallow meal)

Iv. definition of classes in C #

permissions [public external can use class, internal only internal use class] +class + class name

public class Gamescene {

}

A component is also a class, and a class is a complex data type

V. Definition of data members in C #

permissions [public external can be accessed directly, private external (outside the curly braces that define its class) cannot be accessed directly, protected inherited classes can be accessed, internal almost useless]+ type + name of data member

private int age;

private string name;

private int sex;

Vi. definition of methods for C # classes

Permissions + return value type + Name of the method of the class

public int Setage (int.) {

Logic

}

Input raw material, produce milk

Vii. examples of classes in C #

1. Data members (each instance is assigned a set of data members and occupies their own memory, not the same, the group of data members of an instance is packaged as a complex data object, the reference variable points to a complex data type of memory, using reference variables to access memory)

2. Common logic (common, only one, put in memory, black box, input what output what)

MyPerson person; The person here is not an instance of the class, just a reference variable that defines a class instantiation that must be created with the New keyword

Person=new MyPerson (); Now is the instantiation of the class, and the person reference variable points to the instance

You can use an instance of a class to reference a variable to access the instance's data member + call the class's function method

person.age=10;

Person.init_person ("Xiaohong");

Viii. definition of variables in C #

1. Define a member variable (data member) of a class

private int age;

2. Define a local variable (a variable defined inside a function that is valid when the code executes to the function, invalid when leaving the function, memory recycle)

void Start () {

int A;

}

Ix. This object for C #

The function of a class is like a box that enters something into it, executes the logic inside the box, and then outputs or does not output anything.

A method of a known class occupies only a single memory in memory, and all instances of the class are functions that invoke a common class, so how do you know which instance is calling this common function and how to know which instance of the data member is being processed when the logic is being processed?

A This object is required at this time

MyPerson Xiaohong;

Xiaohong=new MyPerson ();

Xiaohong.init_person ("Xiaohong"); Point the This object to the memory that the Xiaohong reference variable points to, specifying that instance together

MyPerson xiaoming;

Xiaoming=new MyPerson ();

Xiaoming.init_person ("Xiaohong");//Point the This object to the memory pointed to by the Xiaoming reference variable, specifying that instance together

function definitions in the MyPerson class

public void Init_person (int age,string name) {

This.age=age; Xiaohong.age=age

This.name=name; Xiaohong.name=name

}

The This object, which is equivalent to passing a variable in the function arguments, (int age,string Name,myperson this), when called Is Xiaohong.init_person ("Xiaohong", Xiaohong);

Through this access to the data of the instance of the specified class within the function, the data member is also accessible by private permission, because the function is inside the class.

X. Recycling of instances

In the function

MyPerson xiaoming;

Xiaoming=new MyPerson ();

MyPerson person=xiaoming;//equals the definition of a person reference variable, also point to the Xiaoming instance, when two reference variables point to the same instance

When the function execution is finished, xiaoming and person are released, equal to now no reference variable to the Xiaoming instance, this instance will be automatically reclaimed by the garbage collector, the original instance object occupied by the memory is also recycled, the programmer is not collected by the tube

Xi. memory model

Generated when the program runs, depending on whether a variable or object is encountered in the execution, whether it is placed in a stack or in heap memory

Stack: Store local variables, recycle after function return

Heap: A complex object that stores new, a data member package, and no reference variable points to the instance memory when it is recycled

Load it into memory, when you click on the exe file

Data segment: Store data (global variables, static data). Habitual memory, never recycled, unless the programmer himself deletes

Code Snippets: Store function instructions, each function has a unique instruction stored in the code snippet, Init_person (), all instances common, one strip execution. Habitual memory, never recycled, unless the programmer himself deletes

About unity in C # Basic Learning