C#简易知识点

成员命名规则:carColor

属性命名规则:Color

 

int 不能自动(隐士)转换成 char  (但是 VC 中可以)

double 不能自动(隐士)转换成 int

int 可以自动(隐士)转换成 double

 

Xxx.Parse(string)  //字符串转换为 其他类型

如: string s = "123";

     int i = int.Parse(s);  //ok, but if s = "a" then error! so just numeric

     同理有:float.Parse(string)  double.Parse(string)

 

int i = 123;

float f = 45.6;

double d = 153.789;

string s = s = i.ToString();   //ok, but only if i is numeric

string s = s = f.ToString();   //ok, but only if f is numeric

string s = s = d.ToString();   //ok, but only if d is numeric

 

Convert.ToXxx(ObjectValue)  //任意类型 转换为 其他类型

如: string s1 = "123";
     int i = Convert.ToInt32(s1);  //ok, i = 123;

 

     string s2 = "123.45";
     float f = Convert.ToSingle(s2);  //ok, f = 123.45;

 

     string s3 = "123.45";
     double d = Convert.ToDouble(s3);  //ok, d = 123.45;

 

 

值类型存储在堆栈中,如:int, char, 结构等。

引用类型存储在对中,如:类,接口,数组,字符串。 

 

object 类型是所有其他数据类型的基类,它可以表示通用的类型。所有类型都可以转换为 object 类型。

装箱是将值类型转换为引用类型。

拆箱是将引用类型转换为值类型。

如:   int i = 12;
       double d = 23.45;
       object obj;
       obj = i;   //装箱
       Console.WriteLine(obj);  //12;

       int i2 = (int)obj;  //箱,注意要强制类型转换。

       Console.WriteLine(i2);   //12;
       obj = d;   //装箱
       Console.WriteLine(obj);   //23.45;

       double d2 = (double)obj;  //箱,注意要强制类型转换。

       Console.WriteLine(d2);    //23.45;

 

装箱拆箱会消耗性能。大多数情况下,简易性比性能更重要(因为可能考虑到开发速度)。

 

定义数组

type [] name = {value1, value2, ...};

如: int [] a = {1,2,3};  //ok

     int [] a = new int [] { 1, 3, 5, 7, 9 };  //ok

     int [] a = new int [5] { 1, 3, 5, 7, 9 };  //ok

     string [] s = {"abc", "中国", "123"};  //ok

 

     int [] a;  //ok, 声明

     int a[];   //error

     a = new int[5];  //分配空间

 

交错数组 

如: int[][] jaggedArray = new int[2][];   //定义了不一定是矩形的数组

     jaggedArray[0] = new int[4];

     jaggedArray[1] = new int[3];

     jaggedArray[0][2] = 29;   //ok

     jaggedArray[0, 2] = 29;   //error

 

     int[, ] array;

     array = new int[5, 4];   //定义了矩形的数组,5行4列。

     array[3, 2] = 29;   //ok

     array[3][2] = 29;   //error

 

二维数组
– 平面上点的坐标pt(x,y)
– 声明:
• double[,] dbHeight=new double[3,4];
• double[,] dbHeight={ {1,2,3,4},{2,3,4,5},{3,4,5,6} };

 

数组的数组

• 数组的每个元素是数组
• 声明方式
int[][] arrayInt;
– 方式一:
arrayInt=new int[2][];
//注意不能用arrayInt=new int[3][4]!
arrayInt[0]=new int[3];
arrayInt[1]=new int[4];
– 方式二:
arrayInt={new int[]{1,2,3,},new int[]{4,5,6,7}};

 

参数的类型
– 值参数
– 引用参数
– 输出参数

C#输出参数和引用参数的区别

从CLR的角度看,关键字out和关键字ref是等效的,这就是说,无论使用哪个关键字,都会生成相同的元数据和IL代码。但是,C#编译器将两个关键字区别对待,在C#中,这两个关键字的区别在于哪个方法负责初始化引用对象。如果方法的参数标记为out,那么调用者不希望在调用方法之前初始化对象,被调用的方法不能读取对象的值,而且被调用的方法必须在返回之前为对象赋值。如果方法的参数标记为ref,那么调用者必须在调用方法之前首先初始化参数的值,被调用的方法可以读取参数或为参数赋值。

 

一种新类型的参数:参数数组
– 可以使用个数不定的参数调用函数
– 必须是参数定义中的最后一个参数
– 用关键字params说明
– params参数必须是一维数组
– 例如:
public void fun(params in[]args)

 

委托
– 委托使用的目标:把函数作为参数传递
– 类似于C++中的函数指针
– 是事件处理的基础
– 委托是面向对象的、类型安全的和保险的。
– 委托声明:
• delegate double process(double db1);
• delegate 函数返回类型名委托名(函数参数)

 

