*************用TXT文本记的************
第3课:类和对象
// 在 namespace 里面进行类的声明
class Person
{
成员变量; 成员方法; 成员属性;构造函数; 析构函数;索引器;运算符重载;静态成员
}
Person P = new Person( );
第5课:成员变量和访问修饰符
class Person
{
int a = 1; // 任何类型的变量都可以用
Person p; // 可以套娃,但不能new一个新的赋值
// 会无限套娃爆内存
// 现在是空的状态,只有个名字
}
// 访问修饰符
// public - 公共的,内部和外部都能访问使用
// private - 私有的,只有内部能用,不写默认是private
// protected - 保护的,内部和子类才能访问使用
第7课:成员方法
class Person
{
public string name;
public void Speak(string str)
{
Console.WriterLine("{0}说{1}", name, str);
}
}
Person p = new Person( );
p.name = "小明";
p.Speak("你好");
第9课:构造、析构、垃圾回收
** 初始化时调用构造函数 **
class Person
{
public string name;
public int age;
public Person( str name ) // 用来初始化的构造函数
{ // 可以函数重载
this.name = name; // this 代表自己
}
// 特殊写法,会优先运行 this(name)代码,然后再运行后续内容
// this 代表自己,这里就是用的上面的函数
public Person( int age, str name ) : this( name )
{
this.age = age;
}
// 析构函数
~Person( ) // 当引用的堆内存被回收时触发
{ // 暂时用不上
}
}
Person p = new Person(18, "XiaoMing");
p = null; // 触发析构函数
GC.Collect( ); // 手动触发垃圾回收
// 一般情况不会用
// 都是在 Loading 加载场景时才会用的
第11课:成员属性
class Person
{
private name; // private 私有的,无法在外面直接访问
public string Name
{
get // 获取私有的属性值
{ // 可以在返回前加些逻辑规则
name -= "MIO"; // 解密
return name;
}
set // 用来收取外部传入的内容
{ // 可以在传入前加些逻辑规则
name += "MIO"; // 加密
name = value; // value 代表外部传入的值
}
}
// 自动属性
// 外部能得到,但是不能修改
// 如果没有什么特殊处理就可以用自动属性
public string Name
{
get;
private set;
}
}
Person p = new Person( );
p.Name = "xiaoming"; // 传入数据
Console.WriterLine(p.Name); // 获取内容(因为是私有的所以会报错)
第13课:索引器
** 让对象像数组一样使用 **
class Person
{
private int age;
private Person[ ] friends;
public Person this[int index]
{
get
{
if (friends == null || friends.Length < index)
{
return null;
}
return friends[index];
}
set
{
if (friends == null)
{
friends = new Person[ ] { value };
}
else if (index > friends.Length - 1)
{
Console.WriterLine("ERROR!");
return;
}
friends[index] = value;
}
}
}
Person p = new Person( );
p[0] = new Person( );
Console.WriterLine(p[0]);
第15课:静态成员
** 无需初始化的调用 **
class Test
{
static public float Pi = 3.14f; // 静态成员变量
public int a = 100; // 成员变量
public const int b = 123; // 常量,不可修改,其他同静态变量
public static float MianJi(float r) // 静态方法
// 不可直接调用普通变量
{
return Pi * r * r;
}
}
Console.WriterLine(Test.Pi); // 静态成员不需要初始化就能调用
Console.WriterLine(MianJi(5)); // 静态方法也一样
第17课:静态类和静态构造函数
** 静态类
** 只能包含静态成员
** 不能实例化
** 可用于工具类 **
static class Tool
{
public static int a = 0; // 静态成员
public ststic void TestFun( ); // 静态方法
{
}
static Tool( ) // 静态构造函数
{ // 不能用访问修饰符
Console.WriterLine("1"); // 只调用一次
} // 基本用不上
}
第19课:拓展方法
*** 为现有的非静态变量类型添加新的方法
*** 提升程序的拓展性
*** 一定写在静态函数中
*** 第一个参数用 this 修饰
static class Tool
{
publc ststic void SpeakValue(this int value, int a, int b) // 为 int 增加方法
{
Console.WriterLine("" + value + a + b);
}
public static void Fun2(this Test t)
{
Console.WriterLine("新方法");
}
}
class Test
{
int i = 99;
public Fun( )
{
Console.Writerline("哈哈");
}
}
int i = 10;
i.SpeakValue(22, 33); // 输出为 102233
Test t = new Test( );
t.Fun2( ); // 输出为 新方法
第21课:运算重载符
*** 使用关键字 operator
*** 一定是公共的静态方法
*** 可以让自定义类和结构体对象进行运算
*** 可以一个符号多个重载
*** public static 返回类型 operator 运算符(参数列表)
class Point
{
public int x;
public int y;
public static Point operator +(Point p1, Point p2)
{
Point p = new Point;
p.x = p1.x + p2.x;
p.y = p1.y + p2.y;
return p;
}
}
Point p1 = new Point( );
p1.x = 1;
p1.y = 1;
Point p2 = new Point( );
p2.x = 2;
p2.y = 2;
Point p3 = p1 + p2;
第23课:内部类和分部类
// 内部类
*** 在类里面写类,套娃

