1. Instruction de boucle
L'instruction de boucle est une instruction plus importante en c#.
Définition d'une instruction de boucle
Une instruction de boucle est une boucle de base qui boucle si la condition de boucle est remplie et saute hors de la boucle si elle n'est pas satisfaite. L'instruction de boucle résout le problème selon lequel l'instruction n'est exécutée qu'une seule fois sous la condition if.
Plusieurs types d'instructions de boucle sont répertoriés ci-dessous :
(1) while loop
while (condition de boucle) est une boucle de base, où () est la condition de boucle et l'instruction sous la boucle est exécutée lorsque la condition de boucle est vraie.
Par exemple, voici la somme des 20 premiers nombres :
using System;
namespace A
{
class B
{
static void Main(string[] args)
{
int i=1;
while(i<=20)
{
s=s+i;
i++;
}
Console.WriteLine("前20个数的总和是：{0}",s);
Console.ReadKey();
}
}
}
s'avérer:
前20个数的总和是：210
(2).do-while boucle
do-while est similaire à while mais différent de while en ce que l'instruction do-while consiste à exécuter l'instruction dans la boucle avant de porter un jugement, donc do-while doit exécuter la boucle au moins une fois . comme:
using System;
namespace B
{
class C
{
static void Main(string[] args)
{
int a;
do
{
a=1;
s=s+a;
a++;
}
while(a<=20)
Console.WriteLine("总值是{0}，a的数值为{1}",s,a);
Console.ReadKey();
}
}
}
s'avérer:
总值是210，a的数值为21
(3) La boucle for
est l'instruction de boucle la plus pratique pour l'instruction for en C#.
La forme générale est pour (expression 1 ; expression 2 ; expression 3) L'expression 1 est l'affectation de la variable de boucle. Tel que : i=0, 1, 2....
L'expression 2 sert à évaluer la condition de la boucle. Si elle est vraie, l'instruction de boucle continuera à s'exécuter. Si elle est fausse, elle sortira du corps de la boucle. L'expression 3 augmentera la variable de boucle.
Utilisez pour écrire la somme des 20 premiers nombres :
using System;
namespace B
{
class C
{
static void Main(string[] args)
{
int i,j;
for(i=1;i<=20;i++)
{
s=i+s;
}
Console.WriteLine("总和是：{0}"，s);
Console.ReadKey();
}
}
}
s'avérer:
总和是：210
2. Imbrication de boucles
Après avoir appris la boucle, vous pouvez apprendre l'imbrication de la partie la plus importante de la boucle.
Comme son nom l'indique, l'imbrication des boucles consiste à imbriquer une autre boucle à l'intérieur de la boucle, qui est une double boucle. Si une autre boucle est imbriquée à l'intérieur, il s'agit d'une triple boucle. La double boucle awhlie-whlietaper,tandis que pourtaper,pour pourtype etc
while(表达式) while(表达式)
{
... {
......
while(表达式) for(表达式1;表达式2;表达式3)
{
{
.... ......
} }
} }
for(表达式1;表达式2;表达式3)
{
......
for(表达式1;表达式2;表达式3)
{
......
}
}
La double boucle exécute d'abord la boucle la plus externe, puis exécute la boucle interne, et ne revient à la boucle externe qu'après l'exécution de la boucle interne, puis exécute la boucle interne, et ainsi de suite jusqu'à ce que la boucle externe soit exécutée, et enfin génère le résultat.
Ce qui suit est une formule de quatre-vingt-dix-neuf pour cent écrite avec une double boucle for
using System;
namespace chengfabiao
{
class biao
{
static void Main(string[] args)
{
int i,j;
for(i=1;i<=9;i++)
{
for(j=1;j<=i;j++)
{
s=i*j;
Console.Write("{0}*{1}={2} ",i,j,s);
}
Console.Writeline();
}
Console.ReadKey();
}
}
}
s'avérer:
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
3. Conversion de types
La conversion de type est divisée en conversion explicite et conversion implicite.
(1) Conversion implicite La conversion implicite
est une conversion de bas niveau vers un niveau élevé, telle que la conversion du type int en type double. La conversion implicite ne nécessite pas d'instructions spéciales mais est automatiquement effectuée par le compilateur.
int a = 10;
double b = a;//隐式转换
La règle de conversion implicite est la suivante : tout type A peut être implicitement converti en type B tant que sa plage de valeurs est entièrement contenue dans la plage de valeurs du type B. Sur la base de cette règle de conversion, la conversion implicite de C# n'entraînera pas de perte de données. Il convient de noter que nos types simples bool et string les plus couramment utilisés n'ont pas de conversion implicite.
(2)
Conversion explicite : la conversion du type A au type B ne peut être effectuée que dans certains cas, les règles de conversion sont plus compliquées et un certain type de traitement supplémentaire doit être effectué. La conversion explicite est également appelée conversion de type forcée. La conversion explicite nécessite que l'utilisateur spécifie explicitement le type de conversion. Comme la conversion de données de type double en données de type int.
Par exemple:
double c = 10.5;
int d = (int)c;//显示转换
Avis:
Les conversions explicites peuvent entraîner des erreurs. Le compilateur effectuera une détection de débordement sur la conversion lorsque cette conversion sera effectuée. S'il y a un débordement indiquant que la conversion a échoué, cela signifie que le type source n'est pas un type cible valide. Impossible d'effectuer la conversion de type.
La conversion de type obligatoire entraînera une perte de données. Par exemple, dans l'exemple ci-dessus, la valeur d finale est 10.
4. Encapsulation
En C#, enfermer un ou plusieurs projets dans un package empêche l'accès externe aux détails du projet. L'encapsulation limite les droits d'accès externes. L'encapsulation peut être implémentée avec des modificateurs d'accès.
Voici les modificateurs d'accès et les niveaux :
L'image ci-dessus montre des niveaux croissants d'accès de l'extérieur vers l'intérieur.
(1).modificateur privé
Le modificateur d'accès privé
permet à une classe de masquer ses variables membres et ses fonctions membres des autres fonctions et objets. Seules les fonctions de la même classe peuvent accéder à ses membres privés. Même une instance d'une classe ne peut pas accéder à ses membres privés.
(2).modificateur protégé
Le modificateur d'accès Protected permet à une sous-classe d'accéder aux variables membres et aux fonctions membres de sa classe de base. Cela aide à implémenter l'héritage
(3).modificateur interne
Le spécificateur d'accès interne permet à une classe d'exposer ses variables membres et ses fonctions membres à d'autres fonctions et objets du programme en cours. En d'autres termes, tout membre avec le
modificateur d'accès interne peut être accédé par n'importe quelle classe ou méthode définie dans l'application dans laquelle le membre est défini
(4).modificateur public
Le modificateur d'accès public permet à une classe d'exposer ses variables membres et ses fonctions membres à d'autres fonctions et objets. Tous les membres publics sont accessibles par des classes externes.
Note:En plus d'encapsuler avec les modificateurs ci-dessus, vous pouvez également utiliser get et set, où get est lisible et set est inscriptible.