特征------成员变量
行为------成员方法
初始化调用------构造函数
释放时调用------析构函数
保护成员变量------成员属性
像数组一样使用------索引器
类名点出使用------静态成员
自定义对象可计算------运算符重载
静态类和静态构造函数
拓展方法
内部内和分部类
知识点一 内部类
概念：在一个类中再申明一个类
特点：使用时要用包裹者点出自己
作用：亲密关系的变现
注意：访问修饰符作用很大
csclass Person { public int age; public string name; public Body body; public class Body { Arm leftArm; Arm rightArm; class Arm { } } }知识点二 分部类
概念：把一个类分成几部分申明
关键字：partial
作用：**分部描述一个类，**增加程序的拓展性
注意：
分部类可以写在多个脚本文件中
分部类的访问修饰符要一致
分部类中不能有重复成员
cspartial class Student { public bool sex; public string name; partial void Speak(); } partial class Student { public int number; partial void Speak() { //实现逻辑 } public void Speak(string str) { } }知识点三 分部方法
概念：将方法的申明和实现分离
特点
1.不能加访问修饰符 默认私有
2.只能在分部类中申明
3.返回值只能是void
4.可以有参数但不用 out关键字 局限性大，了解即可
csclass Program { static void Main(string[] args) { Console.WriteLine("内部类和分部类"); Person p = new Person(); Person.Body body = new Person.Body(); } }
继承
知识点一 基本概念
一个类A继承一个类B
类A将会继承类B的所有成员
A类将拥有B类的所有特征和行为
被继承的类称为 父类、基类、超类
继承的类称为子类、派生类
子类可以有自己的特征和行为
特点
1**.单根性** 子类只能有一个父类
2.传递性 子类可以间接继承父类的父类
知识点二 基本语法
cs
class 类名 : 被继承的类名
{
}实例
cs
class Test
{
}
class Teacher
{
姓名
public string name;
职工号
protected int number;
介绍名字
public void SpeakName()
{
number = 10;
Console.WriteLine(name);
}
}
class TeachingTeacher : Teacher
{
科目
public string subject;
介绍科目
public void SpeakSubject()
{
number = 11;
Console.WriteLine(subject + "老师");
}
}
class ChineseTeacher:TeachingTeacher
{
public void Skill()
{
Console.WriteLine("一行白鹭上青天");
}
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine("继承的基本规则");
TeachingTeacher tt = new TeachingTeacher();
tt.name = "怪盗基德";
tt.number = 1;
tt.SpeakName();
tt.subject = "Unity";
tt.SpeakSubject();
ChineseTeacher ct = new ChineseTeacher();
ct.name = "怪盗基德";
ct.number = 2;
ct.subject = "语文";
ct.SpeakName();
ct.SpeakSubject();
ct.Skill();
}
}知识点四 访问修饰符的影响
public - 公共 内外部访问
private - 私有 内部访问
protected - 保护 内部和子类访问
internal - 内部的 只有在同一个程序集的文件中，内部类型或者是成员才可以访问
知识点五 子类和父类的同名成员
概念 ：C#中允许子类存在和父类同名的成员
但是 极不建议使用
总结
继承基本语法
class 类名:父类名
1.单根性 ：只能继承一个父类
2.传递性 ：子类可以继承父类的父类的所有内容
3.访问修饰符 对于成员的影响
4.极奇不建议使用 在子类中申明和父类同名的成员
里氏替换原则
知识点一 基本概念
里氏替换原则是面向对象七大原则中最重要的原则
概念：任何父类出现的地方，子类都可以替代
重点：语法表现------父类容器装子类对象,因为子类对象包含了父类的所有内容
作用：方便进行对象存储和管理
知识点二 基本实现
cs
class GameObject
{
}
class Player:GameObject
{
public void PlayerAtk()
{
Console.WriteLine("玩家攻击");
}
}
class Monster:GameObject
{
public void MonsterAtk()
{
Console.WriteLine("怪物攻击");
}
}
class Boss:GameObject
{
public void BossAtk()
{
Console.WriteLine("Boss攻击");
}
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine("里氏替换原则");
里氏替换原则 用父类容器 装载子类对象
GameObject player = new Player();
GameObject monster = new Monster();
GameObject boss = new Boss();
GameObject[] objects = new GameObject[] { new Player(), new Monster(), new Boss() };
}
}知识点三 is和as
基本概念
is：判断一个对象是否是指定类对象
返回值：bool 是为真 不是为假
as：将一个对象转换为指定类对象
返回值：指定类型对象
成功返回指定类型对象，失败返回null
基本语法
类对象 is 类名 该语句块 会有一个bool返回值 true和false
类对象 as 类名 该语句块 会有一个对象返回值 对象和null
cs
if( player is Player )
{
Player p = player as Player;
p.PlayerAtk();
(player as Player).PlayerAtk();
}
for (int i = 0; i < objects.Length; i++)
{
if( objects[i] is Player )
{
(objects[i] as Player).PlayerAtk();
}
else if( objects[i] is Monster )
{
(objects[i] as Monster).MonsterAtk();
}
else if (objects[i] is Boss)
{
(objects[i] as Boss).BossAtk();
}
}总结
概念：父类容器装子类对象
作用：方便进行对象的存储和管理
使用：is和as
is 用于判断
as 用于转换
注意：不能用子类容器装父类对象
继承中的构造函数
知识回顾
构造函数
实例化对象时调用的函数
主要用来初始化成员变量
每个类 都会有一个默认的无参构造函数
语法
cs访问修饰符 类名() { } 不写返回值 函数名和类名相同 访问修饰符根据需求而定,一般为public构造函数可以重载
可以用this语法重用代码
注意有参构造会顶掉默认的无参构造
如想保留无参构造需重载出来
csclass Test { public int testI; public string testStr; public Test() { } public Test(int i) { this.testI = i; } public Test(int i, string str) : this(i) { this.testStr = str; } }知识点一 继承中的构造函数 基本概念
特点：
当申明一个子类对象时，先执行父类的构造函数，再执行子类的构造函数
注意：
1**.父类的无参构造 很重要**
2.子类可以通过base关键字 代表父类 调用父类构造
知识点二 继承中构造函数的执行顺序
父类的父类的构造------>。。。父类构造------>。。。------>子类构造
csclass GameObject { public GameObject() { Console.WriteLine("GameObject的构造函数"); } } class Player:GameObject { public Player() { Console.WriteLine("Player的构造函数"); } } class MainPlayer : Player { public MainPlayer() { Console.WriteLine("MainPlayer的构造函数"); } }知识点三 父类的无参构造函重要
子类实例化时 默认自动调用的 是父类的无参构造 所以如果父类无参构造被顶掉 会报错
csclass Father { public Father() { } public Father(int i) { Console.WriteLine("Father构造"); } } class Son:Father { #region 知识点四 通过base调用指定父类构造 public Son(int i) : base(i) { Console.WriteLine("Son的一个参数的构造"); } public Son(int i, string str):this(i) { Console.WriteLine("Son的两个参数的构造"); } #endregion } class Program { static void Main(string[] args) { Console.WriteLine("继承中的构造函数"); MainPlayer mp = new MainPlayer(); Son s = new Son(1,"1412"); } }
总结
继承中的构造函数
特点：执行顺序是先执行父类的构造函数 再执行子类的 从老祖宗开始 依次一代一代向下执行
父类中的无参构造函数 很重要
如果被顶掉 子类中就无法默认调用无参构造了
解决方法：
1.始终保持申明一个无参构造
2.通过base关键字 调用指定父类的构造
注意：区分this和base的区别