// 分部类
*** 可以写在多个脚本文件中
*** partial 用作开头
partial class Student {
int a;
partial void Speak( ); // 声明分部方法
}
partial class Student {
int b;
partial void Speak(string str)
{
// 分部方法的实现逻辑
}
}
// 分部方法
*** 将方法的声明和实现分离
*** 不能加访问修饰符,默认私有
*** 只能在分部类中声明
*** 返回值只能是 void
*** 基本不用 ⬆️
第24课:继承的基本概念
*** 继承父类的一切
*** class 子类名 : 父类名
*** 访问修饰符的影响:public-都能用,private-只有自己能用,protected-子类也能用
internal-同一个程序集的文件中,内部或是成员才能访问
第26课:里氏替换
*** 任何父类出现的地方,子类都可以替代
*** 用父类容器装子类对象,因为子类对象包含了父类的所有内容
*** 方便进行对象的存储和管理
class GameObject { }
class Player : GameObject { }
class Monster : GameObject { }
GameObject player = new Player( ); // 用父类容器装子类对象
GameObject monster = new Monster( );
GameObject[ ] objects = new GameObject[ ] { new Player( ), new Monster( ) };
// is 和 as 的作用
*** 里氏替换无法直接调用子类的内容,需要再转一次
for (int i = 0; i < objects.Length; i++)
{
if (objects[i] is Player) // 判断是否为子类
{
(objects[i] as Player).PlayerAtk; // 将父类转为子类
} // 并调用子类函数
if (objects[i] is Monster)
{
(objects[i] as Monster).MonsterAtk;
}
}
第28课:继承中的构造函数
*** 当声明一个子类对象时,先执行父类的构造函数,再执行子类的构造函数
*** 父类的无参构造函数 很重要
*** 子类可以通过 base 关键字 代表父类 调用父类构造函数
*** 子类实例化时 默认自动调用父类的无参构造函数
*** 如果父类的无参构造函数被顶掉,会报错
*** 需要在父类再写一个无参构造函数
*** 还可以用 base 调用指定的父类构造,这样可以不写无参构造
class Father
{
public Father(int i) // 无参构造被顶掉
{
console.WriterLine("啊啊啊");
}
}
class Son : Father
{
public Son(int i) : base(i) // 通过 base 调用父类的构造
{
}
public Son(int i, string str) : this(i) // 重载也要调用,否则会报错
{ // this 代表调用上面的 Son(int i) : base(i) 代码
}
}
第30课:万物之父和装箱拆箱
*** object 是所有类型的基类,它是一个类(引用类型)
*** 可以用里氏替换,用 object 容器装所有对象
*** 可以用来表示不确定类型,作为函数参数类型
object o = new Son( ); // object 是所有类的父类
if (o is Son)
{
(o as Son).Speak( );
}
object o2 = 1f; // 数值类型也可以用
float f1 = (float)o2; // 可以强转为别的值类型
object str = "123123";
string str2 = str as string; // string 类型转换有点不一样
string str3 = str.ToString( );
object arr = new int[5];
int[ ] arr2 = (int[ ])arr; // 数组强转
int[ ] arr3 = arr as int[ ]; // 建议都用 as 进行转换,不然容易搞错
*** 装箱拆箱 ***
*** 用 object 存值类型(装箱)栈内存转移到堆内存
*** 再把 object 转为值类型(拆箱)堆内存会转移到栈内存
*** 好处:不确定类型时可以方便存储传递
*** 坏处:存在内存迁移,有性能损耗
static void Test(params objict[ ] array) { } // 变长函数,可输入任意数量
Test(1, 2, 3.2, 5f, "222"); // object 让你能输入任意类型数据
第32课:密封类
*** 使用 sealed 关键字修饰类
*** 让类无法被继承
sealed class Father
{
}
class Son : Father // 会报错,Father 类无法继承
{
}
第34课: 多态vob
*** 让继承同一父类的子类,在执行相同方法时有不同的表现
*** 虚函数 ***
*** virtual *** override ***
*** 让同一个对象有唯一行为特征
class Father
{
public void Speak( )
{
Console.WriteLine("Father的方法");
}
// 虚函数 可以被子类重写
public virtual void Atk( ) // 关键字 virtual
{
Console.WriteLine("Father攻击");
}
}
class Son : Father
{
public void Speak( )
{
Console.WriteLine("Son的方法");
}
// 重写虚函数
public override void Atk( ) // 关键字 override
{
// base 代表父类,用来保存父类的行为
base.Atk( );
Console.WriteLine("Son攻击");
}
}
Father f = new Son( );
f.Speak( ); // 输出 Father的方法
(f as Son).Speak( ); // 输出 Son的方法
f.Atk( ); // 输出 Father攻击
Son攻击
// 虚函数的效果
第36课:抽象类和抽象函数
*** 抽象类 *** 关键字 abstract ***
*** 不能被实例化
*** 可以包含抽象方法
*** 继承抽象类必须重写其抽象方法
abstract class Thing
{
public string name; // 抽象类中什么都能写
}
class Water : Thing // 抽象类可以被继承
{
}
// Thing t = new Thing( ); // 报错,不能被实例化
Thing t = new Water( ); // 可以用里氏替换,父类容器装子类
第38课:接口
*** 接口是行为的抽象规范
*** 它也是一种自定义类型,关键字:interface
*** 接口命名规范:帕斯卡前面加个I
*** 不包含成员变量
*** 只包含方法、属性、索引器、事件
*** 成员不能被实现
*** 成员可以不用写访问修饰符,不能是私有的
*** 接口不能继承类,但可以继承另一个接口
*** 类可以继承多个接口
*** 类继承接口后,必须实现接口中所有成员
*** 它和类的申明类似
*** 接口是用来继承的
*** 接口不能被实例化,但是可以作为容器存储对象
interface IFly
{
string name; // 报错,不能有成员变量
string Name // 可以用自动属性
{
get;
set;
}
void Fly( ); // 方法
int this[int index] // 所引器
{
get;
set;
}
event Action doSomeThing; // 事件
}
class Animal{ }
class Person : Animal, IFly // 类可以继承1个类,n个接口
{
public virtual void Fly( ) // 必须加 public 修饰符
{ // 接口函数,使用 virtual 可以在子类重写
}
... // 其他接口的内容也要有
}
IFly f = new IFly( ); // 报错,不能实例化接口
IFly f = new Person( ); // 接口也遵训里氏替换原则
interface IWalk
{
void Walk( );
}
interface IMove : IFly, IWalk // 接口继承接口时,不需要实现其内容
{ // 等类继承接口后,类自己去实现所有内容
}
*** 当一个类继承两个接口,但是接口存在同名方法时,实现接口时不能写访问修饰符
** 会导致继承了跟没继承一样
interface IAtk
{
void Atk( );
}
interface ISuperAtk
{
void Atk( );
}
class Player : IAtk : ISuperAtk
{
// public void Atk( ){ } // 相当于没继承,重写了 Atk 方法
void IAtk.Atk( )
{
}
void ISuperAtk.Atk( )
{
}
}
IAtk ia = new Player( );
ISuperAtk isa = new Player( );
is.Atk( );
isa.Atk( );
Player p = new Player( );
// p.Atk( ); // 报错,因为有两个方法重名了,需要转成子类再调用
// 或者在类里面再写一个有访问修饰符的 Atk 方法
(p as IAtk).Atk( );
(p as ISuperAtk).Atk( );
第40课:密封函数
*** 关键字:sealed / override
*** 让方法或抽象方法之后不能再被重写
*** 跟密封类差不多
abstract class Animal // 抽象类,不可实例化,可继承
{
public abstract void Eat( ){ } // 抽象函数
public virtual void Speak( ){ } // 虚函数
}
class Person : Animal
{
public override void Eat( ){ }
//public sealed override void Eat( ){ } // 密封函数
public override void Speak( ){ }
}
class WhitePerson : Person
{
public override void Eat( ){ } // 如果已密封,则会报错
public override void Speak( ){ }
}
第42课:命名空间
*** 命名空间是用来组织和重构代码的
*** 类的申明都是在命名空间中的
*** 不同命名空间中互相使用,需要引用命名空间或指明出处
*** 不同命名空间中允许有同名类
*** 命名空间可以无限套娃
*** 命名空间中的类默认为 internal (访问修饰符)
*** public —— 完全公开
*** internal —— 只能在该程序集使用
*** abstract —— 抽象类
*** sealed —— 密封类
*** partial —— 分部类
namespace MyGame
{
class GameObject
{
}
}
using MyGame;
GameObject g = new GameObject( );
MyGame.GameObject g = new MyGame.GameObject( ); // 两种方法都行
第43课:万物之父中的方法
*** object 中的静态方法 ***
*** Equals —— 判断两个对象是否相等
*** ReferenceEquals —— 判断两个引用类型是否相等(值类型始终是 False )
Console.WriteLine(Object.Equals(1, 1)); // True
Test t = new Test( );
Test t2 = new Test( );
Console.WriteLine(Object.Equals(t, t2)); // False // 指向两个不同地址
Console.WriteLine(Object.ReferenceEquals(t, t2)); // False
*** object 中的成员方法 ***
*** GetType —— 反射中的重要方法,获取运行对象的类型
*** MemberwiseClone —— 获取对象的浅拷贝对象,返回一个新的对象
// 但是新的对象中的引用变量和老对象一致
Test t = new Test( );
Type type = t.GetType; // 暂时不用理解
class Test
{
public int i = 1;
public Test2 = new Test2( );
public Test Clone( );
{
return MemberwiseClone( ) as Test;
}
}
class Test2
{
public int i = 2;
}
Test t = new Test( );
Test t2 = t.Clone( );
Console.WriteLine("克隆后“);
Console.WriteLine(t.i); // 1
Console.WriteLine(t.t2.i); // 2
Console.WriteLine(t2.i); // 1
Console.WriteLine(t2.t2.i); // 2
t2.i = 20;
t2.t2.i = 21;
Console.WriteLine("修改克隆信息后“);
Console.WriteLine(t.i); // 1
Console.WriteLine(t.t2.i); // 21
Console.WriteLine(t2.i); // 20
Console.WriteLine(t2.t2.i); // 21
*** object 中的虚方法 *** // 虚方法可重写
*** Equals —— 判断是否为相同引用
*** GetHashCode —— 获取对象哈希码
*** ToString —— 用于返回当前代表的字符串
第45课:string
*** 字符串指定位置获取 ***
*** 字符串本质是 char 数组
string str = "超级无敌";
Console.WriteLine(str[0]); // 超
char[ ] chars = str.ToCharArray( ); // 字符串转 char 数组
Console.WriteLine(char[1]); // 级
*** 字符串拼接 ***
*** Format ***
str = string.Format("{0}{1}", 114, 514);
*** 正向查找字符位置 ***
*** IndexOf ***
int index = str.IndexOf("无"); // 2
int index2 = str.IndexOf("草"); // -1 (找不到返回-1)
*** 逆向查找字符位置 ***
*** LastIndexOf ***
index = str.LastIndexOf("无敌"); // 2
*** 移除指定位置后的字符 ***
*** Remove ***
str = "超级无敌";
str.Remove(2); // 超级无敌(返回新字符串,不修改原来的)
str = str.Remove(2); // 超级
str = str.Remove(0, 1); // 级(在0位置移除1个字符)
*** 替换指定字符串 ***
*** Replace ***
str = "超级无敌";
str = str.Replace("无敌", "牛逼"); // 超级牛逼
*** 大小写转换 ***
*** ToUpper *** ToLower ***
str = "asdf";
str = str.ToUpper( ); // ASDF
str = str.ToLower( ); // asdf
*** 字符串截取 ***
*** Substring ***
str = "超级无敌";
str = str.Substring(2); // 无敌
str = str.Substring(0, 1); // 无(保留0位置后的1个字符)
*** 字符串切割 ***
*** Split ***
str = "1, 2, 3, 4, 5";
string[ ] strs = str.Split(","); // 1
for (int i = 0; i < strs.Length; i++) 2
{ 3
Console.WriterLine(str[1]); 4
} 5
第47课:StringBuilder
*** 字符串每次修改都需要创建新对象,性能消耗大
*** 新方法不需要创建新对象,需要频繁修改时可以用它,提升性能
*** 使用前需要引用命名空间
*** StringBuilder 存在容量问题,每次往里面增加时,会自动扩容
*** 默认容量是2/4/8/16/32...以此类推,多出的空间会浪费存储空间
StringBuilder str = new StringBuilder("123123123"); // 初始化
//StringBuilder str = new StringBuilder("123123123", 100); // 手动设置容量100
Console.WriterLine(str.Capacity); // 获取容量 16
Console.WriterLine(str.Length); // 获取字符长度 9
// 增
str.Append("444"); // 123123123444
str.AppendFormat("{0}{1}", "111", "222"); // 123123123444111222
// 插入
str.Insert(0, "999"); // 999123123123444111222
// 删
str.Remove(0, 10); // 23444111222
// 清空
// str.Clear( );
// 查
str[1] // 3
// 改
str[0] = "A"; // A3444111222
// 替换
str.Replace("1", "B"); // A3444BBB222
// 重新赋值
str.Clear( );
str.Append("123123");
// 判断 StringBuilder 是否和某个字符串相等
if (str.Equals("123123"))
第49课:结构体和类的区别
// 存储位置不同,一个在栈上,一个在堆上
// 结构体具有封装的特性,但不具备继承和多态的特性,因此大大减少了它的使用频率
// 由于结构体不具备继承的特性,所以它不能够使用protected保护访问修饰符
// 结构体可以继承 接口,因为接口是行为的抽象
// 对象是数据集合时,优先考虑结构体,比如位置、坐标等等
// 从值类型和引用类型赋值时的区别上考虑
免责声明:本文系网络转载或改编,未找到原创作者,版权归原作者所有。如涉及版权,请联系删