在使用equals对字符串继续比较时，字符的大小写不会影响结果 

可以随意使用一个变量来调用equals

console.WriteLine（对象1.equals（对象2））；

equals对比是根据引用来判断的

重写equals用过值来判断

插入的操作

1.迁移（从后往前,将插入点后的数据后移）

for(int i=count-1;i>index-1;i--)

{

array[i+1]=array[i];

}
2.将数据插入，count++，

 

移除的操作（参数是索引，不是值）

从前往后覆盖

Lisa

Rose

Jiose

Zj'fi's'f'ji's

1.抽象类可以包含方法体，接口不能包含方法体，所以接口就不能包含普通带有函数体的函数了

2.抽象类是一个不完整的模板，他只能通过继承来实现构造对象，所以抽象类通常被称为抽象基类

3.接口也是一个不完整的模板，同样也不能够完成实例化（构造对象），

抽象类和接口的区别：抽象类可以用普通函数

new方法和override方法都相当于把父类的函数在子类重写一遍，只要是子类构造的，在调用函数的时候都会调用子类重写后的。new隐藏方法如果是用子类构造，父类声明的就会调用父类的方法（哪个声明的就用那个的方法new son()是构造father b=new son()是声明），virtual必须和override一起使用，但new可以单独使用

用子类构造的数据可以传给父类，在调用函数时会调用子类的例如a.Fun2(b),主要是看参数，也即是b是子类还是父类的，当参数是整数或者不是子类或者父类的，就看是谁调用的，也就是这里的a，如果是a调用的就执行父类的函数，如果是b调用的就执行b类重回后的函数

运算符重载

函数重载相当于重写

运算符重载相当于重新定义运算符的运算方法

比如，判断数据是否相等默认情况是根据判断数据的引用（地址）是否相等，想要重新定义==的功能根据值判断 >>运算符重载

声明函数 ：

