C# 类和对象

最新推荐文章于 2023-12-26 10:42:19 发布
最新推荐文章于 2023-12-26 10:42:19 发布
阅读量163 收藏
点赞数
文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Inuyasha__/article/details/112191539
版权

类和对象

基本类

修饰符

对于类或者方法，下列修饰符访问性通用

访问修饰符同 类同程序集子类同程序集 非子类不同程序集子类不同程序集非子类
public√√√√√
internal√√√
protected√√√
private√
protected internal√√√√

观察可得，protected只能用于子类继承，internal用于同程序集继承，public都可以继承，private都不能继承

构造函数
class People {
   	private String name;
    private static int cnt;
    // this调用该类本身所声明的其他构造函数
    public People(): this("huro") {}
    public People(String name) {
        this.name = name;
    }
    // 静态构造函数都是私有的
    // 静态构造函数是不可继承的
    // 静态构造函数只能对静态数据成员初始化
    // 如果没有静态构造函数，又有初始设定的静态字段，会自动生成一个静态构造函数
    // 静态构造函数不允许出现访问修饰符例如 private 
    static People() {
        cnt = 0;
    }
}

class Student: People {
    // base 调用该类父类的构造函数
    public Student(String name): base(name);
}
构造函数的执行顺序
  1. 子类静态字段的直接初始化器
  2. 子类静态构造函数
  3. 子类实例字段的直接初始化器
  4. 父类静态字段的直接初始化器
  5. 父类静态构造函数
  6. 父类实例字段的直接初始化器
  7. 父类的构造函数
  8. 子类的构造函数

一个例子

public class Parent {
    public static int a = initA(); // => 4 父类静态字段
    public int b = initB(); // => 6 父类实例字段
    public static int initA() {
        Console.WriteLine("init A"); // => 4 父类静态字段的直接初始化器 
        return 1;
    }
    public static int initB() {
        Console.WriteLine("init B"); // => 6 父类实例字段的直接初始化器
        return 2; 
    }
    static Parent() {
        Console.WriteLine("running parent static"); // => 5 父类静态构造函数
    }
    public Parent() {
        Console.WriteLine("running parent constructor"); // => 7 父类的构造函数
    }
}
public class Child: Parent {
    public static int x = initX(); // => 1 子类静态字段
    public int y = initY(); // => 3 子类实例字段
    public static int initX() {
        Console.WriteLine("init X"); // => 1 子类静态字段的直接初始化器
        return 3;
    }
    public static int initY() {
        Console.WriteLine("init Y"); // => 3 子类实例字段的直接初始化器
        return 4;
    }
    static Child() {
        Console.WriteLine("running child static"); // => 2 子类静态构造函数
    }
    public Child() {
        Console.WriteLine("running child constructor"); // => 8 子类的构造函数
    }
}
public static void Main(String[] args) {
    Child c = new Child();
}

结果为

init X
running child static
init Y
init A   
running parent static
init B    
running parent constructor    
running child constructor
对象初始化
  1. 用大括号的形式初始化 public 属性
public class Bar {
    public String Text {set; get};
}
// 初始化
Bar bar = new Bar { Text = "hello world!"};
  1. 用构造函数
属性

字段是指用 public 修饰符修饰的变量

属性是指封装的变量即用get 和 set 访问器封装的

传统的字段并不可以解决赋值的时候的判断问题，C#提供了一种方法来解决这个问题，可以在设置值的时候对值进行控制

主要分为

  1. 虚拟属性（用于继承）
  2. 只读属性
  3. 只写属性
  4. 重写属性
  5. 自动属性
class People {
    protected string hobby;
    public virtual string PHobby {
        get { return ""; }
        set {}
    }
}

class Student: People {
    private string stu_sex;
    // set 内部的 value 是设置的值
    // 例如 StuSex = 1; 那么value = 1
    public string StuSex {
        get {
            return stu_sex;
        }
        set {
            if (value.Equals("男") || value.Equals("女")) {
                stu_sex = value;
            } else {
                Console.WriteLine("性别只可以是男或者女")
            }
        }
    }
    // 也可以定义只读属性
    private string readonly_attr;
    public string readonlyAttr {
        get {
            return readonly_attr;
        }
    }
    
    // 同理也可以定义只写属性
    // 静态只写属性
    private static int cnt;
    public static int StuCnt {
        set {
            if (cnt >= 0)
            	cnt = value;
        }
    }
    
