基础知识一: 面向对象的基本知识

C#基础共分为七个部分:

　　一: 面向对象

二: 值类型, 引用类型, 字符串操作

　　三: 集合文件操作

　　四: 正则表达式

　　五: XML操作

　　六: 委托, 事件

　　七: 反射

1, 面向对象:

　　面向对象的三大特性: 封装, 继承, 多态

2, 什么是类? 什么是对象? 类和对象的区别?

　　类: 类似模子, 确定对象将会拥有的特征(属性) 和行为 (方法)

　　对象是一个你能够看得到, 摸得着的具体实现-- 万物皆对象.

　　　　--类是模具, 创建对象的模具, 抽象的

　　　　   .类是一组数据类型, 用户自定义的数据类型.

　　　　　.类组成: 字段, 属性, 方法, 构造函数.

　　　　--对象是具体的, 是类的具体实例. 对象是具有属性(特征)和方法(行为)

　　　　--类中包含了数据(用字段标示)与行为(用方法(函数, 功能)标示, 方法为一块具有名称的代码)

3, 知识点总结

封装继承多态

一、封装：

　　封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。被封装的对象通常被称为抽象数据类型。

 封装的意义：
　　封装的意义在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改。

　　封装提供了一个有效的途径来保护数据不被意外的破坏。相比我们将数据（用域来实现）在程序中定义为公用的（public）我们将它们(fields)定义为私有的（privat）在很多方面会更好。私有的数据可以用两种方式来间接的控制。第一种方法，我们使用传统的存、取方法。第二种方法我们用属性（property）。

　　使用属性不仅可以控制存取数据的合法性，同时也提供了“读写”、“只读”、“只写”灵活的操作方法。

访问修饰符：

二、继承：

　　继承主要实现重用代码，节省开发时间。

１、C#中的继承符合下列规则：

    1. 继承是可传递的。如果C从B中派生，B又从A中派生，那么C不仅继承了B中声明的成员，同样也继承了A中的成员。Object类作为所有类的基类。
    2. 派生类应当是对基类的扩展。派生类可以添加新的成员，但不能除去已经继承的成员的定义。
    3. 构造函数和析构函数不能被继承。除此之外的其它成员，不论对它们定义了怎样的访问方式，都能被继承。基类中成员的访问方式只能决定派生类能否访问它们。
    4. 派生类如果定义了与继承而来的成员同名的新成员，就可以覆盖已继承的成员。但这并不因为这派生类删除了这些成员，只是不能再访问这些成员。
    5. 类可以定义虚文法、虚属性以及虚索引指示器，它的派生类能够重载这些成员，从而实现类可以展示出多态性。

　　２、new关键字

　　　如果父类中声明了一个没有friend修饰的protected或public方法，子类中也声明了同名的方法。则用new可以隐藏父类中的方法。（不建议使用）

　　３、base关键字

　　　base 关键字用于从派生类中访问基类的成员：

    1. 调用基类上已被其他方法重写的方法。
    2. 指定创建派生类实例时应调用的基类构造函数。

 三、多态

　　１、多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。

　　编译时的多态性：

　　编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。

　　运行时的多态性：

　　运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中，运行时的多态性通过虚成员实现。

　　编译时的多态性为我们提供了运行速度快的特点，而运行时的多态性则带来了高度灵活和抽象的特点。

　　２、实现多态：

    1. 接口多态性。
    2. 继承多态性。
    3. 通过抽象类实现的多态性。

　　３、override关键字：

　　　重写父类中的virtual修饰的方法，实现多态。

五个访问修饰符

　　Private:只有类本身能存取.
　　Protected:类和派生类可以存取.
　　Internal:只有同一个项目中的类可以存取.
　　Protected Internal:是Protected和Internal的结合. 
　　Public:完全存取.

　　

  1. C# 方法默认访问级别 : private
  2. C# 类默认访问级别 : internal
  3. 接口成员访问修饰符默认为public,且不能显示使用访问修饰符。
  4. 类(class)

    构造函数默认为public访问修饰符。

    析构函数不能显示使用访问修饰符且默认为private访问修饰符。 
    　　析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

  5. 类的成员默认访问修饰符为private;
  6. 枚举(enum)

    枚举类型成员默认为public访问修饰符，且不能显示使用修饰符。

  7. 结构(struct)

    结构成员默认为private修饰符。

    结构成员无法声明为protected成员，因为结构不支持继承。

  8. 嵌套类型

    嵌套类型的默认访问修饰符为private。 和类，结构的成员默认访问类型一致。