匿名方法
• 匿名方法(anonymous methods)允许将
与一个委托关联的代码“内联(in-line)”到
使用委托的地方,我们可以很方便地将代
码直接写在委托实例中。
• 匿名方法还共享对本地语句所包含的函数
成员的访问。
• 要将代码块传递为委托参数,创建匿名方
法则是唯一的方法。

 

可空类型
• 可空类型表示可被赋值为null 值的值类型变量。
无法创建基于引用类型的可空类型。(引用类型
已支持null 值。)。
• 语法 T? 是System.Nullable<T> 的简写,此处的
T 为值类型。这两种形式可以互换。
• 为可空类型赋值与为一般值类型赋值的方法相
同,如 int? x = 10; double? d = 4.108;
• 如果基础类型的值为null,请使用
System.Nullable.GetValueOrDefault 属性返回该
基础类型所赋的值或默认值,例如int j =
x.GetValueOrDefault();

• 请使用HasValue 和Value 只读属性测试
是否为空和检索值。可空类型变量的默认
值将HasValue 设置为false。未定义
Value。
• 使用 ?? 运算符分配默认值,当前值为空的
可空类型被赋值给非空类型时将应用该默
认值,如:

         int? x = null;

         int y = x ?? -1; //若 x 为空,则 y 为 -1;

                          //若 x 不为空,则 y 为 x。
• 不允许使用嵌套的可空类型。将不编译下
面一行:Nullable<Nullable<int>> n;

 

泛型
• 泛型允许类、接口、结构、委托和方法通过它们
所存储和操作的数据的类型来指定类型。
• 这些类和方法将一个或多个类型的指定推迟到客
户端代码声明并实例化该类或方法的时候。
• 和使用object类相比,泛型降低了装箱和拆箱的
负担,减少了类型转换所带来的错误
• 使用泛型类型可以最大限度地重用代码、保护类
型的安全以及提高性能。
• 泛型最常见的用途是创建集合类。

 

的成员有以下类型
– 成员常量:代表与类相关联的常量值
– 域即类中的变量
– 成员方法:负责执行类中的计算和其它操作
– 属性:用于定义类中的值并对它们进行读写
– 事件:用于说明发生了什么事情
– 操作符:定义类中特有的操作
– 构造函数和析构函数:分别用于对类的实例进行初始化和销毁

 

静态成员由类访问;非静态成员由对象访问。

 

构造函数和析构函数不能被继承。除此以外的其
它成员,不论对它们定义了怎样的访问方式,都能
被继承。基类中成员的访问方式只能决定派生类能
否访问它们。

 

类可以定义虚方法、虚属性以及虚索引指示器。它
的派生类能够重载这些成员,从而实现类可以展示
出多态性。

 

虚函数:当类中的方法声明前加上了virtual 修饰
符。我们称之为虚方法。反之为非虚。使用了
virtual 修饰符后不允许再有static, abstract, 或
override 修饰符。

 

重载:在派生类中声明对虚方法的重载要求在声明中加上
override 关键字,而且不能有new, static 或virtual
修饰符。

 

public, private, protect, internal

其中 internal 表示在同一个工程中才可以访问(即当前程序集内才可访问)。

 

