面向对象三大特性
类的关键字 class
类里面包含
成员变量
成员属性
成员方法
面向对象三大特性：
一、封装
目的：保护类，让类更加安全
做法：让类里面的成员变量变为私有的，做相应的方法或者属性去间接的操作成员变量
1、封装成员方法来间接操作类里面的成员变量
class ren
{
private string name;
private int age;//年龄必须在18-50之间
//取age的值
public int getage()
{
return age;
}
//给age赋值，
public void setage(int a)
{
age = a;
}
//取name的值
public string GetName()
{
return name;
}
//给name赋值
public void Setname(string n)
{
name = n;
}
2、使用成员属性来间接访问里面的成员变量
class student
{
private string _Name;//命名规则
public string Name
{
get { return _Name; }
set { _Name = value; }
}
访问修饰符：
private 私有的 只能在类里访问
protected 受保护的 只能在该类和它的子类中访问
public 公有的 在任何地方都能被访问
构造函数：
public Student(string s,string n)
{
_Sex = s;
_Name = n;
}
Student s = new Student("男");
Console.WriteLine(s.Sex);
Console.ReadLine();
作用：造对象所要调用的方法，用来创建对象 ren r = new ren();
每一个类都有一个构造方法，不写也有，只不过看不到
特殊性：写法特殊 执行时间特殊（最先执行）
执行什么操作：实现什么功能：可以实现对成员的初始化
每一个类都有一个构造方法，不写也有只不过看不到而已
特殊性：写法特殊 执行时间特殊
1.使用面向对象来求两个圆之间的面积
类：class Yuan
{
private int _BanJing;
public int BanJing
{
get { return _BanJing; }
set { _BanJing = value; }
}
public double MianJi()
{
return _BanJing * _BanJing * 3.14*2;
}
public double ZhouChang()
{
return 2 * 3.14 * _BanJing;
}
static void Main(string[] args)
{
Yuan y1 = new Yuan();
y1.BanJing = 10;
Yuan y2 = new Yuan();
y2.BanJing = 5;
double zc = y1.ZhouChang() - y2.ZhouChang();
double mj = y1.MianJi()-y2.MianJi();
2.函数重载
函数重载需要的条件：函数名要相同，参数的个数或者参数的类型不同
public string Show()
{
return "没有参数";
}
public string Show(int n)
{
return "有一个整形参数";
}
public string Show(string s)
{
return "有一个字符串类型的参数";
}
Ren r = new Ren();
string s = r.ShowA("hello");
//函数的四要素：返回类型 函数名 --参数列表-- 函数体
//函数重载需要的条件：函数名要相同，参数的个数或者参数的类型不同
3.this关键字
虽然写在类里面，但不是属于类的，而是属于该对象的
一般来说在类里面 this关键字是可以省略的，但是如果有一个方法形参名字和成员名字重复，
这时候再调用该对象里面的成员的时候需要加this关键字
4. is关键字
判断变量是不是属于某个类型
if (y2 is Ren)
{
s = "是一个人";
}
else
{
s = "不是一个人";
}
5. as关键字
转换类型（只能转换兼容类型，可以将子类对象转换为父类对象）
二、继承
子类可以继承父类的一切
特点：单继承
一个子类只能有一个父类 一个父类可以有多个子类
class Ren // 父类
{
private string _Name;
public string Name
{
get { return _Name; }
set { _Name = value; }
}
private int _Age;
public int Age
{
get { return _Age; }
set { _Age = value; }
}
public string Speak()
{
return _Name+"人类正在讲话";
}
}
//子类 class China:Ren
{
public China(string m):base(m)
{
}
public string Eat()
{
//return base.Name+"用筷子吃饭";
return base.Speak();
}
}
class America : Ren 用冒号继承ren(父类)
{
public America(string m): base(m)
{
}
public string Eat()
{
return "用刀叉吃饭";
}
C#特殊点：所有类的祖先都是object
base关键字：在子类中代表父类对象，用法和this关键字相同 写在子类里
如果父类有构造方法，那么子类也要有构造方法，如果父类构造需要参数，那么子类构造也必须有相应的参数。
子类构造后面可以通过base调用父类的构造方法
public China(string m):base(m)
{
}
三、多态 有两种
1、编译多态：函数重载
2、运行多态：
当父类引用指向子类实例时，由于子类对父类的方法进行重写，在调用该方法时表现出不同就称为多态。
父类引用：ren r=new ren() 子类实例：指对象 重写： 覆盖
父类：rirtual 虚方法
子类： override 重写
class dongwu 父类
{
public virtual string eat()
{
return "a";
}
}
class dog : dongwu 子类
{
public override string eat()
{
return "b";
}
}
条件：必须要有继承 父类引用指向子例实例 子类必须对父类的方法引用重写
里氏代换原则：如果有一个地方需要使用到父类对象，那么你可以将一个子类对象给他， 子类可以替换父类给他
dongwu dw = new dog();//动物指向子类dog实例 改变dog()
Console.WriteLine(dw.eat()); //下面也会呈现不同
