初识opp思想和类的特性

第一章：深入.NET框架

一：.NET的功能

1.它提供了一个面向对象的编程环境，完全支持面向对象编程

2.对Web应用，Web服务的强大支持

3.实现SOA，支持云计算

4.支持构建.NET程序的炫彩外衣

二：.NET框架的组成

1. CLR（公共语言运行时）

作用：所有.NET应用程序运行时的环境

组成：CLS（公共语言规范）和CTS（通用类型系统）

CLS和CTS之间的作用

CLS	CTS
一种最低语言标准	解决不同语言数据类型不同问题

2. FCL（框架类库）

   作用：提供了对于系统功能的调用，是建立.NET应用程序，组件和控件的基础

   核心框架及功能：

   核心框架	功能
   system	包含所有其他的命名空间
   system.Net	支持对网络协议的编程
   system.Data	提供了表示ADO.NET结构的类的访问
   system.Collections.Generic	支持泛型操作
   system.Windows.,Forms	可以用于Windows应用程序
   system.Drawing	支持GDI+基本图形操作，如：验证码

   三：类图

作用：能够便于明白类的功能及类之间的关系

【注意】：在VS的通用类图中，字段属性放在方法的前面，变量类型和返回值放在冒号的后面，而私有成员前加一个“-”，共有成员前面加一个“+”。

第二章：C#D的数据类型

1. 值传递

   命名空间：System.ValueType

   内存区域：栈

   包括类型：基本数据类型（如：int,float），枚举，结构类型等

   【注意】

   结构类型的语法：

   访问修饰符 Struct  结构名
   {
   //结构体
   }
   

   特点：

   结构中可以有字段，也可以有方法。定义时，结构中的字段不能被赋值

   使用的注意方面：

   1.可以不用new，直接定义结构的对象即可

   2.声明结构的对象后，必须给结构中的所有成员赋值

   3.不能手写结构函数，结构里面有多少字段，定义的构造函数里面就有多少参数

2. 引用传递

   命名空间：System.Object

   内存区域：堆

   包括类型：数组，类，接口等

3.参数传递

1. 当不用ref修饰传递值类型参数时，参数在方法中的修改不会保留
2. 当不用ref修饰，传递引用类型参数时，参数在方法中的修改会保留
3. 当用ref修饰，传递值类型或引用类型参数时，参数在方法中的修改会保留

4.装箱与拆箱

装箱：把值类型转换为引用类型的过程

拆箱：把引用类型转换为值类型的过程

如：

int i=123;
object o=i;//装箱
int j=(int)o;//拆箱

三：集合（一组大小不固定的值）

1.非泛型集合（不限制数据类型，需要进行数据的转换）

A: Arraylist(类似于数组)：

命名空间：System.Collections

属性：Count，主要是获取Arraylist中包含的元素数

方法：

方法	作用
Add(object value)	将对象添加到Arraylist的结尾处
RemoveAt(int index)	删除Arraylist指定的索引处的元素
Remove(object value)	时时彩Arraylist特定的对象
Clear()	删除Arraylist中的所有元素

例式：

using System.Collections;
Arraylist arraylist=new Arraylist();//可以设置容量为0的Arraylist对象
Arraylist arraylist2=new Arraylist(5);//也可以设置容量为5的Arraylist对象
arraylist.Add("张三");//添加一个对象
SE se=new SE();//new一个SE的对象
se.name="李四";
arraylist.Add(se);//添加一个se对象
//for遍历
for(int i=0;i< arraylist.count;i++)
{
    SE eng=(SE) arraylist[i];//进行类型转换
    CW(eng.name);
}
//foreach遍历
foreach(object obj in arraylist)
{
    SE eng=(SE)obj;
    CW(eng.name);
}
 arraylist.Remove(se);//删除对象名为se的元素
arraylist.RemoveAt(0);//删除索引为0的元素

B:Hashtable（哈希表）：

命名空间：System.Collections

属性：

属性	作用
count	获取在Hashtable中的元素个数
Keys	获取在Hashtable中的键的集合
Values	获取在Hashtable中的值的集合

方法：

方法	作用
Add(object key,object value)	将带有键和值的元素添加在Hashtable中
Remove(object key)	从Hashtable中删除指定键的元素
Clear()	从Hashtable中删除所有元素

例式：

using System.Collections;
Hashtable ht=new Hashtable();
SE se=new SE();//new一个SE的对象
se.name="李四";
ht.Add(se.name,se);//添加一个se对象,将姓名当作键
ht.Remove("李四");//按照键删除
//遍历Keys
foreach(object obj in ht.Keys)
{
    CW((string)obj);
}
//遍历Values
foreach(object obj in ht.Values)
{
    SE se =(SE)obj;
    CW(se.name);
}
//结构DictionaryEntry遍历
foreach(DictionaryEntry en in ht)
{
    CW(en.Key);
    CW(((SE)en.Value).name);
}

2.泛型集合（限制数据类型，不需要进行数据的转换）

A:List：【它的属性与方法都跟Arraylisty一样，但是List比起Arraylisty更保证了类型的安全性】

