1.访问修饰符
字段、方法、属性都可以叫做类的成员，它们都需要定义访问级别。访问级别的用处在于控制成员在哪些地方可以被访问。
这样达到面向对象中"封装"的目的。
public：无访问级别，在哪都能访问。
private：私有成员，只能在当前类里面访问。
internal:在当前程序集中访问。
protected：受保护的成员，只能再当前类和继承它的子类中访问。不允许其它非子类访问。


2.构造方法
(1)构造方法用来创建对象，并且可以在构造函数中对对象进行初始化。
(2)构造函数是用来创建对象的特殊方法，方法名和类名一样，没有返回值，连void都不要。
(3)构造函数可以有参数，new对象的时候传递函数参数即可。
(4)如果不制定构造函数，则类有一个默认的无参数构造函数。如果指定了构造函数，则不再有默认的的无参构造函数，如果需要无参构造函数，
需要自己来写。
(5)构造函数可以重载，也就是可以有多个参数不同的构造函数。
(6)构造函数在被该类new的时候调用

3.值类型变量在内存中的分配
3.1当变量是一个类的成员变量的时候，那么该变量是跟随类的对象存在于堆内存，当对象引用断开时，等垃圾回收器进行清理时被销毁。
3.2当变量是一个方法的局部变量时，那么该变量是在方法调用时，存在于栈内存，方法执行完毕后就立即销毁。


4.里氏替换原则、多态(程序的可扩展性、灵活性)
子类继承父类的属性和方法，使创建子类变得很简单，实现了代码重用、以及多态。
类的单根继承性、传递性、继承时构造函数
所有的类都直接或简介的继承自object。查看IL代码。
代码：
Person p=new Teacher();
//子类可以隐士的转换成父类
Teacher t=(Teacher)p;
5.is和as
typeA is typeB;//仅判断
typeA as typeB;//先判断，再转换

6.多态就是对象可以表现多个类型的能力。

7.虚方法和重写
7.1方法不能用static修饰
7.2方法重写与基类的签名必须一致
7.3virtual不能与private一起使用
常见虚方法：
Equal();
ToString();

8.抽象方法与抽象类
抽象类与抽象方法由abstract修饰。
abstract使用注意：
抽象方法中没有方法体。
抽象成员只能存在于抽象类中。
抽象类中可以有非抽象成员。
抽象类的派生拍类必须实现抽象方法体。
抽象类只能用作基类，无法实例化。

9.接口
(1)接口是完全抽象的一种约定。
(2)接口就是用来实现的。
(3)语法：
[访问修饰符] interface 接口名
{
//接口成员定义  
}
(4)接口只有方法、属性、索引和事件的声明
(5)接口是用来实现的，所有成员默认为public

10.静态方法和实例方法
静态 实例(非静态)
static关键字  不需要static关键字
使用类名调用  使用实例对象调用
在静态方法中，可以访问静态成员。在实例方法中，可以直接访问静态成员。

在静态方法中，不可以直接访问实例成员。在实例方法中，可以直接访问实例方法。
调用前需要初始化  实例化对象时初始化。



11.小结
Person p=new Student();
new 子类时，先创建子类对象调用子类的构造函数时创建父类对象，调用父类构造函数。
子类默认调用父类的无参数构造函数
类的访问修饰符默认就是internal(程序集内共享--也就是项目内部共享，只能在项目内部访问)
类的成员变量的访问修饰符默认是private


(*)代码实现：
<------------------------------------Person---------------------------------------------->
public class Person
{
#region成员变量和属性
string _name;
public string Name
{
get{return _name;}
set{_name=value;}
}
string _hobby;
public string Hobby
{
get{return _hobby;}
set{_hobby=value;}
}
int _age;
public int Age
{
get{return _age;}
set{_age=value;}
}
bool _gender;
public bool Gender
{
get{return _gender;}
set{_gender=value;}
}
double _salary;
public double Salary
{
get{return _salary;}
set{_salary=value;}
}
#endregion
public Person()
{
Console.WriteLine("Person构造函数");
}
public void SayHello()
{
Console.WriteLine("Hello World");
}
//带参数的构造函数
public Person(string name)
{
this._name=name;
}
private string s="Person 的私有成员";
public void SayHelloFromFather()
{
Console.WriteLine("这是来自父类的问候");
}
//虚方法，可以被子类重写。
//当类存在继承关系的时候，类里的this，既能够指向子类对象的成员，也能够同时通过base指向父类的成员。
public virtual void SayHi()
{
Console.WriteLine("大家好~父类的SayHi()");
}

}
<--------------------------------Student------------------------------------------------>
internal class Student:Person
{
public Student():base("")
{
//子类中可以访问到父类中受保护的成员
base.s="私有的";
Console.WriteLine("继承父类无参数的构造函数");
}
public Student(string s):base(s)
{
Console.WriteLine("Student的构造函数");
}
public override void SayHi()
{
base.SayHi();
//当类存在继承关系的时候，类里的this，既能够指向子类对象的成员，也能够同时通过base指向父类的成员
Console.WriteLine("大家好，我叫{0},{1}岁了，性别{2},爱好{3}",base.Name,base.Age,base.Gender,base.Hobby);
}
}

好好学些，天天向上。。。

值得学习ing!