    // 重写属性
    public override string PHobby {
        get {return hobby;}
        set {hobby = value;}
    }
    
    // 自动属性，系统默认给set和get函数
    public string money {
        get;
        set;
    }
}

需要注意

  1. 属性修饰符与方法修饰符相同，包括了 static , virtual, override 等
  2. get 访问器返回类型与属性类型相同 set 访问器没有返回值，但是有一个默认的隐式参数 value 这个值的类型和属性类型相同
  3. 访问器的访问性不能高于他所属的属性
  4. 不能把属性作为 ref 或 out 参数传递
运算符重载
public class Square {
    int width;
    int height;
    // 如果重载了 == 运算符 就也要重载 != 运算符
    // 同理如果重载了 <= 也要重载 >=
    // 定义了加法 + 不必定义减法 - 没有联系
    public static bool operator == (Square s1, Square s2) {
        return s1.width * s1.height == s2.width * s2.height;
    }
    public static bool operator != (Square s1, Square s2) {
        return s1.width * s1.height != s2.width * s2.height;
    }
}
public static void Main(String[] args) {
    Square s1 = new Square { Width = 10, Height = 20 };
    Square s2 = new Square { Width = 20, Height = 10};
    Console.WriteLine(s1 == s2);
}
数据类型转换
  1. 隐式转换
public class Square {
    public int Width { set; get; }
    public int Height { set; get; }
    // 隐式转换，则在转换的时候不需要明确指出转换对象
    public static implicit operator int(Square s) {
        return s.Width * s.Height;
    }
}
public static void Main(String[] args) {
    Square s1 = new Square { Width = 10, Height = 20 };
    Console.WriteLine(s1);
}
  1. 显式转换
public class Square {
    public int Width { set; get; }
    public int Height { set; get; }
    // 显式转换
    public static explicit operator int(Square s) {
        return s.Width * s.Height;
    }
}
public static void Main(String[] args) {
    Square s1 = new Square { Width = 10, Height = 20 };
    // 需要明确指定转换为 int
    Console.WriteLine((int)s1); // => 200
    Console.WriteLine(s1); // => 命名空间.主类名+Square
}
分部类
// A1.cs
partial class A {
    public void f1() {};
}

// A2.cs
partial class A {
    public void f2() {};
}

// Main
A a = new A();
a.f1();
a.f2();

可以将一个类分布在不同的文件中，使用的时候编译器会自动将他们合起来。

常数
  • 默认是private
  • 常量表达式的值是一个可以在编译的时候计算的值
  • 不允许使用static运算符
  • 和静态成员一样只能通过类名访问
class A {
    const int a = 1;
}
结构

结构大家很熟了，就是用 struct 定义的

下面是区别

结构类
值类型引用类型
可以不使用new实例化必须使用new实例化
没有默认的构造函数但可以添加构造函数有默认的构造函数
没有析构函数有析构函数
接口

接口大家很熟了，就是用 interface 定义的

析构函数
方法功能
System.Object.Finalize这个方法用于回收对象的存储空间，析构函数是在回收对象的存储空间前调用的，最好不要手动调用
System.GC.Collect这个方法用于请求运行垃圾回收器，例如代码中有非常多的资源需要回收
Dispose这个方法用于立即销毁某个对象
Close某个资源可能以后会打开只是暂时关闭

大多数情况下是不需要写析构函数的，因为C#中有垃圾收集器

什么情况下需要自己写析构函数？
  1. 当该类中打开了一个文件，对象销毁时，应当关闭这个文件。
  2. 当该类中打开了数据库，对象销毁时，应当关闭这个连接。
  3. 当该类中申请了大量内存，对象销毁时，应当释放这些内存。

泛型类

.net 泛型 与 C++模板有所不同，C++在用特定类型实例化模板的时候是需要模板的源代码的，但是.net内部是针对基本类型即值类型（int, float ……）和引用类型（类类型）分别制作了类，所以不需要源代码了。

装箱和拆箱

如果在创建一个对象的时候没有指定好类型，可能会进行装拆箱工作，当发生失败的时候还会在运行的时候抛出异常。

var list = new LinkedList();
list.AddLast("2"); // 装箱
list.AddLast(3); // 装箱
foreach(string s in list1) {
    // 拆箱
    Console.WriteLine(s);
}

foreach循环中发现int无法转化为string类型，因此抛出异常