字段和属性及索引器

1、属性
　　所谓属性其实就是特殊的类成员，它实现了对私有类域的受控访问。在C#语言中有两种属性方法，其一是get，通过它可以返回私有域的值，其二是set，通过它就可以设置私有域的值。比如说，以下面的代码为例，创建学生姓名属性，控制对name字段的受控访问：

 1 using System;
 2
 3 public class Student
 4 {
 5     private string name;
 6     /// <summary>
 7     /// 定义学生的姓名属性
 8     /// </summary>
 9     public string Name
10     {
11         get { return name; }
12         set { name = value; }
13     }
14 }
15
16
17 class Program
18 {
19     static void Main(string[] args)
20     {
21         Student student = new Student();
22         student.Name = "Jeff Wong";
23         Console.WriteLine(student.Name);
24         Console.Read();
25     }
26 }

2、索引器
简单说来，所谓索引器就是一类特殊的属性，通过它们你就可以像引用数组一样引用自己的类。显然，这一功能在创建集合类的场合特别有用，而在其他某些情况下，比如处理大型文件或者抽象某些有限资源等，能让类具有类似数组的行为当然也是非常有用的。比如，上例中，我们假设一个班级有若干个学生，构建索引器就可以很方便地调用：

 1 using System.Collections.Generic;
 2
 3 public class Student
 4 {
 5     public List<Student> listStudents = new List<Student>();
 6
 7     /// <summary>
 8     /// 构建索引器
 9     /// </summary>
10     /// <param name="i"></param>
11     /// <returns></returns>
12     public Student this[int i]
13     {
14         get { return listStudents[i]; }
15         set { listStudents[i] = value; }
16     }
17
18     private string name;
19     /// <summary>
20     /// 属性
21     /// </summary>
22     public string Name
23     {
24         get { return name; }
25         set { name = value; }
26     }
27     public Student(string name)
28     {
29         this.name = name;
30     }
31     public Student()
32     {
33         this.listStudents.Add(new Student("jeff wong"));
34         this.listStudents.Add(new Student("jeffery zhao"));
35         this.listStudents.Add(new Student("terry lee"));
36         this.listStudents.Add(new Student("dudu"));
37     }
38 }
39
40
41 class Program
42 {
43     static void Main(string[] args)
44     {
45         Student student = new Student();
46         int num = student.listStudents.Count;
47         Console.WriteLine("All the students:");
48         for (int i = 0; i < num; i++)
49         {
50             Console.WriteLine(student[i].Name); //通过索引器，取所有学生名
51         }
52
53         //设置索引器的值
54         student[0].Name = "jeff";
55         Console.WriteLine("After modified,all the students:");
56         for (int i = 0; i < num; i++)
57         {
58             Console.WriteLine(student[i].Name);
59         }
60
61         Console.Read();
62     }
63 }

上面代码中，我们看到索引器的访问器带一个参数（参数为整数），其实可以构建多个参数的索引器。还以上述代码为例，我们要根据学生学号和姓名得到学生的考试总分，修改后代码如下：

 1 using System;
 2 using System.Collections.Generic;
 3
 4 public class Student
 5 {
 6     public List<Student> listStudents = new List<Student>();
 7
 8     public Student this[int i,string name]
 9     {
10         get
11         {
12             foreach (Student stu in listStudents.ToArray())
13             {
14                 if (stu.sid == i && stu.name == name) //按照学号和姓名取出学生
15                 {
16                     return stu;
17                 }
18             }
19             return null;
20         }
21         set { listStudents[i] = value; }
22     }
23
24     private int sid; //学号
25     public int Sid
26     {
27         get { return sid; }
28         set { sid = value; }
29     }
30     private string name;//姓名
31     public string Name
32     {
33         get { return name; }
34         set { name = value; }
35     }
36     private int score; //总分
37     public int Score
38     {
39         get { return score; }
40         set { score = value; }
41     }
42     public Student(int sid, string name, int score)
43     {
44         this.sid = sid;
45         this.name = name;
46         this.score = score;
47     }
48     public Student()
49     {
50         this.listStudents.Add(new Student(1, "jeff wong", 375));
51         this.listStudents.Add(new Student(2,"jeffery zhao",450));
52         this.listStudents.Add(new Student(3,"terry lee",400));
53         this.listStudents.Add(new Student(4,"dudu",500));
54     }
55 }
56
57
58 class Program
59 {
60     static void Main(string[] args)
61     {
62         Student student = new Student();
63         Student stu = student[1, "jeff wong"];
64         Console.WriteLine("student number:" + stu.Sid + ",name:" + stu.Name + ",score:" + stu.Score);
65
66         Console.Read();
67     }
68 }