public static bool operator==(Students1,Student s2)
==和！=必须成对的写 

 public static bool operator !=(Student s1, Student s2)
        {
            bool result = s1 == s2;//程序的思路应该是多利用已有的资源，举一反三
            //s1==s2只是一种运算
            return !result;//返回与==运算相反的值，bool也可以取反 }

c#中可以重写的运算符有：==、！=、>、<、

 

索引器

定义索引器电脑方法：

public int this 【int  index】

{

get{}set{}

}

使用索引器的方法：取值，赋值

运算器重载     

 索引器的使用在主函数中   

Console.WriteLine(wk["Thur"]);

  在类中  public int this[string day]
      {

            get
            {    }
        }、

索引器相对于普通函数书写跟整洁

接口的继承

Interface 接口 method 方法

interface Interface2：Interface1

在一个新类中实现

class classInterface ：Interface2

一个类可以继承多个接口但只能继承一个类

例如：

class classInterface:Interface2,Interface1,Brid

 

接口

定义接口：

新建项，接口名为IFly

interface 接口名

{

void fly（）；

}

(习惯在接口名前+I)，接口里是不包含数据成员的

定义一个接口在语法上和定义抽象类完全相同，但不允许提供接口中有成员，接口只能包含方法，属性，索引器和事件的申明。

接口不能有构造函数，也不能有字段（成员），接口也不允许运算器重载

接口定义中不允许声明成员的修饰符，接口成员都是公有的

IFly 飞翔接口可以包含多个方法，默认为public

接口没有继承，实现接口的方法有

1.传统

定义 一个新的类，从中类似于继承

  class 类名：接口名实现窗口

 

2.多态

IFly fly;

fly = new Plane();

fly.Fly();

 

静态成员储存在静态存储区

静态成员是该类所有对象共享的，只能用类来访问

（java没有这个要求）

静态函数只能使用静态数据

静态类不能实例化，当游戏中有公共只存一份的成员可以放在静态类中

其他修饰符

new 隐藏继承方法

abstract 抽象类和抽象方法

sealed 密封类和密封方法（必须是重写方法，override表示不能被写了）

static 静态（不能和abstract 、sealed一起写）

const （不能和stastic一起使用）声明常量

readonly 声明只读字段 ，只能在初始和构造函数的时候赋值，之后不能修改

virtual用来声明虚方法（父类），override用来重写虚方法（子类）

 

修饰符

定义：修饰符用来修饰方法，指定函数的可见性

public全部可见

private在类中

protected 派生类中可以访问，在没有继承类的时候跟private是一样的

inteamal同一程序集（比public稍微高一点）

默认的 class +类名是在本项目下

当想在当前项目下访问其他项目中的类：

1.在当前项目添加项目引用

2.引入其他项目的命名空间

3.在其他项目的类+public（父类也需要public）

 

子类的构造函数

构造函数：方法和类名相同,在创建对象时会调用构造函数

在子类调用父类的构造函数

public DrivedClass():Base//这里的Base是父类的意思，比赛父类名，写不写base结果都一样

顺序：先构造父类，在构造子类

            Drivedclass bc1 = new Drivedclass();//必须用子类来创建一个对象，用父类创建的只会完成父类的构造函数
在子类函数调用父类的构造函数

public DrivedClass (int attack,int hp,int speed):base()

当指定调用父类某个有参数的函数时，就不会去调用无参数的函数了

抽象类

如果父类的函数在各个子类中都不要设置不同的函数体，在父类中定义就没必要了，就可以设置只有函数名，没有函数体，声明成抽象函数

1.抽象类的设置(非抽象类里面不能含有抽象函数)

abstract class Enemy

2.抽象函数 的设置

public abstract void Attack();

3.抽象类是不能构造对象的，例如

Enemy ey=new Enemy();

只能声明Enemy ey；但new Enemy() 使用抽象类的模板是错误的

处理办法：在当前行的左边点击实现抽象类

将函数体修改 

抽象函数和虚方法的区别：

抽象函数是让父类只需要声明函数，而子类负责设置

在抽象类里abstract  class Enemy{

public abstract void Attack()

{。。。} }

在子类里面 class Boss : Enemy
    {
        public override void Attack()}

虚方法是在子类里重写函数

public virtual void Move()

在boss类中

(输入override会有提示)

public override void Move()

{

base.Move();//和父类相同

}

密封类  sealed

作用：1.防止重写某些类，导致代码混乱

            2.商业原因

类不能继承，方法不能重写 

在父类用virtual虚方法

普通类+virtual方法

在子类重写方法

继承类+override方法+sealed（该方法不可以再次被重写）

 

 

 

 

通过隐藏方法来重写

public new viod AI(){...}

 相当于直接重写+new，防止出错

这两种virtual和隐藏方向的区别是，在调用函数的时候virtual会调用重写后的方法，也就是子类的，但隐藏方法只是在子类重新

创建子类对象的方式

1.Boss b1=new boss();

2.Enemy b2=new boss();

第二种方式创建时，默认使用的方法是父类的，当使用了virtua虚方法的时候，使用的方法是子类的 

可以把子类赋值给父类。但是不能把父类赋值给子类（子类的要求更高）

例如  Enemy enemy=new boss();        对的

          Boss b = new Enemy;          错误

构造的子类对象赋值给父类声明的对象，本质还是子类的对象，但是父类声明的，子类里的方法不能使用

重写函数的办法

1.虚方法

在Enemy中

pubilc virtual void Move()

在boss类中

(输入override会有提示)

public override void Move()

{

base.Move();//和父类相同

}

2.隐藏方法、

this 可以访问父类和子类，base只能访问父类

案例实现

父类--boss

子类--type1ememy、type2ememy

1.创建enemy类

变量包括 血量hp、时间speed

方法（函数）包括AI、移动Move

2 .创建enemy派生出的boss类

boss类包括特殊的变量和方法

例如print方法用来打印boss的各个属性参数

skill方法用来使用技能

attack变量为攻击力

3.创建enemy派生出的type1ememy和type2ememy

 访问权限包括：private protected public

protected是指必须要子类才能调用

5.在boss函数中使用构造函数

 在主函数中先创建一个boss类的对象名为boos1，参数为100，穿个boss类

boss类

this 的作用

1.可以查看当前对象的所有变量

2.可以用来区分变量的对象

利用类创建对象（因此对象也即为一个变量）：

Customer c1 = new Customer();

以上可分为：

Customer c1;  //声明对象

c1 = new Customer;  //实例化一个对象，否则是空引用（等同于Customer c1 = null; 效果）

可以直接通过这个对象去访问类里的成员

base 基 class 类

drived 派生 

派生方法：

    Drivedclass :Baseclass

继承

定义：

把相同部分、属性变成父类(搞基)

在派生出来一些子类（派生类）也可以将某部分重写

继承包括：实现继承、接口继承、多重继承

多重继承（c++）：例单继承是指只有一个父类派生出所有的子类，而多重继承是指可以继承多个父亲，每一个子类都可以继承自己想要继承的父类（可以有多个父类）