许可优化
许可优化
产品
产品
解决方案
解决方案
服务支持
服务支持
关于
关于
软件库
当前位置:服务支持 >  软件文章 >  唐老狮Unity系列C#四部曲核心篇,编程进阶

唐老狮Unity系列C#四部曲核心篇,编程进阶

阅读数 10
点赞 0
article_banner


*************用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保护访问修饰符

// 结构体可以继承 接口,因为接口是行为的抽象

// 对象是数据集合时,优先考虑结构体,比如位置、坐标等等

// 从值类型和引用类型赋值时的区别上考虑


免责声明:本文系网络转载或改编,未找到原创作者,版权归原作者所有。如涉及版权,请联系删

相关文章
技术文档
QR Code
微信扫一扫,欢迎咨询~
customer

online

联系我们
武汉格发信息技术有限公司
湖北省武汉市经开区科技园西路6号103孵化器
电话:155-2731-8020 座机:027-59821821
邮件:tanzw@gofarlic.com
Copyright © 2023 Gofarsoft Co.,Ltd. 保留所有权利
遇到许可问题?该如何解决!?
评估许可证实际采购量? 
不清楚软件许可证使用数据? 
收到软件厂商律师函!?  
想要少购买点许可证,节省费用? 
收到软件厂商侵权通告!?  
有正版license,但许可证不够用,需要新购? 
联系方式 board-phone 155-2731-8020
close1
预留信息,一起解决您的问题
* 姓名:
* 手机:

* 公司名称:

姓名不为空

姓名不为空

姓名不为空
手机不正确

手机不正确

手机不正确
公司不为空

公司不为空

公司不为空