C#基础语法

2017-10-13  本文已影响0人  哈哈哈哈哈啊啊啊

一、 打印

Console.Write(); //输出后不换行
Console.WriteLine(); //输出后换行

二、 C#程序结构

命名空间（namespace）,一个class，class方法，class属性，一个Main方法，语句，表达式，注释

namespace HelloWorldApplication {
class HelloWorld{
static void Main(String[] args){
Console.writeLine("Hello World");
Console.ReadKey();
}
}
}

2.1注意

C#是大小写敏感的
所有的语句和表达式以分号结尾
文件名可以不同于类名
程序的执行从Main方法开始
编译和执行
1）在vs中点击Run按钮或者按下F5键来运行程序
2）命令提示符工具，定位到文件所保存的目录CSC helloworld来执行程序

三、C#的数据类型

3.1值类型

bool，byte，char，double，float，int

3.2引用类型

当一个值类型转换为对象类型时，被称为装箱，当一个对象类型转换为值类型时，被称为拆箱
实例：

int val = 8;
object obj = val;//整型数据转换为了对象类型（装箱）
拆箱：之前由值类型转换而来的对象类型再转回值类型, 实例：
int val = 8;
object obj = val;//先装箱
int nval = （int）obj;//再拆箱
只有装过箱的数据才能拆箱

3.3 动态类型

可以存储任何类型的值在动态数据类型中，与对象类型相似，但对象类型检查在编译时发生的，而动态类型变量的类型检查是在运行时发生的

3.4字符串类型

允许给变量分配任何字符串值
可以用@'<script type='text/javaScript'></script>'

3.5指针类型

声明指针的语法
type* identifier;

四、C# 类型转换

类型转换从根本上说是类型铸造，或者说是把数据从一种类型转换为另一种类型，在C#中，类型铸造有两种形式：
1）隐式类型转换-这些转换是C#默认的以安全方式进行的转换，不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类
2）显示类型转换-强制类型转换，显示转换需要强制转换运算符，而且强制转换会造成数据丢失

double d = 56.34
int i;
i=(int)d;

4.1 类型转化的方法

ToBoolean,转化为布尔型
ToByte，转化为字节型
ToChar，转化为Unicode字符类型
ToDateTime，转换为日期-时间结构
ToDecimal,把浮点型或者整数类型转换为十进制类型
ToDouble,转换为双精度类型
ToInt16,转换为16位整数类型
ToInt32，转换为32位整数类型

4.2 类型之间的转换-Convert和Parse

string locstr=123.ToString();
int i=Convert.ToInt16(locstr);
int ii=int.Parse(locstr);

五、变量的定义

int i,j,k;

六、常量

常量是固定值，程序执行期间不会改变，常量可以是任何数据类型。

6.1整数常量

整数常量可以是十进制数，八进制数，或者十六进制数的常量

6.2 定义常量

常量使用const关键字来定义的
const double pi=3.1415926

字符常量

字符常量是在单引号中，一个字符常量可以是一个普通的字符，一个转义序列，或者一个通用字符

字符串常量

字符串常量在双引号中，或者在@""中，字符串常量包含的字符与字符常量相似

七、运算符

7.1算数运算符

7.2 关系运算符

7.3 逻辑运算符

7.4 位运算符

7.5 赋值运算符

7.6 其他运算符

sizeof():返回数据类型的大小
typeof():返回class的类型
&：返回变量的地址
*：变量的指针
is：判断变量是否为某一类型
as：强制转换，即使转换失败也不会抛出异常

八、 封装

封装被定义为‘把一个或多个项目封闭在一个物理的或者逻辑的包中’，在面向对象程序设计方法论中，封装是为了防止实现细节的访问
C#封装根据具体的需要，设置使用者的访问权限，并通过访问修饰符来实现

8.1 访问修饰符

九、 方法

每一个C#程序至少有一个带有Main方法的类

9.1 定义方法

访问修饰符 返回类型 方法名称 （参数列表）{方法主体}

9.2 调用方法