C# 中的属性可以处理可读可写:

        private string _name;
        public string Name   //Name 属性
        {
            set { _name = value; }   //可写, 其中value是内置的参数
            get { return _name; }    //可读
       

封装字段快捷键 Ctrl+R 然后 Ctrl+E 

 

base关键字可以调用父类的属性和方法,还有父类的构造函数。

如: 

namespace HelloWorld
{
    class Student : Person  //从 Person 类继承了 Name, Age 属性。
    {

        public void 考试()
        {
            Console.WriteLine("考试, 姓名 = {0}, 年龄 = {1}", base.Name, base.Age);
        }

    }
}

调用 考试() 则输出: 考试, 姓名 = XXX, 年龄 = XXX

通过 base 调用基类的构造函数。

        Student(int age, string name)
            : base(age, name)
        {
       

 

 

[访问修饰符] virtual[new][override] [返回值类型] 方法名([参数列表])

{
}

virtual 关键字是用于父类的。

new 和 override 关键字是用于子类的。

 

抽象类

abstract class Person   //抽象类(含有一个抽象方法的类)

{

    public abstract void SayHi();  //抽象方法(即一个没有实现的方法)
}

 

 

虚方法                    抽象方法

--------------------------------------------

在具体类中             在抽象类中

用 virtual 修饰         用 abstract 修饰 

要有方法体              不允许有方法体

可以被子类 override    必须被子类 override   

除了密封类都可以写     只能在抽象类中   

 

 

public class OtherPerson : Student, Teacher   //error,C Sharp 不支持多继承,想要达到目的,可

                                            //以通过接口的方式实现,把 Student,Teacher 都定

                                            //义成接口,再通过 OtherPerson 类对其实现。

 

接口

public interface IPict   //默认也是 public

{

    int DeleteImage();  //只定义,不实现。而且无访问修饰符(如public等)

    void DisplayImage();  //同上

}

 

 

abstract 实现面向对象的多态

例:

abstract class Person   //抽象基类

{

    public void abstract SayHello();

}

class Student : Person

{

    public override void SayHello()

    {

        Console.WriteLine("Student SayHello");

    }

}

class Teacher : Person

{

    public override void SayHello()

    {

        Console.WriteLine("Teacher SayHello");

    }

}

Student 类和 Teacher 类分别实现各自的 SayHello()方法;则:

Person p1 = new Student();

Person p2 = new Teacher();

p1.SayHello();  //输出 Student SayHello

p2.SayHello();  //输出 Teacher SayHello

多态:不同对象受到相同消失时,会产生不同行为。 

 

interface 接口实现多态:

例:

    interface IPerson
    {
        void SayHello();
   

    class Student : IPerson
   

        public void SayHello()
         

            Console.WriteLine("Student SayHello");
        }

    }

    class Teacher : IPerson
    {

        public void SayHello()
        {
            Console.WriteLine("Teacher SayHello");
        }
   
    IPerson p = new Student();
    p.SayHello();   //输出 Student SayHello           

    p = new Teacher();
    p.SayHello();   //输出 Teacher SayHello

 

 

简单工厂设计模式

class Factory

{

    public static Person Create(string name)

    {

        switch (name)

        {

            case "s":

                return new Student();

                break;

            default:

                return new Teacher();

                break;

          

        return null;

    }

}

    interface IPerson
    {
        void SayHello();
   

    class Student : IPerson
   

        public void SayHello()
         

            Console.WriteLine("Student SayHello");
        }

    }

    class Teacher : IPerson
    {

        public void SayHello()
        {
            Console.WriteLine("Teacher SayHello");
        }
   

            IPerson p = Factory.Create("s");
            p.SayHello();   //输出 Student SayHello  
            p = Factory.Create("t");
            p.SayHello();   //输出 Teacher SayHello
  

 

ArrayList 是一个可动态维护长度的集合。

using System.Collections;  //引入命名空间

 

HashTable 可通过关键字来检索数据。

using System.Collections;  //引入命名空间

 

ArrayList 和 HashTable 可存储不同类型的对象,但遍历时可能涉及到类型转换的错误,如果考虑类型安全,可以用泛型。

泛型去数据时不用拆箱,而 ArrayList 和 HashTable 需要拆箱,而且拆箱比装箱耗费大。 

 

典型的泛型集合:  List<T>  Dictionary<K,V>

技巧:

遍历写 foreach 时,可按两下 tab 键。

 

读写文件的步骤:

1. 创建一个文件流。

2. 创建相应的读写器。(reader and writer)

3. 执行读写操作。

4. 关闭读写器。(reader and writer)

5. 关闭文件流。

注意先要引入命名空间   using System.IO;

例:

            string path = "d:\\ttt.txt";

也可以写成  string path = @"d:\ttt.txt";
            FileStream fs = new FileStream(path, FileMode.Create);  //创建文件流
            StreamWriter sw = new StreamWriter(fs);  //创建读写器
            sw.WriteLine("this is a test prog.");  //写操作
            sw.Close();  //关闭读写器
            fs.Close();  //关闭流文件

 

            FileStream fs2 = new FileStream(path, FileMode.Open);   //创建文件流
            StreamReader sr = new StreamReader(fs2);  //创建读写器
            string str = sr.ReadLine();  //读操作。还有 ReadToEnd() 的方法
            Console.WriteLine(str);

            sr.Close();  //关闭读写器
            fs2.Close();  //关闭流文件

 

 

File (静态类)操作举例

            string path = @"d:\ccc.txt";
            if (File.Exists(path))
            {
                Console.WriteLine("file exists!");
            }
            else
            {
                Console.WriteLine("file not exists!");
                StreamWriter sw = File.CreateText(path);
                sw.WriteLine("write finished!");
                sw.Close();
            }

 

Directory (静态类)可以对目录和子目录进行操作

 

静态类                     非静态类

------------------------------------------------------

static 修饰              不用 static 修饰

只包含静态成员           可以包含静态成员

不可以包含实例成员       可以包含实例成员

使用类名调用静态成员     使用实例对象调用非静态成员

不能被实例化             可以被实例化

不能包含实例构造函数     包含实例构造函数

  • 0
    点赞
  • 0
    收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
评论
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值