3、总结：
<1>、

属性的定义：
访问修饰符 返回类型 属性名

｛
      get｛语句集合｝
      set｛语句集合｝
｝

索引器的定义：

访问修饰符 返回类型 this[参数类型 参数...]
｛
       get｛语句集合｝
       set｛语句集合｝
｝

<2>、

索引器使得对象可按照与数组相似的方法进行索引。
this 关键字用于定义索引器。
get 访问器返回值。set 访问器分配值。
value 关键字用于定义由 set 索引器分配的值。
索引器不必根据整数值进行索引，由你决定如何定义特定的查找机制。
索引器可被重载。
<3>、属性和索引器的主要区别： 
a、类的每一个属性都必须拥有唯一的名称，而类里定义的每一个索引器都必须拥有唯一的签名（signature）或者参数列表（这样就可以实现索引器重载）。 
b、属性可以是static（静态的）而索引器则必须是实例成员。
<4>、索引器重载实例：

 1 using System.Collections.Generic;
 2
 3 public class Student
 4 {
 5     public List<Student> listStudents = new List<Student>();
 6
 7     public Student this[int i,string name]
 8     {
 9         get
10         {
11             foreach (Student stu in listStudents.ToArray())
12             {
13                 if (stu.sid == i && stu.name == name) //按照学号和姓名取出学生
14                 {
15                     return stu;
16                 }
17             }
18             return null;
19         }
20         set { listStudents[i] = value; }
21     }
22
23     /// <summary>
24     /// 索引器重载
25     /// </summary>
26     /// <param name="i"></param>
27     /// <returns></returns>
28     public Student this[int i] //i从0开始
29     {
30         get { return listStudents[i]; }
31         set { listStudents[i] = value; }
32     }
33
34     private int sid; //学号
35     public int Sid
36     {
37         get { return sid; }
38         set { sid = value; }
39     }
40     private string name;//姓名
41     public string Name
42     {
43         get { return name; }
44         set { name = value; }
45     }
46     private int score; //总分
47     public int Score
48     {
49         get { return score; }
50         set { score = value; }
51     }
52     public Student(int sid, string name, int score)
53     {
54         this.sid = sid;
55         this.name = name;
56         this.score = score;
57     }
58     public Student()
59     {
60         this.listStudents.Add(new Student(1, "jeff wong", 375));
61         this.listStudents.Add(new Student(2,"jeffery zhao",450));
62         this.listStudents.Add(new Student(3,"terry lee",400));
63         this.listStudents.Add(new Student(4,"dudu",500));
64     }
65 }
66
67
68 class Program
69 {
70     static void Main(string[] args)
71     {
72         Student student = new Student();
73         Student stu = student[1, "jeff wong"];
74         Console.WriteLine("student number:" + stu.Sid + ",name:" + stu.Name + ",score:" + stu.Score);
75
76         Console.WriteLine("all the students:");
77
78         for (int i = 0; i < student.listStudents.Count; i++)
79         {
80             Console.WriteLine("student number:" + student[i].Sid + ",name:" + student[i].Name + ",score:" + student[i].Score);
81         }
82
83         Console.Read();
84     }
85 }

里氏替换 一句话总结: 子类可以替换父类的位置，而程序的功能不受影响

更多链接: http://blog.csdn.net/yisuowushinian/article/details/18976629

时间： 2024-10-14 02:52:04

基础知识一: 面向对象的基本知识的相关文章

Java基础知识：面向对象&类图

类(Class)封装了数据和行为,是面向对象的重要组成部分,它是具有相同属性.操作.关系的对象集合的总称.在系统中,每个类都具有一定的职责,职责指的是类要完成什么样的功能,要承担什么样的义务.一个类可以有多种职责,设计得好的类一般只有一种职责.在定义类的时候,将类的职责分解成为类的属性和操作(即方法).类的属性即类的数据职责,类的操作即类的行为职责.设计类是面向对象设计中最重要的组成部分,也是最复杂和最耗时的部分. 1.面向对象特性 1)抽象 2)继承 3)封装 4)多态 2.类图: 在软件系统

零基础学习嵌入式需要注意哪些知识

