第 1 节面向对象基本概念
面向对象编程（OOP）
面向对象三大特征：封装、继承、多态。
第 2 节定义类字段方法及实例化类
1、最简单的类：class Person{}
2、增加类变量（字段/成员变量）和方法：
//字段用来描述类内部的信息
//方法是类的“行为”
3、类的实例化：
//创建Person类的对象/实例，然后把Person类型变量yzk 指向这个对象
Person yzk = new Person();
yzk.setName("杨中科"); //调用yzk变量当前所指向的对象的setName方法
//每new一次就创建类的一个“实例”/ “对象”
//两个对象之间的内存是独立的，每人一块，互不影响
new出的每个对象都是一个单独的实例，两个对象之间的成员变量是独立的两份。
new出来的叫类对象或者实例(Instance)。
第 3 节对象的引用传递
Person weiren = yzk; //weiren指向yzk当前所指向的对象。
Weiren.setAge(30); //调用weiren指向的对象的setAge
只有new才会创建新的对象，有多少new就有多少对象
//把一个对象传递进方法中，传递的也是同一份引用
static void Test(Person p)
{
}
第 4 节null和成员变量、局部变量的不同初始化
1、null表示变量没有指向任何对象
2、对于一个为null的变量调用成员方法都会报异常NullReferenceException。
3、值类型(ValueType)：数值类型(int、long、double等）、boolean等基本类型，枚举、结构体,复制传递，不能为null。String不是值类型。
第 5 节this解决成员变量和局部变量重名的问题
public void setAge(int age)
{
this.age = age;
}
1、局部变量必须初始化，成员变量声明时默认初始化。基本数值类型默认初始值为0，String等非基本类型初始化为null。
2、当成员变量和局部变量（函数参数也可以看做局部变量）重名的时候，被看做局部变量，因此为了避免混乱，建议访问成员变量的时候加上“this.”，this代表当前对象。
public void sayHello()
{
Console.WriteLine("大家好，我是"+name+"，我今年"+age+"岁了");
}
new Person().sayHello(); //创建一个匿名对象，然后调用。输出结果是？
大家好，我是，我今年0岁了
第 6 节public和private
public成员可以被类内部或者外部访问，private成员只能被类内部访问。这样可以保护不希望外接调用的内部成员(Member，包含字段Field/变量、方法)不被外界访问。
字段(Field)/成员变量(Member Variable)一般声明为private。通过get/set方法来进行取值/赋值（好处：可以控制参数的合法值），可实现只读或只写
第 7 节属性入门
为了避免外界给成员变量随便赋值，必须把成员变量声明为private，然后提供get/set方法，写起来、调用起来都麻烦，C#提供了“属性”这样一个语法：
private int height;
public int Height
{
get
{
return this.height;
}
set
{
this.height = value;
}
}
p.Height=50;int a = p.Height;
通过Reflector看属性本质上是什么？（ ILSpy的C#看的优化后的代码，IL看的是IL代码，看不懂 ）
public void set_Height(int value)
{
this.height = value;
}
public int get_Height()
{
return this.height;
}
第 8 节属性的简化写法
1、 如果是简单set/get逻辑，可以使用更简写的语法： public int Weight { get; set; } 通过Reflector看本质是什么
编译器生成一个私有变量： private int <Name>k__BackingField;
public void set_Name(int value)
{
this.<Name>k__BackingField = value;
}
{
return this.<Name>k__BackingField;
}
2、get、set可以有一个声明为private、protected，这样就可以设置不同的访问级别。
3、如果只有get或者set就是只读或只写属性（必须有方法体）。只读只写不能简化写。
第 9 节构造函数入门和属性赋值的简化写法
1、构造函数是创建类对象，并且在创建完成前对类进行初始化的特殊函数。如果定义类时没有声明构造函数，默认会给出一个无参构造函数，如果定义了任意一个构造函数，将不会提供默认的无参构造函数。
2、构造方法格式及特点：
方法名必须和类名一致
没有返回值类型
构造函数可以重载，Person(String name,int age)
2、 属性赋值简化
Person p = new Person() { Id=5,Name="abc"};
/*
class Person
{
public int Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
public Person()
{
}
public Person(int id)
{
this.Id = id;
}
}
Person p = new Person() { Id=5,Name="abc"};
Person p1 = new Person(5) { Name = "aaa", Age = 6 };
// Person p1 = new Person(5); p1. Name = "aaa"; p1.Age = 6
Person p2 = new Person { Id=5,Name="a"};
*/
赋值是在对象构造之后
如果后面有{}的话，如果调用无参构造函数，则可以不写()
Person p = new Person() { Id=5,Name="abc"}; //属性初始化，简化属性赋值
第 10 节static介绍
1、一些场景下会要求一个类的多个实例共享一个成员变量；有时候想定义一些不和具体对象关联、不需要new就调用的方法
举例：Console类的WriteLine，MessageBox的Show
2、static方法不需要new就可以直接通过类名调用。
3、static变量不需要new就可以直接通过类名调用。static变量是共享的内存空间，非static变量则是对象隔离的。
4、static 方法中无法使用this关键字，因为static独立于对象存在，不是任何人的唯一。
5、static成员中只能访问static成员，不能直接访问非static成员。非static成员可以访问static成员。
第 11 节单例模式
1、有的类在系统中只能有一个对象（*，资源管理器、缓存管理器等），这时就要使用“单例模式”（singleton）。
2、单例模式（“饿汉式”）的实现步骤：
1）构造函数声明为private，这样避免外界访问
2）定义一个private readonly static的对象实例，static成员的初始化只在类第一次使用的时候执行一次。readonly修饰变量只能在构造函数或者初始化的时候赋值。
3）定义一个public static的getInstance方法，返回唯一实例。
第 12 节静态代码块以及面试题
class MyTest
{
static MyTest() //静态代码块（静态构造函数）
{
Console.WriteLine("zi 静态代码块");
}
public MyTest()
{
Console.WriteLine("zi 构造方法");
}
}
MyTest t1 = new MyTest();
MyTest t2 = new MyTest();
public class MyJingTaiDaimaKuai
{
public static int i = test1();//最开始执行
public int age = test2();//new的时候先执行成员变量的初始化，再执行构造函数
static MyJingTaiDaimaKuai()
{
Console.WriteLine("静态代码块");//再执行
}
public MyJingTaiDaimaKuai()
{
Console.WriteLine("构造函数");
}
public static int test1()
{
Console.WriteLine("test1");
return 3;
}
public static int test2()
{
Console.WriteLine("test2");
return 333;
}
}
MyJingTaiDaimaKuai a1 = new MyJingTaiDaimaKuai();
Console.WriteLine(a1.age);
MyJingTaiDaimaKuai a2 = new MyJingTaiDaimaKuai();
Console.WriteLine(a2.age);
只要一旦开始“接触一个类”，静态成员、static代码块就会被执行
静态代码块（静态构造函数）在类第一次被使用的时候执行一次，在构造函数执行之前执行。只要用到类，哪怕没new对象（比如只是声明变量）也会被执行，且只执行一次。
执行顺序：静态成员(只执行一次) > static代码块就会被执行(只执行一次) > 成员变量的初始化 > 构造函数
第 13 节命名空间namespace
命名空间语法：
namespace ConsoleApplication1包住类；
命名空间的使用：
1.当前命名空间中的类无需引用；使用using引用其他包中的类：
2.还可以直接通过“命名空间+类名”的方式使用“System.Data.SqlClient.SqlConnection”（适用于同时使用多个重名的类）；
第 14 节继承基本语法
C#中一个类可以“继承”自其他类，如果A继承自B，则A叫做B的子类，B叫做A的父类(基类)。子类会从父类继承所有非private成员。子类还可以有子类。
C#中一个类只能有一个父类，如果没指定父类，则System.Object为父类。
第 15 节继承中的构造函数
子类的构造方法默认都去访问了父类的无参构造方法：在子类中的构造方法后都有一行默认语句 base()
class Zi : Fu
{
public Zi(): base()//不管是否显式调用，控制台都会输出fu
{
Console.WriteLine("zi");
}
}
先执行父类的构造函数把父类初始化完成，再初始化子类的。（先调用父类的构造函数，再调子类的构造函数）
可以通过super(参数)去访问父类中的有参构造函数。可以通过this(参数...)去访问本类中的其他构造函数。
class Fu
{
public Fu(int a)
{
Console.WriteLine("fu"+a);
}
}
class Zi : Fu
{
public Zi():base(0)
{
Console.WriteLine("zi");
}
public Zi(int a):base(a)
{
Console.WriteLine("zi"+a);
}
}
如果定义了构造函数，则类就不会有默认的无参构造函数；如果父类中没有默认的，则子类构造函数必须显示调用父类的构造函数
第 16 节private、public和protected的区别
private成员无法被子类访问，子类只能通过父类的非private方法“间接”访问父类的private成员。这样保证了父类private成员的安全性。
procected成员只能被自己以及子类（直接或者间接）访问，无法被“外姓人”访问。
第 17 节Override
面向对象三大特征：封装、继承、多态。
子类中定义和父类中一样的方法就叫“重写(Override)或覆盖”，父类中可以被override方法要声明为virtual 。
new关键字可以在派生类中隐藏基类的方法，也就说在使用派生类的方法是调用的方法是New关键字新定义出来的方法，而不是基类的方法。
Override和OverLoad区别：
Override 重写：子类有和父类一样（名字、参数个数、类型、返回值）的方法
OverLoad 重载：方法的名字一样，参数的个数或类型不一样
第 18 节多态的精髓
不能用子类的变量指向父类的对象
可以用父类的变量指向子类的对象，调用方法的实现还是对象的实现
不管实际指向的是什么类型的兑现，能够调用什么方法取决于变量的类型
父类变量可以指向子类的对象，内存中也还是子类的对象，有且只有这一个对象。变量是什么类型没有关系，到底执行谁的方法主要取决于内存中的对象是什么类型
能够调用什么方法由变量类型决定，执行谁的方法由实际指向的对象决定
第 19 节多态与类型转换
1. ()类型转换可以把“被看做父类对象的实例”重新看成“子类”。(显式类型转换/强制类型转换)
2.如果对象就是父类对象，当被看成子类对象的时候会失败，抛出运行期异常，编译器无法发现这个错误。
3.类型转换只能在有父子关系的类中进行
思考：
1、定义一个方法 void test1(DiQiuRen dqr){dqr.sayHello();}
如下调用test1(new Chinese());可以吗？运行结果是什么？
可以，dqr指向Chinese对象，运行结果：我是中国人
2、String s = (String)zgr1;可以吗？
不可以，类型转换只能在有父子关系的类中进行
第 20 节抽象类
把类标记为abstract，这样的类无法被直接实例化（new），这就叫抽象类。
1.抽象方法没有方法体；
2.一旦类中定义了抽象方法，类必须被修饰为抽象；（抽象类中不一定要有抽象方法）
3.抽象类无法实例化(new)。
语法：
abstract class DiQiuRen
{
public abstract void speak();
}
子类必须实现抽象类方法
无法创建抽象类或接口的实例
第 21 节接口
1、接口（interface）是一种用来声明“能力”的类型，不提供具体实现
语法：
public interface ISpeakable
{
void speak();
}
2、不提供实现方法，连{}都不能有。
3、接口无法实例化，只能被类“实现”
public class TeacherCang : ISpeakable
{
}
4、既可以使用接口类型变量又可以使用类类型变量调用speak
5、接口的意义是定义“做什么”，类定义“怎么做”
6、接口中不能声明变量（字段），一个没有实现代码的接口中声明变量没意义。
7、接口中可以定义多个方法，也可以不定义任何方法(* 标识接口)。
8、接口只是“能力”不是“实现”，因此不能也必要定义构造函数。
9、类只能有一个父类，类可以实现多个接口。
单继承，多接口
接口和抽象类的区别和联系：
（1）派生类只能继承一个基类，即只能直接继承一个抽象类，但可以继承任意多个接口；
（2）抽象类中可以定义成员的实现，但接口中不可以；
（3）抽象类中可以包含字段、构造函数、析构函数、静态成员或常量等，但接口中不可以；
（4）抽象类中的成员可以是私有的（只要不是抽象类的）、受保护的、内部的或受保护的内部成员（受保护的内部成员只能在应用程序的代码或派生类中访问），但接口中的成员必须是公共的。
扫一扫
3346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