//  System.InvalidCastException:“无法将类型为“System.Int32”的对象强制转换为类型“System.String”。”

指定了泛型后，在编译阶段就会给予错误提示，而且由于不用装箱和拆箱，性能更优

假定LinkedList可以指定泛型类型

var list = new LinkedList<int>();
list.AddLast(1);
list.AddLast(3);
list.AddLast(5);
foreach (int i in list) {
    Console.WriteLine(i);
}
用一个例子认识泛型

下面是一个链表

// 泛型类，泛型参数为 T
public class LinkedList<T> : IEnumerable<T>
{
    // 自动属性，外界不可以修改，只可以内部修改
    public LinkedListNode<T> First { get; private set; }
    public LinkedListNode<T> Last { get; private set; }

    // 增加元素
    public LinkedListNode<T> AddLast(T node)
    {
        var newNode = new LinkedListNode<T>(node);
        if (First == null)
        {
            First = newNode;
            Last = First;
        }
        else
        {
            newNode.Prev = Last;
            Last.Next = newNode;
            Last = newNode;
        }
        return newNode;
    }

    // 实现遍历接口，c# 语法糖有 yield 相关说明
    public IEnumerator<T> GetEnumerator()
    {
        LinkedListNode<T> current = First;

        while (current != null)
        {
            yield return current.Value;
            current = current.Next;
        }
    }

    // 这里必须指定是 IEnumerable下的GetEnumerator 否则会和上面的那个方法出现歧义性，调用的时候编译器不知道调用哪一个
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

下面是链表节点的定义

public class LinkedListNode<T>
{
    public LinkedListNode(T value)
    {
        this.Value = value;
    }
    // 只能内部设置
    public T Value { get; private set; }
    // internal set 是指同一个程序集可以修改，前面修饰符有说到了
    public LinkedListNode<T> Next { get; internal set; }
    public LinkedListNode<T> Prev { get; internal set; }
}
一些泛型的问题
  1. 无法假定T1一定有构造函数
class Demo<T1> {
    private T1 innerObject;
    public Demo() {
        innerObject = new T1();
    }
}
  1. 无法假定类型一定是引用或者是值类型
class Demo<T1, T2> {
    public bool Compare(T1 op1, T2 op2) {
        return op1 == op2;
    }
}

由于无法假定类型，所以不知道赋值为 null 或者 0，这个时候可以用 default 关键字进行赋值，如果T1 是引用类型，那么 default 会赋值为 null

class Demo<T1> {
    public void empty(T1 op) {
        op = default;
    }
}
抗变和协变

抗变和协变其实很简单

public void Display(Shape o) {}

例如这个方法，我们可以传递 Shape 类，当然还可以传递他的子类，这个就叫做协变。

public Shape GetShape() {}

而作为返回值的时候，我们知道他返回的是 Shape 类，假设 Rectangle 类是 Shape 类的子类

Reactangle r = GetShape();

这行代码是不可以的，因为 Shape 不一定是 Rectangle，这就叫做抗变，即抵抗改变，不愿意改变。

泛型接口的协变和抗变

如果泛型类型用out关键字标注，泛型接口就是协变的

public interface IIndex<out T> {
    T this[int index] { get; }
    int Count { get; }
}

协变类型参数只能作为方法的返回值或者get访问器返回值用。

如果泛型类型用in关键字标注，泛型接口则是抗变的

public interface IDisplay<in T> {
    void Show(T item);
}

这乍一看好像和上面的抗变和协变反过来了。

其实是为了下面的使用

List<Object> list1 = new List<Object>(){0, 1, 2};
List<int> list2 = new List<int>();
foreach(Object obj in list1)
{
  list2.Add((int)obj);
}

我们这样做转换的话，需要花费两倍的内存

IIndex<Rectangle> rectangles = RectangleCollection.GetRectangles();
IIndex<Shape> shapes = rectangles;

我们明确协变参数只会作为方法的返回值或get访问器

我们会尽可能复用 Rectangle 中的方法，因为返回 Rectangle 不也是 Shape 吗，这样就不会出现类型转换的问题。

同理抗变也是这样的。因此我们也可以解释了