命名空间：System.Collections.Generic

语法：

List<T> list=new List<T>;//【T是指数据类型】

B:Dictionary：【它的属性与方法都跟Hashtable一样，但是Dictionary比起Hashtable更保证了类型的安全性】

命名空间：System.Collections.Generic

语法

Dictionary<K，V> 对象名=new Dictionary<K,V>();//K是键的数据类型,V是值的数据类型

3.泛型类

语法：

public class 类名<T> //T是类性参数，可以是类类型，也可以是基本类型
{
}

特点：

1. 性能高

2.类型安全

3.实现代码的重用

第四章：深入类的方法

1.构造函数

作用：new对象的

特点：

1.方法名与类名一样

2.没有返回值

3.主要完成对象的参数化工作

分类：

A：无参构造函数

语法：

访问修饰符  类名()
{
//方法体    
}

【注意】在一个类中，如果你没有手写构造函数，那么这个类中会有一个默认的隐式无参构造函数，但是如果你手写了构造函数，那么就不会有默认的构造函数。

B：有参构造函数

语法：

访问修饰符  类名(参数列表)
{
//方法体    
}

2. 方法重载

作用：利于不通英语的弊端

特点：

1.方法名相同

2.同一个类中

3.方法参数类信息不同或参数个数不同

【注意】不能以返回值类型，修饰符决定是否是重载。

3.例式

class SE
{
    public SE()//手写了构造函数
    {
        CW("hello");
    }
    
     public SE(string name)//重载
    {
        CW("hello，我是{0}"，name);
    }
}

//在main方法中
SE se=new SE();//它会输出hello，调用了无参构造函数
SE se=new SE("张三");//它会输出hello,张三，调用了有参构造函数

第五章：初识继承和多态

1.什么是继承：子承类

2.继承说明了什么：两个类之间的关系

3.特性：

	单根性	传递性
作用：	如：class A:B;class B:C----》A可以访问C中的非私有成员	一个子类不能同时继承多个多个父类

4.语法

class 子类：父类{}	 	   //Java

class 子类 extends 父类{}	//C#

5.用法

在产生继承关系后，在其他类new子类对象时，只能调用父类中public的成员，而在子类中可以调用protended和public成员。【除了被sealed修饰的类】

6. 调用构造函数

A. 隐式：在new一个子类对象时，会默认的先调用父类的无参构造函数，再调用子类的无参构造函数

B. 显式：再子类中的方法括号外用base：()，可以调用父类无参的方法，而base：(值)，可以调用父类有参的方法。【那个值是实参，能用变量名，也可以直接赋值】

7.关键字

base：调用父类成员，this：调用子类成员 ，但是this也可以调用父类的非私有成员。
【注意：如果子类和父类中都有同一变量，就只能用base调用父类的变量，this调用子类的变量】

8. 数据类型

	as a	is a
语法	对象名 as 数据类型	对象名 is 数据类型
作用	强转，等价于：(数据类型) 对象名	判断数据类型

第六章：深入多态

1.什么是多态：一种事物有多种形态

2.多态的实现方式：重载，重写（虚方法，抽象方法）

A：虚方法

1.语法

访问修饰符 virtual 返回值 方法名(){} //父类的语法

访问修饰符 override 返回值 方法名(){} //子类的语法

2.特点

1.不在同一类
2.重写的方法在父类中要已经存在，且子类方法中的参数也要相同
3.子类不一定要重写方法
4.父类用virtual修饰，子类用override修饰

3.里氏替换原则（LSP）：父类引用指向子类，只能访问父类中声明的方法，不能访问子类中定义的方法

B：抽象方法和抽象类

1.语法

访问修饰符 abstract class 类名
{
    访问修饰符 abstract 返回值 方法名(); //父类，含有抽象方法的一定是抽象类
}

访问修饰符  override 返回值 方法名(){} //子类的语法

2.意义：规定子类必须重写方法

3.抽象方法的特点

1.不同类，相同方法，参数
2.没有方法体，只能位于抽象类【除非子类也是抽象类】
3.父类里面的抽象方法，子类必须实现

4.抽象类的特点

1.不能new对象
2.不能被sealed和static修饰
3.抽象类中有抽象方法，也可以有普通方法

5.应用

//抽象父类
public abstract class A
{
    public abstract void Sayhi();
}
//普通父类
public class C
{
    public string name；
    public C()
    {
        CW("这是C类的无参方法");
    }
    public virtual void Say(string name)
    {
        CW("C类的有参方法");
    }
}
//子类
public class B：A
{
    public override void Sayhi()
    {
        CW("hello");
    }
}
public class D:C
{
	public string name;
    public D()
    {
    CW("这是D类的无参方法");
    }
    public override void Say(string name)	//显式调用父类的有参方法
    {
    CW("我是C类的"+base.name+"我是D类的"+this.name);
    }
}
//测试
Static void Main(String[] args)
{
    A a=new A();
    a.Sayhi();//————输出hello
    D d=new D();//会先输出C类的无参方法,再输出D类的无参方法
    d.Say("小小");
    console.Read();
}