一直以来对于零基础学习嵌入式的同学都非常的敬佩,毕竟这需要付出比别人更多的努力,才能追平那些本专业有编程基础的同学.从我本人而言,见过零基础学习嵌入式的同学并不在少数.今天主要谈谈零基础学习嵌入式需要注意哪些知识. 首先一定远离负能量的人,我曾记得有这样的一句话"近墨者黑 近朱者赤".这些影响还是很大的.如果一个人整天在你耳边说学这没用.学那没用.立马让滚蛋.我相信这都是坑友的,当然让你别吃喝嫖赌抽这些才是好人! 那么零基础学习嵌入式需要注意哪些知识? 零基础学习嵌入式会涉及到编程,编

12-Python基础之类与面向对象

Python基础之类与面向对象 类的初始化: class Defun(object): #(object)可加可不加,不加默认继承(object) def __init__(self,*args): self.name = args[0] #args的第一个元素 ''' ''' self.N_numbers = args[-1] #args的最后一个元素 类的属性引用与实例化 #定义一个学生类 class Student:#定义一个学生类, def __init__(self,name,sex,

如何将别人的知识转化成自己的知识？

不传授具体的知识,只告诉你获得知识的方法.将别人的知识转化成自己的知识,成就你的丰盈人生! 由知识管理中心(Knowledge Management Center)基于最新知识管理理论和实践.认知与学习理论,结合互联网对于信息和知识整合.传播.创造的影响所开发的"KMC高效学习方法网络课程"已经在众多同学学习的基础上.结合多位专家的建议进行了重大升级. [课程名称]KMC 高效学习方法网络课程–互联网思维下的高效学习方法 [课程导师]田志刚 知名知识管理专家.个人知识管理畅销书<

[.net 面向对象编程基础] (2) 关于面向对象编程

[.net 面向对象编程基础]  (2)  关于面向对象编程 首先是,面向对象编程英文 Object-Oriented Programming 简称 OOP 通俗来说,就是 针对对象编程的意思 那么问题来了什么是对象,不是“女盆友”“找对象”的这个对象.当然也可以理解“女盆友”也是“对象”的一种. 面向对象中的对象,指一切皆是对象 专业述语解释我们无视就好 只所有面向对象编程,是因为之前有一个面向过程编程 面向过程——是指把问题分解成步骤,一步一步实现 面向对象——是把构成问题的事务分成各个对象

Java基础教程：面向对象编程

Java基础教程:面向对象编程 Java语言概述 Java语言特点 1.Java为纯面向对象的语言,它能够直接反映现实生活中的对象.总之,Everything is object! 2.平台无关性.Java为解释型语言,编译器会把Java代码变成"""中间代码",然后在JVM上解释执行. 3.Java提供了很多内置的类库,这些类库简化了开发人员的程序设计工作,同时缩短了项目开发时间. 4.Java语言提供了对Web应用的支持. 5.Java语言提供了较好的安全性和健

Java基础教程：面向对象编程[2]

Java基础教程:面向对象编程[2] 三大特性 封装 封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部份包装.隐藏起来的方法.封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问. 使用封装我们可以对成员变量进行更精确的控制,同时隐藏信息,实现细节等. 方法: public class Person{ private String name; private int age; ? public int getAge(){ return age;

javascript的基础知识及面向对象和原型属性

自己总结一下javascript的基础知识,希望对大家有用,也希望大家来拍砖,毕竟是个人的理解啊 1.1 类型检查:typeof(验证数据类型是:string) var num = 123; console.log(typeof num); // 1.2 in 运算符 作用:判断指定属性是否存在于指定的对象中. 如果指定的属性存在于指定的对象中,则 in 运算符会返回 true. 语法: 属性 in 对象 返回值:true 或者 false 示例: var obj = { age: 18 };

Java基础知识之面向对象（1）

什么是面向对象: 比如我们想做一个盒子,先想一下盒子的样子,然后找具体的工具来做出我们想要的盒子,这个过程就是面向对象. 面向对象的特征 封装.继承.多态 封装:内部资源对外部不可见 继承:扩展现有类的功能 多态:方法可以重载,对象可以有多个形态 类与对象的理解 类:具有相同特征的一类事物(如:两个眼睛,一个鼻子,一个嘴的人,人就是一个类), Java中定义类的具体方法: class 类名称{ 成员变量: .... 成员方法: } 对象:一个类的具体体现,对于上面说的人,任何一个个体都是一个对象