using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int factorial(int num) {

        int result;
       if (num == 1)
        {
            return 1;
        }
        else
        {
            result = factorial(num - 1) * num;
            return result;
        }
    }
    static void Main(string[] args)
    {
        NumberManipulator n = new NumberManipulator();//调用 factorial 方法
        Console.WriteLine("6 的阶乘是： {0}", n.factorial(6));
        Console.WriteLine("7 的阶乘是： {0}", n.factorial(7));
        Console.WriteLine("8 的阶乘是： {0}", n.factorial(8));
        Console.ReadLine();
    }
}

}

9.3 参数传递

public void swap(ref int x,int y)

using System;
namespace CalculatorApplication

{
class NumberManipulator
{
public void getValue(out int x )
{
int temp = 5;
x = temp;
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();/* 局部变量定义 */
int a = 100;
Console.WriteLine("在方法调用之前，a 的值： {0}", a);
n.getValue(out a);
Console.WriteLine("在方法调用之后，a 的值： {0}", a);
Console.ReadLine();
}
}
}

十、 可空类型（Nullable）

可空类型可以表示其基础值类型正常范围内的值，再加上一个null值

十一、 数组

数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合，通常认为数组是一个同一类型变量的集合

11.1声明数组

double [] balance;

11.2 初始化数组

声明一个数组不会在内存中初始化数组，当数组是一个引用类型，所以需要使用new关键字来创建数组的实例

double [] balance=new double[10];

十二、 string类的方法

十三、 结构

结构是值类型结构，它使得一个单一变量可以存储各种数据类型的相关数据，定义结构必须使用struct，struct语句为程序定义了一个带有多个成员的新的数据类型

struct Books
{
public string title;
public string author;
public string subject;
public int book_id;
}

13.1 结构的特点

using System;
struct Books
{
public string title;
public string author;
public string subject;
public int book_id;
};
public class testStructure
{
public static void Main(string[] args)
{
Books Book1; /* 声明 Book1，类型为 Book /
Books Book2; / 声明 Book2，类型为 Book */
Book1.title = "C Programming";
Book1.author = "Nuha Ali";
Book1.subject = "C Programming Tutorial";
Book1.book_id = 6495407;
Book2.title = "Telecom Billing";
Book2.author = "Zara Ali";
Book2.subject = "Telecom Billing Tutorial";
Book2.book_id = 6495700;
Console.WriteLine( "Book 1 title : {0}", Book1.title);
Console.WriteLine("Book 1 author : {0}", Book1.author);
Console.WriteLine("Book 1 subject : {0}", Book1.subject);

  Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);
  Console.WriteLine("Book 2 title : {0}", Book2.title);
  Console.WriteLine("Book 2 author : {0}", Book2.author);
  Console.WriteLine("Book 2 subject : {0}", Book2.subject);
  Console.WriteLine("Book 2 book_id : {0}", Book2.book_id);       
  Console.ReadKey();

}
}

十四、 枚举

枚举是一组命名整型常量，使用enum关键字声明，C#枚举是值数据类型，换句话说，枚举包含自己的值，且不能继承或传递继承

14.1声明变量

enum <enum_name>(指定枚举的类型名称)
{
enumeration list是一个用逗号分隔的标识符列表
}

十五、 继承

继承是面向对象程序设计中最重要的概念之一，当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可

15.1 基类和派生类

一个类可以派生自多个类或接口，这意味着它可以从多个基类或接口继承数据和函数.

using System;
namespace InheritanceApplication
{
class Shape
{
public void setWidth(int w)
{
width = w;
}
public void setHeight(int h)
{
height = h;
}
protected int width;
protected int height;
}
class Rectangle: Shape
{
public int getArea()
{
return (width * height);
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle Rect = new Rectangle();
Rect.setWidth(5);
Rect.setHeight(7);
Console.WriteLine("总面积： {0}", Rect.getArea());
Console.ReadKey();
}
}
}

15.2 基类的初始化

派生类继承了基类的成员变量和成员方法，因此父类对象应在子类对象创建之前被创建