  1. 如果实现了协变接口，那么可以完成子类向父类的转化
  2. 如果实现了抗变接口，那么可以完成父类向子类的转化

编译器会自动帮我们去实现复用。

类型约束
约束说明
where T: structT 必须是值类型
where T: classT 必须是引用类型
where T: IFooT 必须实现接口或是接口本身
where T: FooT 必须是基类或者派生与基类
where T: new()T 必须有一个公有无参构造函数
where T1: T2T1 必须 派生为 T2

注意如果用new() 作为约束，那么就必须是指定的最后一个约束

public class Demo<T> where T: Foo(), new() {}
泛型继承要求

必须是重复接口的泛型类型或者必须指定基类的类型

  1. 重复接口的泛型类型
public class Base<T> {
    // ...
}
public class Derived<T>: Base<T> {
    // ...
}
  1. 指定基类的类型
public class Base<T> {
    // ...
}
public class Derived<T>: Base<string> {
	// ...   
}

派生类未必要是泛型类

public class Base<T> {
    // ...
}
public class Derived: Base<int> {
 	//...   
}
  1. 类型约束继承

原先 Farm 的要求是 T 必须是 Animal 类型的

class Farm<T>: where T: Animal {
    // ...
}

继承后做的要求必须至少与基类型的相同，即至少范围要比Animal来的小，要是Animal的子类或者Animal

class SuperFarm<T>: Farm<T> where T: SuperCow {
    // ...
}

以下就是不可以的，因为class是指引用类型，范围更广了

class SuperFarm<T>: Farm<T> where T: class {
    // ...
}
静态成员

泛型类静态成员只能在类的一个实例中共享，即是不互通的

public class StaticDemo<T> {
    public static int x;
}

StaticDemo<string>.x = 4;
StaticDemo<int>.x = 5;
泛型方法
void Swap<T>(ref T x,ref T y) {
    T temp;
    temp=x;
    x=y;
    y=temp;
}

这个方法用于交换两个数字的值

可以这样调用

int i = 4, j = 5;
Swap<int>(ref i, ref j);

也可以简化调用

Swap(ref i, ref j);

方法是泛型的可以简化调用，类不行。

泛型方法也可以重载

public T Bar<T>(T value) {
    return value;
}
public int Bar(int value) {
    return value;
}
public T Foo(T value) {
    return Bar(value);
}

如果直接调用

Bar(1); // 会调用上述第二个，因为最为精确
Bar("1"); // 会调用上述第一个
Foo(1); // 会调用上述第三个和第一个，因为编译期间就决定了，这个Foo中的Bar是第一个，都是类型T
Foo("1"); //同上
泛型委托
public delegate T1 MyDelegate<T1, T2>(T2 op1, T2 op2) where T1: T2;
樂_smile
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C# 将一个对象转换为指定类型
weixin_33922670的博客
09-08 2985
原文地址：点击打开链接 适用：普通的对象，并且有默认的无参数构造函数 #region 将一个对象转换为指定类型 /// <summary> /// 将一个对象转换为指定类型 /// </summary> /// <param name="obj">待...
C#类和对象
06-06
C#类和对象
c# 将object尝试转为指定对象
banyu0433的博客
12-24 1388
主方法： 1 /// <summary> 2 /// 将object尝试转为指定对象 3 /// </summary> 4 /// <param name="data"></param> 5 /// <returns>&lt...
转:《Effective C#》Item 3：使用as和is操作符来做类型转换
flyskylf的专栏
09-30 688
转:http://dev.csdn.net/author/Knight94/373eb00c0a5340cfb75335712707d921.htmlEffective C#》Item 3：使用as和is操作符来做类型转换  在程序中，进行类型转换是常见的事。那么在C#中支持以前语言的类型转换方法，即用类型名进行强行转换，例如：object objTest = new NewT
c# object类型转为指定对象
ADONETXUEXUZHE的博客
10-19 736
将object类型json数据转化为特定的对象。
C# 根据指定的类型，动态转换object数据到指定类型
最新发布
weixin_43632687的博客
12-26 739
动态转换数据类型
C#编程自学之类和对象
12-26
在之前的文章中介绍了C#是一种完全面向对象的语言，既然是完全面向对象的语言就应该用面向对象的模式去学习C#，不了解面向对象？不必担心。这篇文章将介绍学习C#基础部分所要用到的面向对象的知识，后面文章我们将...
2005.net c#类和对象
05-20
本课件“2005.net c#类和对象”旨在深入浅出地讲解C#中类与对象的概念、特性及其实际应用，非常适合初学者入门学习。 首先，我们要理解什么是类。类是C#中的一个核心概念，它是对象的蓝图或模板。类定义了一组属性...
详解C# 利用反射根据类名创建类的实例对象
01-20
1、假设你要反射一个 DLL 中的类，并且没有引用它（即未知的类型）： Assembly assembly = Assembly.LoadFile(程序集路径，不能是相对路径); // 加载程序集（EXE 或 DLL） dynamic obj = assembly....
c# 类型转换
01-20
CLR允许将一个对象转换为它的实际类型，或者它的基类型。 在Ｃ＃中，可将一个对象隐式转换为它的基类型，将对象转换成派生类型需要显示转换。例： object o = new Emplee(); Emplee e = (Emplee)o; 但是如果将一个对象转换成自己的派生类型是，会运行时报错： object o = new object(); Emplee e = (Emplee)o; 所以CLR是类型安全的。 c#中is as的操作符用法 在c#语言中，进行类型转换的另一个方式是使用is as操作符。 is：检查对象是否兼容指定对象，返回bool类型。 例： object o = new ob
c# 所有类型都从Object类型派生
12-31
CLR要求每一个类型都最终从object类型派生，如下： class Typer {} === class Typer ：object {} 上面是完全相等的。 所有的类型最终从object派生，每一个类型都有一组最基本的方法： Equals：如果两个对象相等，返回True GetHashCode：返回对象值的一个哈希码 ToString：默认返回类型的完整名称，int等类型被重写 GetType：返回调用的那个对象的类型 此外，从object派生类型能访问受保护的方法 MemberWiseClone:返回一个新实类 Finalize:虚方法，在内存回收之前调用 CLR要求所有的对象都用NEW
c#实现object与byte[]互转
05-31
c#实现object与byte[]互转、序列化
C#中的类型转换
讲述工作、生活、技术中的日常与感悟。
02-06 1664
前言 前几篇文章中经常说到强制类型转换，就是可以将派生类对象强制转换为基类对象的做法或者通过as运算符进行的转换。 今天我们就来一起简单了解复习下在C#中都有哪些类型的转换。 要理解转换很容易，日常的开发编码过程中，由于变量类型的不同我们可能会根据业务的变更会进行变量值之间的转换。这里就会出现类型转换。比如Int型变量转换为String类型等等。 这里转换是接受一个类型的值并使用它作为另一个类型的等价值的过程，转换后的值应和源值一样。 如下就是典型的强制类型转换 short temp = 5; sbyt
C#中类型转换方法
计算机相关知识
07-30 937
C#中内置了很多类型转换方法如下： 序号 方法 &amp; 描述 1 ToBoolean 如果可能的话，把类型转换为布尔型。 2 ToByte 把类型转换为字节类型。 3 ToChar 如果可能的话，把类型转换为单个 Unicode 字符类型。 4 ToDateTime 把类型（整数或字符串类型）转换为 日期-时间 结构。 ...
类的const限定符
diaolingle的专栏
04-19 357
例子1： class A { public: A() {} ~A() {} public: int Test() const { printf("const\n"); return 0; } int Test() { printf("non const\n"); return 0; } static int Change() const //这个定义
关于static修饰符
Code & Data & Finance
03-28 739
[C++]关于static修饰符 2010年07月01日 星期四 21:58 一、类的 static数据成员 1. 类的 static数据成员必须在类外部进行初始化。            class Test { public: ... ... pr
静态构造函数
cabicmi的博客
03-02 5141
一、定义　　由名称可知，静态构造函数（也称为类型构造函数）包含“静态”和“构造函数”两个特点。第一个特点决定了它与静态函数类似，只能使用静态成员；第二个特点决定了它与构造函数类似，具有初始化作用，并且没有返回值。　　与构造函数（针对实例对象）不同的是，静态构造函数（针对类）只执行一次，并且是在第一个实例对象创建前被调用，所以它可以用于那些只需要执行一次的操作；而且它不允许有public等修饰符，由...
深入理解Static关键字修饰符
weixin_30869099的博客
06-17 225
一、Static关键字修饰符 　　1.修饰类和变量 　　　　1） 使用static关键字来修饰的类，这个静态类里面所有的属性和方法必须是static关键字来修饰　　　　2） 没有使用static关键字来修饰的类，也可以用static来修饰类里面的属性和方法　　　　3） 使用static关键字来修饰的类，这个类不需要实例化，直接通过类名.属性/方法　　　　4） const 和 static 不...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值