当前位置：首页 > news >正文

面向对象语法糖ArrayList集合，队列，栈泛型与异常

news 2026/6/2 7:46:52

一.面向对象主要分为封装，继承和多态三大原则

1.什么是封装

封装是指将对象的行为和属性封装到一起，隐藏内部的细节，通过接口来与外部进行连接，封装可以通过修饰符public,protected,private来设置访问外部的权限。

public:公共的，表示可以通过创建对象直接调用该对象或者方法。

class Person{ public string name; } class Test{ public static void Main(string[] args) { Person person = new Person(); Console.Writeline(person.name); } }

protected:受保护的，只能被继承对象调用对象或者方法。

class Person{ protected string name; } class Student : Person { } class Test{ public static void Main(string[] args) { Person person = new Student(); Console.Writeline(person.name); } }

而private私有的则无法被外部类的对象调用，但是可以通过public的get,set方法来间接访问private数据，被封装的对象不会被直接访问和修改

class Person{ private string name; public string Name { get { return name;} set {name = value;} } } class Student : Person { } class Test{ public static void Main(string[] args) { Person person = new Student(); Console.Writeline(person.Name); } }

2.什么是继承

继承是指一个类可以继承另一个类的所有非私有属性和方法，从而实现代码的复用和扩展，并且继承的类也可以拥有自己的属性和方法，继承只支持多层继承，不支持多重继承。

class Person{ public string name; } class Student : Person{} class Children : Student{} class Test{ public static void Main(string[] args) { Person child= new Children(); Console.Writeline(child.name); } }

当子类有与父类方法名相同的同名方法，调用子类方法时会隐藏父类的同名方法，如果需要调用父类的同名方法则需要base关键词进行实现。当子类方法与父类方法构成重载时则不会隐藏父类方法。

class Person{ public string name; public void Go() { Console.WriteLine("走路"); } } class Student : Person{ public void Go() { Console.WriteLine("跑步"); } } class Test{ public static void Main(string[] args) { Student stu= new Student(); stu.Go(); } }

子类会默认继承父类的无参构造函数，当父类出现有参构造函数时，子类则无法再调用父类的构造函数，则需要在子类中调用父类的有参构造函数或者父类重写一个无参构造函数

在继承中如果子类要使用同名方法有两种方式可以选择，其一是方法的重载，其二是方法的重写。

方法的重载是子类和父类方法名相同但方法中的参数不同，子类对象可以依据不同的方法参数调用父类和子类的同名不同参的方法。

方法的重写是子类重新定义父类的方法，父类需要使用virtual关键字将方法变成虚方法。子类则使用override关键字重写方法。

3.什么是多态

多态是指同一个方法被不同的对象调用从而表现出不同的行为，主要通过方法的重载与方法的重写来实现

class Person{ public string name; public virtual void Go()//方法的重写 { Console.WriteLine("走路"); } public void eat() { Console.WriteLine("吃饭"); } } class Student : Person{ string name; public override void Go() { Console.WriteLine("跑步"); } public void eat(string name)//方法的重载 { Console.WriteLine($"{name}吃饭") } } class Test{ public static void Main(string[] args) { Person stu= new Student(); stu.Go(); stu.eat(); stu.eat("小明"); } }

二.语法糖

1.语法糖的作用

语法糖也被称作是糖衣语法，作用是减少代码量，增强代码的可读性，减少代码的出错风险。

2.var的作用

使用var修饰的字段会根据字段所赋值的内容在编译期间判断字段的数据类型。一旦字段的数据类型被推断则不能更改为其他类型。

class Person { var name = "小明" } class Test { public static void Main(string[] args) { Person p = new Person(); Console.WriteLine(name.type); } }

3.dynamic的作用

使用dynamic修饰的字段在编译期间不会被给予确定的数据类型，可以给该字段赋值不同属性的内容，dynamic会在运行时判断该字段最后的数据类型。

class Person { dynamic name = "小明" name = 10 ; } class Test { public static void Main(string[] args) { Person p = new Person(); Console.WriteLine(name.type); } }

三.ArrayList集合，队列，栈

1.ArrayList的使用方法

ArrayList是一种高级的动态数组，可以通过Add(元素)方法动态添加元素,也可以使用Insert(索引，元素)将元素插入数组，还可以使用Remove(元素），RemoveAt(索引)和RemoveRange(索引,移除元素数)删除指定的元素或者范围内的所有元素。当要清除ArrayList中的所有元素时可以使用Clear()方法清除数组中的所有元素。

ArrayList元素可以使用Contains(元素)方法进行查找，返回bool类型的值。也可以使用IndexOf(元素)和IndexOf(元素,查找开始位置的索引)返回查找的元素的索引值。还可以使用LastIndexOf()方法，与前面的IndexOf方法传相同的参数，不过是从最后一个元素往前找，同样返回查找元素的索引值

ArrayList可以使用foreach遍历集合的各个元素。

2.Queue队列的使用方法

Queue是一种先进先出的集合，队列无法进行通过下标查询,插入的功能，且没有排序功能。队列可以通过Enqueue(元素)的方法向队尾添加元素，也可以使用Dequeue()的方法取出队首的元素。

Queue可以通过Peek()方法读取队尾的元素，也可以使用Contains(元素)的方法判断元素是否在队列中

3.Stack栈的使用方法

Stack是一种后进先出的集合，同样无法进行插入和下标查询的功能。Stack可以通过push(元素)方法进行入栈操作，也可以使用Pop()方法进行出栈操作。

Stack可以通过Peek()方法读取栈顶ye，也可以使用Contains(元素)的方法判断元素是否在栈中

四.泛型与异常

1.泛型的作用

泛型有泛型类，泛型方法，泛型接口，泛型约束等等。它的主要作用就是实现代码的复用，减少代码冗余。

泛型类：

public class Person<T> { public T name public void ass(T name) { Console.WriteLine($"{name}",name); } } class Work { public static void Main(string[] args) { Person<int> p1 = new Person<int>(); p1.ass(123); Person<string> p2 = new Person<string>(); p2.ass("小明"); } }

泛型方法：

class Work { public static void Main(string[] args) { int i = ass<int>(1); string j = ass<string>("j"); } public T ass<T>(T t) { return t; } }

泛型接口:

public interface Person<T> { public T name void ass(T name); } public class Teacher : Person<int> { public override void ass(int name) { Console.WriteLine($"Teacher name :{name}",name); } } public class Student<T> : Person<T> { public override void ass(T name) { Console.WriteLine($"Student name :{name}",name); } } class Work { public static void Main(string[] args) { Teacher tea = new Teacher(); tea.ass(1); Student<int> stu1= new Student<int>(); stu1.ass(2); Student<string> stu2= new Student<string>(); stu2.ass("stu2"); } }

泛型约束:

public class Person { public string name public void ass(string name) { Console.WriteLine($"{name}",name); } } public class Student<T> where T : Person { } class Work { public static void Main(string[] args) { Student<Person> stu = new Student(Person); stu.ass("小明"); } }