using System;
namespace RectangleApplication
{
class Rectangle
{
protected double length;
protected double width;
public Rectangle(double l, double w)
{
length = l;
width = w;
}
public double GetArea()
{
return length * width;
}
public void Display()
{
Console.WriteLine("长度： {0}", length);
Console.WriteLine("宽度： {0}", width);
Console.WriteLine("面积： {0}", GetArea());
}
}//end class Rectangle
class Tabletop : Rectangle
{
private double cost;
public Tabletop(double l, double w) : base(l, w)
{ }
public double GetCost()
{
double cost;
cost = GetArea() * 70;
return cost;
}
public void Display()
{
base.Display();
Console.WriteLine("成本： {0}", GetCost());
}
}
class ExecuteRectangle
{
static void Main(string[] args)
{
Tabletop t = new Tabletop(4.5, 7.5);
t.Display();
Console.ReadLine();
}
}
}

15.3 多重继承

多重继承是一个类别可以同时从多于一个父类继承行为与特征的功能，与单一继承相对，单一继承指一个类别可以继承自一个父类
C#不支持多重继承，但是可以通过接口来实现多重继承

using System;
namespace InheritanceApplication
{
class Shape
{
public void setWidth(int w)
{
width = w;
}
public void setHeight(int h)
{
height = h;
}
protected int width;
protected int height;
}
public interface PaintCost
{
int getCost(int area);
}
class Rectangle : Shape, PaintCost
{
public int getArea()
{
return (width * height);
}
public int getCost(int area)
{
return area * 70;
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle Rect = new Rectangle();
int area;
Rect.setWidth(5);
Rect.setHeight(7);
area = Rect.getArea();
Console.WriteLine("总面积： {0}", Rect.getArea());
Console.WriteLine("油漆总成本： ${0}" , Rect.getCost(area));
Console.ReadKey();
}
}
}

十六、C#多态性

多态性意味着多种形式，在面向对象编程范式中，多态性往往表现为“一个接口，多个功能”，多态性可以是静态的或动态的，在静态多态性中，函数的响应式是在编译时发生的，在动态多态性中，函数的响应是咋运行时发生的

16.1 静态多态性 函数重载

函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同，不能重载只有返回类型不同的函数声明

16.2动态多态性

C#使用关键字abstract创建抽象类，用于提供接口的部分类的实现
抽象类的规则：

十七、接口

using System;
interface IParentInterface
{
void ParentInterfaceMethod();
}
interface IMyInterface : IParentInterface
{
void MethodToImplement();
}
class InterfaceImplementer : IMyInterface
{
static void Main()
{
InterfaceImplementer iImp = new InterfaceImplementer();
iImp.MethodToImplement();
iImp.ParentInterfaceMethod();
}
public void MethodToImplement()
{
Console.WriteLine("MethodToImplement() called.");
}
public void ParentInterfaceMethod()
{
Console.WriteLine("ParentInterfaceMethod() called.");
}
}

十八、 命名空间

命名空间的设计目的是提供一种让一组名称与其他名称分隔开的方法，在一个命名空间中声明的类的名称与另一个命名空间中声明的相同的类的名称不冲突

18.1 定义命名空间

namespace namespace_name{}

18.2 using 关键字

using关键字表明程序使用的是给定命名空间中的名称

using Project = PC.MyCompany.Project

using (Font font3 = new Font("Arial", 10.0f),
font4 = new Font("Arial", 10.0f))

18.3 嵌套命名空间

命名空间可以被嵌套

十九、 预处理器指令

二十、 异常处理

异常是在程序执行期间出现的问题

20.1 C#中的异常类

C#中的异常类主要是直接或者间接的派生于System.Exception
System.ApplicationException 和 System.SystemException 类是派生于 System.Exception 类的异常类。
System.ApplicationException 类支持由应用程序生成的异常。所以程序员定义的异常都应派生自该类。
System.SystemException 类是所有预定义的系统异常的基类。
下面是派生自System.SystemException

二十一、 C#文件的输入与输出

一个文件是一个存储在磁盘中带有指定名称和目录路径的数据集合
输入流用于从文件读取数据，输出流用于向文件写入数据

21.1 C#中的I/O类

System.IO 命名空间有各种不同的类，用于执行各种文件操作，如创建和删除文件、读取或写入文件，关闭文件等。
下表列出了一些 System.IO 命名空间中常用的非抽象类：

上一篇 下一篇

猜你喜欢

热点阅读