面向对象
1、类：众多对象抽象出来的
2、对象：类实例化出来的
3、类的定义
关键字 class
4、类里面包含
成员属性
成员变量
成员方法
5、面向对象三大特性
（1）封装
目的：保护类，让类更加安全
做法：让类里面的成员变量变为私有的，做相应的方法或者属性去间接
操作成员变量
一、封装成员变量来间接访问类里面的成员变量
例子：
class ren
{
private string name;
//取name的值
public string getname()
{
return name;
}
//给name赋值
public void setname(string n)
{
name = n;
}
}
这样做的目的是可以在输入时规定输入的方位，例如
class ren
{
private int age;
//取name的值
public int getnage()
{
return age;
}
//给name赋值
public void setage(int a)
{
if (age >= 18 && age <= 50)
{
age = a;
}
else
{
age = 18;
}
}
}
--延伸
访问修饰符
private 私有的 --只在该类中可以访问
例：C#中
private void show()
{}
protected 受保护的 --只能在该类和它的子类中访问
public 共有的 --在任何地方都可以访问
二、使用成员属性来间接访问类里面的成员变量
要使用成员属性在命名是采用下划线开头,并且首字母大写，例：_Name
C#中独有
选中要使用属性的成员变量名所在行，右键--重构--封装字段
可以加入控制
注意：变量名和属性名不能重复，这是成员变量要使用命名规则的原因
class student
{
private string _Name;
public string Name
{
get { return _Name; }
set { _Name = value; }
}
private int _Age;
public int Age
{
get { return _Age; }
set
{
if (Age >= 18 && Age <= 50)
{
_Age = value;
}
else
{
_Age = 18;
}
}
}
}
也可直接输入代码，并且简写。但是简写方法不能对值进行控制
class student
{
private string _Name;
public string Name{get;set;}
}
属性和成员变量在使用上是一样的，可以之间点出。例
student s= new student;
s.name="张三"
构造方法（函数）：
作用：造对象所要调用的方法，用于创建对象
每一个类都有一个构造方法，不过写不写都有，不写看不到
特殊性：
（1）写法特殊
对类写构造方法，方法名必须是类名
（2）执行时间特殊
在实例化对象时执行
可以实现对成员进行初始化
student S=new student("男");
class student
{
//构造函数
public student(string s)
{
_Sex = s;
}
private string _Sex;
public string Sex
{
get { return _Sex; }
set { _Sex = value; }
}
}
（2）继承
1、使用面向对象
研究什么内容就做一个什么样的类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 面向对象2
{
class Program
{
static void Main(string[] args)
{
yuan y1 = new yuan();
y1.Banjing = 10;
yuan y2 = new yuan();
y2.Banjing = 5;
double mj = y1.mianji() - y2.mianji();
Console.WriteLine(mj.ToString());
Console.ReadLine();
}
}
class yuan
{
private int _Banjing;
public int Banjing
{
get { return _Banjing; }
set { _Banjing = value; }
}
public double mianji()
{
return _Banjing * _Banjing * 3.14;
}
public double ZhouChang()
{
return 2 * 3.14 * _Banjing;
}
}
}
2、函数重载
在一个类里面通过对函数的重载，实现多个功能
class Ren
{
public string Show()
{
return "没有参数";
}
public string Show(int a)
{
return "有个整形参数";
}
public string Show(string a)
{
return "有一个字符串类型的参数";
}
//函数四要素：返回类型，函数名，参数列表，函数体
//区分同名函数可以通过参数列表来区分
//函数重载的必要条件，函数名要相同，参数的个性或者参数
类型不同
}
3、this
关键字
虽然写在类里面，但不是属于该类的，然是属于该对象的
在C#语言中this可以省略，其他语言不可以省略。但是如果有一个方法
，形参名字和成员名字重复，这时候在调用该对象里面的成员是需要加
this关键字
例子：
class Program
{
static void Main(string[] args)
{
Ren r =new Ren();
r.ShowName();
}
}
class Ren
{
//this 在该类里面带面该对象
//<div onclick="show(this)"></div>--这次句中相当于把这
个div元素传过去
private string _Name;
public string Name
{
get { return _Name; }
set { _Name = value; }
}
public string ShowName()
{
return "该人员名称为：" + this._Name;
}
}
在例子中，this代表Main中实例化r
4、is关键字
判断变量是不是属于某个类
if(变量 is 类型)
{
语句;
}
5、as关键字
转换类型（只能转换兼容类型，可以将子类对象转换为父类对象）
6、继承
子类可以继承父类的一切。
特点：单继承
一个子类只能有一个父类
一个父类可以有多个子类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 面向对象3
{
class Program
{
static void Main(string[] args)
{
China a = new China();
a.Age = 0;
a.Speak();
}
}
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 "人类正在说话";
}
}
class China:Ren
{
public string Eat()
{
return base.Name+"用筷子吃饭";
}
}
class American : Ren
{
public string Eat()
{
return "用刀叉吃饭";
}
}
}
base关键字：在子类代表父类对象，用法和this关键字相同。可以调用父类的属性和方法
如果父类有构造方法，那么子类也要有构造方法，如果父类构造需要参数，那么子类构造也必须有相应的参数
子类构造后面可以通过base调用父类的构造方法
public China(string m): base(m)
{
}
C#特殊点：所有类的祖先都是object类
（3）多态
多态是强类型语言中使用是的一种特性
C#是一种强类型语言，弱类型语言可以随意转换类型，所以不存在多态
JS就是一种弱类型语言
例如：
var a = 6;
此处a的数据类型是根据后面赋值的值的类型来确定的，后面是int型，a就是int型，后面是string类型，a 就是string类型。
封装
目的：保护类，让类更安全
做法：将成员变量变为私有，做相应的方法或属性来间接操作成员变量
函数重载：
条件：函数名相同，参数个数或者参数类型不同
构造函数：
写法：没有返回类型，函数名是类名
特点：写法特殊 执行时间特殊、
作用：在造对象的时候，对对象里面的成员进行初始化
this关键字：
this代表该对象，不是代表该类
访问修饰词：
public 公有的
protected 受保护的
private 私有的
继承：
概念：子类可以继承父类的一切
特点：单继承 一个子类只能有一个父类，一个父类可以有多个子类
base关键字
sealed关键字：密封类，该类不可被继承
部分类 partial 可以将一个类拆分成多个部分，分别放在多个文件内
namespace 命名空间 相当于虚拟文件夹
使用这个关键字来扩展类
（3）多态
一、编译多态
函数重载
二、运行多态
概念：当父类引用指向子类实例的时候，由于子类对父类的方法进行了重写，在调用该方法的时候表现出的不同就称为多态
Ren r = new Ren();
子类的方法会覆盖父类的方法。
class DongWu
{
public virtual string Eat()//虚方法
{
return "该动物在吃饭";
}
}
class Dog : DongWu
{
public override string Eat()//重写
{
return "狗在吃骨头";
}
}
相当于把父类的方法修改了
条件：必须要有继承，父类引用指向子类实例，子类必须对父类的方法进行重写
里氏代换原则：如果有一个地方需要使用到父类对象，可以用子类的对象 替换它。
C#是强类型语言
弱类型语言可以随意转换类型
JS：弱类型语言
var a = 6;