【Unity之c#专题篇】—核心章题单实践

👨‍💻个人主页：@元宇宙-秩沅

👨‍💻 hallo 欢迎 点赞👍 收藏⭐ 留言📝 加关注✅!

👨‍💻 本文由 秩沅 原创

👨‍💻 收录于专栏：unityc#专题篇习题

⭐习题总结专题篇⭐

🎶前言

核心章知识点详解入口

🅰️ 题单来自：B站唐老狮

🎶（A） 面向对象

• 实践经验：
  
  1.类是对象，清楚类的本质
  2.对象和对象之间可作为参数相互联系（学生继承人，食物作为参数给学生）

 class Person
    {
      public   int age = 18;
      public   String name = "张三";
    }
    class Student : Person
    {
        String school ="北大";
        String sClass ="英语21102班";
        public void Eat(Food nice )
        {
           
            Console.WriteLine("我叫{0}，今年{1}岁，就读于{2}{3}，喜欢吃{4}", name, age, school, sClass, nice.foodName);
        }
    }
    class Food
    {
        public  String foodName ="西瓜";
        int foodForce;
    }
    class Program
    {
        static void Main(string[] args)
        {
            Student A  = new Student();
             Food  nice = new Food();
            A.Eat(nice);
        }
    }

🎶（B）封装-成员变量和成员方法

• 实践经验：
  
  1.成员变量是对象的特征
  2.成员方法是对象的行为
  3.用面向对象的角度去看待和解决问题

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _成员变量和访问修饰符
{
    /// <summary>
    /// 对象为人类
    /// </summary>
    class Person
    {
        public String name;
        public float heigt;
        public  Int32 age;
        public String area;
        public Person(String name,float  heigt ,Int32  age ,String area):this()
        {
            this.name = name;
            this.age = age;
            this.heigt = heigt;
            this.area = area;
            Console.WriteLine("信息构造成功，该学生的姓名为{0},身高为{1}，年龄为{2}，地址为{3}", this.name, this.heigt, this.age, this.area);
        }
        public Person()
        {
            Console.WriteLine("构造函数的有参构造的最大作作用开始启动——一键赋值！");
                
        }

            

        public void Speak()
        {
            Console.WriteLine("嗨你好，请叫我智能语音助手");
        }
        public void Work()
        {
            Console.WriteLine("行走方式为直立行走");
        }
        public void Eat()
        {
            Console.WriteLine("进食方式为使用餐具");
        }

    }
    /// <summary>
    /// 对象为学生
    /// </summary>
    class Student 
    {
        public String name;
        public Int32 idea;
        public Int32 age;
        public String classMate;
    
        public void S_Main()
        {
            Console.WriteLine("我的学习方式为复盘");
        }
        public void Eat()
        {
            Console.WriteLine("进食方式为使用餐具");
        }
    }
    /// <summary>
    /// 对象为班级
    /// </summary>
    class MClass
    {
        public String major;
        public String capitary;
        public Int32 studentS;
    }
    class Food
    {
        String name;
        float Hat;
    }

    /// <summary>
    /// 项目入口
    /// </summary>
    class Mian
    {
        static void Main(string[] args)
        {
            //开始创建多个人对象
            Person A = new Person("张三", 163, 23, "湖南");
        }
    }

}

🎶（C）封装-构造函数和析构函数

• 实践经验：
  
  1.最大作用一键赋值
  2.this对构造函数调用顺序的改变
  

class Ticket
    {
        public float distance;
        public float price;
        public float rate = 1;
        Ticket() //无参构造
        {
            Console.WriteLine("欢迎浏览车票信息！");
        }
        public Ticket(float dis):this() //调整构造函数调用的顺序
        {
            if (dis < 0)
            {
                Console.WriteLine("请传入不为负数的参数");
            }
            else
            {
                distance = dis;

            }
            ShowTicket();
        }
        public void GetPrice()
        {
            if (distance > 100 && distance <= 200) rate = 0.95f;
            else if (distance > 200 && distance <= 300) rate = 0.9f;
            else if (distance > 300) rate = 0.8f;
            price = rate * distance;
        }
        public void ShowTicket()
        {
            GetPrice();
            Console.WriteLine("本车票信息如下:\n 全程{0}公里\n 票价共{1}元", distance, price);
        }
        static void Main(string[] args)
        {
            Ticket B = new Ticket(288);
        }
    }
    #endregion

🎶（D）封装-成员属性

• 实践经验：
  
  1.解决了3P的局限性，提高了安全性
  2.用属性的逻辑规则进行保密处理
  3.自动属性（无逻辑规则的时候用）

 #region 18.学生自我介绍行为实现
    class Student
    {
     
        String sex;
        Int32 age;
        float cGrade;
        float uGrade;

        /// <summary>
        /// 四个属性的定义
        /// </summary>
        /// 
        public int A { get; set; } = 666;

        public String Name{ get; set; }
        public int Age
        {
            get
            {
                return this.age;
            }
            set
            {
                if (value >= 0 && value <= 150)
                    this.age = value;
                else Console.WriteLine("年龄超出范围！");
            }
        }
        public String Sex
        {
            get
            {
                return this.sex;
            }
            set
            {
                if (value == "男" && value == "女") this.sex = value;

                else Console.WriteLine("请传入男或者女");
            }
        }
        public float CGrade
        {
            get
            {
                return this.cGrade;
            }
            set
            {
                if (value >= 0 && value <= 100)
                    this.cGrade = value;
                else Console.WriteLine("成绩超出范围！");
            }
        }
        public float UGrade
        {
            get
            {
                return this.uGrade;
            }
            set
            {
                if (value >= 0 && value <= 100)
                    this.uGrade = value;
                else Console.WriteLine("成绩超出范围！");
            }
        }
        /// <summary>
        /// 构造函数一键赋值
        /// </summary>
        /// <param name="name"></param>
        /// <param name="sex"></param>
        /// <param name="age"></param>
        /// <param name="cGrade"></param>
        /// <param name="uGrade"></param>
        public Student(String name, String sex, int age, float cGrade, float uGrade)
        {
            Name = name;
            this.sex = sex;
            Age = age;
            CGrade = cGrade;
            UGrade = uGrade;
            SHi();
            Grade();

        }
        /// <summary>
        /// 问候方法
        /// </summary>
        /// 
        public void SHi()
        {
            Console.WriteLine("我是{0}，今年{1}，性别{2}", Name, Age, Sex);
        }
        /// <summary>
        /// 成绩计算方法
        /// </summary>
        /// <param name="args"></param>
     
        public void Grade()
        {
            Console.WriteLine("总分为{0}，平均分为{1}", CGrade + UGrade, (CGrade + UGrade) / 2);
 
            Console.WriteLine(A);
        }
        static void Main(string[] args)
        {
            Student A = new Student("张三", "男", 18, 90, 56);
        }

    }
    #endregion

🎶（E）封装-索引器

• 实践经验：
  
  1.通过索引器的索引对类中的成员进行便捷操作
  2.class Person ； person A = new person() ; A[1] = 2 ;
  3.模拟构造了用索引器的容器
  
• 便捷操作

    //定义一个 Name 属性来操作 name 字段
    public string Name
    {
        set { name = value; }
        get { return name; }
    }

    //定义一个 Password 属性来操作 password 字段
    public string Password
    {
        set { password = value; }
        get { return password; }
    }

    //定义索引器，name 字段的索引值为 0 ，password 字段的索引值为 1
    public string this[int index]
    {
        get
        {
            if (index == 0) return name;
            else if (index == 1) return password;
            else return null;
        }
        set
        {
            if (index == 0) name = value;
            else if (index == 1) password = value;
        }
    }
}

• 拟构容器

class INT
    {
        private int[] arrary;
        private int cerioty ;
        public int length;
        public INT() //构造函数中初始化
        {
            arrary = new int[cerioty];
            cerioty = 5;
            length = 0;
        }
        public int this[int index]
        {
            get
            {
                if (index > length) Console.WriteLine("越界！");
                return arrary[index];
            }
            set
            {
                arrary[index] = value;
                length++;
            }
        }
        //增
        public void Add(int vaule)
        {
            if(length+1 < cerioty )
            arrary[length++] = vaule;
            //进行扩容操作
            else              
            {
                cerioty *= 2;
                int[] tempArray = new int[cerioty];
                for (int i = 0; i < length; i++)
                {
                    tempArray[i] = arrary[i]; //值全部先放过去
                }
                arrary = tempArray;          //然后地址变更成新地址 ，旧的空间变成垃圾回收
            }
            
        }
        //删
        public void Remove(int index)
        {
            if(arrary[index]!=null)
            {
                arrary[index] = 0;
            }
        }
        static void Main(string[] args)
        {
            INT A = new INT();
            A.Add(666);
            A.Add(999);
            A[0] = 250;
            Console.WriteLine(A[0]+" "+A[1]+" "+A[2]+" "+A[3]);
        }
    }

🎶（F）封装-静态成员

• 实践经验：
  
  1.静态函数不能直接调用非静态成员
  2.在单例模式中的应用

单例模式的实现‘

   class MathS
    {
        private static MathS m; //2.此时外部可以访问并且只有一个该对象存在，因为它在该对象内部实例化了
                                //但是外部还是可以修改为NULL，就达不到第三个条件通过类名点出来得到唯一的对象
        public int secret = 10;
        public static MathS M//3.通过属性只返回一个唯一实例化的对象，就可以实现第三部分直接通过类名点出来得到唯一的对象并且不可被修改
        {
            get
            {
                return m = new MathS();
            }
        }
        private MathS() //1.构造函数变成私有，此时外部无法进行实例化
        {

        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(MathS.M.secret);
        }
    }

🎶（G）封装-静态类和静态构造函数

• 实践经验：
  
  1.静态类两大特点的底层原因：存储于静态存储区，所以和堆区栈区的操作就无关了
  2.静态构造函数的三大特点也是如此：三无，只构造静态变量，码字时就分配了空间

   static  class MathS //静态类测试
    {  
        static  float   CArea( float a ,float b)
        {
            return a * b;
        }
        static void Main(string[] args)
        {
            MathS.CArea(2.0f, 3.0f);
        }
    }
    class Self  //静态构造函数测试
    {
        static int a;
       static Self () 
        {
            a = 2;
        }       //现在已经赋值了
        Self () //此时还需实例化后才能赋值
        {
            a = 2;
        }
    }

🎶（H）封装-拓展方法

• 实践经验：
  
  1.声明定义的条件：无泛型的静态类中的静态方法
  2.声明时有参和无参在调用时的区别，和对于格式的理解
  static public void xx( this int yy)

  #region 拓展自杀的方法
    // class Player
    // {
    //     string name;
    //     int blood;
    //     int tacket;
    //     int defens;
    //     public void Hit()
    //     {

    //     }
    //     public void Move()
    //     {

    //     }
    //     public void Heart()
    //     {

    //     }
    // }
    //static  class Running
    // {
    //    static  public void KillSelf(this Player a)
    //     {
    //         Console.WriteLine("我自杀了");
    //     }
    //     static void Main(string[] args)
    //     {
    //         Player boss = new Player();
    //         boss.KillSelf();
    //     }
    // }

    #endregion
    #region      拓展求平方的方法

  static class Programe
    {

        static public int PinFan( this int A)
        {
            return (int)Math.Pow(A, 2);
        }

        static void Main(string[] args)
        {
            int a = 10;
           Console.WriteLine( a.PinFan());
        }

    }

    #endregion

🎶（III）封装-运算符重载

• 实践经验：
  
  1.熟悉怎么声明一个运算符重载的静态方法
  2.&&，|| ， = ，三目运算符等运算符无法重载，逻辑运算符需要成对的重载方法

 #region  _运算符重载 25题
 
    class Vector3
    {
        public int x, y, z;
        /// <summary>
        /// 三维向量得加法
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        static public Vector3 operator +(Vector3 a ,Vector3 b)
        {
            Vector3 c = new Vector3();
            c.x = a.x + b.x;
            c.y = a.y + b.y;
            c.z = a.z + b.z;
            return c;
        }
        /// <summary>
        /// 三维向量的减法
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        static  public Vector3  operator -(Vector3 a, Vector3 b)
        {
            Vector3 c = new Vector3();
            c.x = a.x - b.x;
            c.y = a.y - b.y;
            c.z = a.z - b.z;
            return c;
        }
        /// <summary>
        /// 三维向量的乘法
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        static public Vector3 operator -(Vector3 a, int b)
        {
            Vector3 c = new Vector3();
            c.x = a.x * b;
            c.y = a.y * b;
            c.z = a.z * b;
            return c;
        }
    }

    class Program
    {
        struct S_PD //用结构体定义的方式来实现运算符重载
        {
            public int x1, x2;
            static public bool operator +(S_PD a, S_PD b)
            {
                if (a.x1 == b.x1 && a.x2 == b.x2)
                {
                    return true;
                }
                return false;
            }
        }
        public int x1,x2;
        public static bool operator +( Program a ,  Program b)
            {        
            if (a.x1 == b.x1 && a.x2 == b.x2 ) return true;
            return false;
            }
        static void Main(string[] args)
        {
            Program a = new Program();
            Program b = new Program();
            S_PD A = new S_PD();
            S_PD B = new S_PD();
            a.x1 = 1; b.x1 = 1;
            a.x2 = 2; b.x2 = 2;
            A.x1 = 3; B.x1 = 4;
            A.x2 = 3; B.x2 = 1;
            Console.WriteLine(a + b);
            Console.WriteLine(A + B);

        }
    }
    #endregion

🎶（III）继承

• 实践经验：
  
  1.父类中私有的可以被继承但是不能被调用
  

  /// <summary>
    /// 人类
    /// </summary>
    class Person
    {
       public  String name;
       public  int Age { get; set; } 
       public  void Speak()
        {
            Console.WriteLine("我会说英语");
        }
    }
    /// <summary>
    /// 战士类继承人类
    /// </summary>
    class Fighter : Person 
    {
       public  void  attent()
        {
            Console.WriteLine("我具有攻击性");
        }
    }
    /// <summary>
    /// 主类
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            //第27题
            Fighter boss = new Fighter();
            boss.name = "牛魔王";
            boss.Age = 32;
            boss.Speak();
            boss.attent();
        }
    }

🎶（J） 继承-里氏替换原则

• 实践经验：
  
  1.父类装载子类，可以通过父类调用子类的方法（里氏替换原则）
  注意：装载后子类中能调用的只能是重写父类的方法
  2.is和as的使用（里氏替换原则）
  注意：用is判断之后，用子类对象装载as转换后的结果
  

  //29题
    /// <summary>
    /// 怪物基类
    /// </summary>
    class Monster
    {
        virtual public void attend()
        { }
    }
    /// <summary>
    /// 派生类boss类
    /// </summary>
    class Boss : Monster
    {
        override public void attend()
        {
            Console.WriteLine("Boss释放技能");
        }
    }
    /// <summary>
    /// 派生类小怪类
    /// </summary>
    class Goblin : Monster
    {
        override public void attend()
        {
            Console.WriteLine("Goblin普通攻击");
        }
    }
    /// <summary>
    /// 主类
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            //第28题 ： //is是类型所属判断操作符，as是引用类型转换操作符
            //第29题
            Random rand = new Random();
            int flag;
            Monster[] totall = new Monster[10];
            for (int i = 0; i < 10; i++)
            {
                if (rand.Next(2) == 1)
                {
                    totall[i] = new Boss(); //用父类装子类——里氏替换原则
                }
                else
                {
                    totall[i] = new Goblin();
                }
            }
            foreach (var item in totall)
            {
                item.attend();
                //as 和 is 的调用搭配
                //if (item is Boss) (item as Boss).attend();
                //else if (item is Goblin) (item as Goblin).attend();   
            }
        }
    }
    //30题 FPS游戏模拟
 //30题 FPS游戏模拟
    //武器类
    class Weapon
    {

    }
    //冲锋枪类
    class SubmachineGun : Weapon
    { }
    //散弹枪类
    class ShotGun:Weapon
    { }
    //手枪类
    class Pistol :Weapon
    { }
    //匕首类
    class Dagger:Weapon
    { }
    class Player
    {
        public Weapon knif;
        public Weapon Gun { get; set; }
        public Player() //默认武器为匕首
        {
            knif = new Dagger();
        }
        public void steadGun( Weapon gun) //替换武器
        {
            Gun = gun;
        }
    }

🎶（K）继承-构造函数

• 实践经验：
  
  1.继承时构造函数默认的调用顺序
  2.通过base 和 this 巧妙的调节继承时构造函数的 调用顺序
  

 /// <summary>
    /// 打工人基类
    /// </summary>
    class Worker
    {
    
        public String Jobs { get; set; }
        public String Contain { get; set; }
        virtual  public void Method() { } 
    }
    /// <summary>
    /// 程序员类
    /// </summary>
    class Programmer : Worker
    {
        public Programmer(String job,String contain )
        {
          
            Method();
        }
        public override void Method()
        {
            Console.WriteLine("我打代码");
        }
    }
    /// <summary>
    /// 策划类
    /// </summary>
    class Mastermind :Worker
    {
        public Mastermind(String job, String contain)
        {
            Jobs = job;
            Contain = contain;
            Method();
        }
        public override void Method()
        {
            Console.WriteLine("我搞策划");
        }
    }
    /// <summary>
    /// 美术类
    /// </summary>
    class Art:Worker
    {
        public Art(String job, String contain)
        {
            Jobs = job;
            Contain = contain;
            Method();
        }
        public override void Method()
        {
            Console.WriteLine("我美术设计");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Programmer garmmer = new Programmer("程序员","打代码");
            Mastermind master = new Mastermind("策划员", "搞策划");
            Art art = new Art("ui设计师", "美术设计");
        }
    }

🎶（L）继承-万物之父

• 实践经验：
  
  1.拆箱装箱的本质是值类型和引用类型的相互转换
  2.好处和坏处（有利于不确定对象的装载，但是跨存储区的转换消耗性能）
  

    //口头描述拆箱装箱：
    //1.装箱 ： 将值类型的对象装在Object基类（引用类型）中的行为叫装箱
    //2.拆箱 ： 将装好的Object对象进行强制转换成值类型的行为叫拆箱
    //
    class Program
    {
        static void Main(string[] args)
        {
            object god;
            int mm = 2;
            god = mm;//装箱
            //拆箱
            int zz = (int)god;
        }
    }

🎶（M）继承-综合练习

• 实践经验：
  
  1.当继承有参构造函数时直接用base关键字
  2.面向对象本质就是拿现实来看待问题。定义特征和抽象行为，从现实生活的角度用代码创造生活的一切
  

 /// <summary>
    /// 定义基类Person
    /// </summary>
    class Person
    {

     public  String name { get; set; }
     public Person ()
     {

     }
     public  Person (String name )
        {
            this.name = name;
        }
    }

    class Drive:Person //司机类
    {
     
    }
    class Passgener:Person//乘客类
    {

    }
    class Car
    {
         public int velocity; 
         public int number = 1;
        private int capacity { get; } = 20;
        private int maxVelocity { get; } = 200;
        public Person driver;
        public Person [] constorm  ;    
        public Car()
        {
            constorm = new Person[capacity];
            driver = new Person("张三");
            constorm[0] = driver;
        }
        public void GoCar(Person passenger)   //上车的行为
        {
            if(number<20)
            {
                Console.WriteLine("乘客上车");
                constorm[number++] = passenger;
            }
            else
            {
                Console.WriteLine("已满载！");
            }
        }
        public void ExitCar(Person passenger) //下车的行为
        {
            Console.WriteLine("乘客下车");
            constorm[number--] = null ;
        }
        public void Driving()                //开始行驶的行为
        {
            Console.WriteLine("车辆开始行驶");
            velocity = 20;
        }
        public void Accident()              //发生事故的行为      
        {
            Console.WriteLine("车辆发生事故");
            velocity = 0;
            number = 0;
        }
        public void StateCar()             //车辆情况汇报系统
        {
            Console.WriteLine("此时车辆的状况如下：\n车辆速度：{0}\n 车辆人数：{1}", velocity, number);
        }
    }
    /// <summary>
    /// 车辆新闻人播报
    /// </summary>
class NewsPeople
    {
        static void Main(string[] args)
        {
            Car BWM = new Car();
            BWM.GoCar(new Person ("郭富城"));
            BWM.Driving();
            BWM.StateCar();

        }
    }

🎶（N）多态

🎶（O）多态-虚方法，重写，base

• 实践经验：
  
  1.编译时的多态是重载
  2.运行时的多态是重写，虚方法，base，抽象类和抽象接口
  3.虚方法可选择性重写
  

  #region 1.鸭子的叫法，利用重写体现多态
    class Duck
    {
        virtual public void Speak() {  }
    }
    class RealDuck:Duck
    {
        override public void Speak()
        {
            Console.WriteLine("嘎");
        }
    }
    class WoodDuck:Duck
    {
        override public void Speak()
        {
            Console.WriteLine("吱");
        }
    }
    class RubberDuck:Duck
    {
        override public void Speak()
        {
            Console.WriteLine("叽");
        }
    }
    #endregion
    #region 2.员工打卡，利用重写体现多态
    class Worker
    {
        virtual public void Sign()
        {
            Console.WriteLine("我是员工九点打卡");
        }
       
    }
    class Massger:Worker
    {
        override public void Sign()
        {
            Console.WriteLine("我是经理十一点打卡");
        }
    }
    class Programme:Worker
    {
        override public void Sign()
        {
            Console.WriteLine("我是程序员我不打卡");
        }
    }
    #endregion
    #region 3.利用重载体现多态
    class Graphic
    {
       virtual  public void Area() { }
       virtual  public void Circumference() { }
    }
    class Rectangle:Graphic 
    {
         public int Area(int heiht,int wigth)
        {
            return heiht * wigth;
        }
        public  int  Circumference(int heiht, int wigth)
        {
            return 2 * (heiht + wigth);
        }
    }
    class Round : Graphic
    {
        public float  Area(int Side)
        {
            return 2 * 3.14f * Side;
        }
        public float  Circumference(int Side)
        {
            return (float )Math.Pow(Side, 2)*3.14f;
        }
    }
    class Square :Graphic
    {
        public int Area(int Radius)
        {
          return (int)Math.Pow(Radius , 2);
        }
        public int  Circumference(int Radius)
        {
            return 4 * Radius;
        }
        class Progeam
        {
            static void Main(string[] args)
            {
                Rectangle MM = new Rectangle();
                Square NN = new Square();
                Round OO = new Round();
                Console .WriteLine ("矩形的面积为："+ MM.Area(2, 3));
                Console.WriteLine("矩形的周长为："+MM.Circumference(2, 3));
            }
        }
    }
    #endregion

🎶（P）多态-抽象类和抽象方法

• 实践经验：
  
  1.抽象类抽象方法必须被重写，抽象方法没有函数体
  2.抽象类不能被实例化但是遵从里氏替换原则
  3.什么时候用抽象类，比如动物类，图形类这种抽象未落地的事务就可以用抽象类

#region 动物抽象类
    abstract class Animal
    {
        abstract public void Speak();
    }
    class Person:Animal
    {
        public override void Speak()
        {
            Console.WriteLine("你干嘛"); 
        }

    }
    class Dog:Animal 
    {
        public override void Speak()
        {
            Console.WriteLine("汪汪汪");
        }
    }
    class Cat:Animal
    {
        public override void Speak()
        {
            Console.WriteLine("喵喵喵");
        }
    }
    #endregion
    #region 图形类
   abstract  class Circle
    {
        //抽象函数不能有方法体，并且是公共的
        abstract public int Area(int a ,int b);
        abstract public int Perimeter(int a,int b);
    }
    class Rectangle :Circle
    {
        public override int Area(int a,int b)
        {
            return a * b;
           
        }
        public override int Perimeter(int a,int b)
        {
            return 2 * (a + b);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //抽象类存在里氏替换原则
            Circle Round = new Rectangle();
            Dog Hashiqi = new Dog();
            Console.WriteLine(Round.Area(1, 3));
        }
    }
    #endregion

🎶（Q）多态-接口

• 实践经验：
  
  1.接口中只能有（无函数体的方法，属性，事件。索引器）
  2.接口方法不需要public修饰，它默认就是public
  3.接口就是抽象一个共用的功能，谁继承即可学习（相当于恶魔果实）
  4.接口继承接口不用全部实现其中成员
  5.接口用里氏替换原则做父类装class
  
  

   #region 继承登记功能接口
    interface IRigster
    {
        //接口中不含变量可包含，无函数体的方法，属性，索引器，事件
        //接口方法不需要public修饰，它默认的就是pulic
        void RigsterMessage(); 
    }
    class Person : IRigster
    {
        public void RigsterMessage()
        {
            Console.WriteLine("派出所登记");    
        }
    }
    class Hourse : IRigster
    {
        public void RigsterMessage()
        {
            Console.WriteLine("房管局登记");
        }
    }
    class Car : IRigster
    {
        public void RigsterMessage()
        {
            Console.WriteLine("车管所登记");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //利用里氏替换原则
            IRigster[] Rigster = new IRigster[3] { new Person(), new Hourse(), new Car() };
            for (int i = 0; i < Rigster.Length ; i++)
            {
                Rigster[i].RigsterMessage();
            }
        }
    }
    #endregion
    #region 继承飞行，游泳，走路的功能接口
    interface IFly
    {
        void Flay();
    }
    interface ISwim
    {
        void Swim();
    }
    interface IWalk
    {
        void Walk();
    }
    abstract class Bird : IFly, IWalk
    {
        abstract public void Flay();


        abstract public void Walk();

    }
    class MaQue : Bird
    {
        public override void Flay()
        {
            Console.WriteLine("我是麻雀可以飞");
        }

        public override void Walk()
        {
            Console.WriteLine("我是麻雀也可以走");
        }
    }
    class YinWU : Bird
    {
        public override void Flay()
        {
            Console.WriteLine("我是鹦鹉可以飞");
        }

        public override void Walk()
        {
            Console.WriteLine("我是鹦鹉也可以走");
        }
    }
    class TiamE : Bird, ISwim
    {
        public override void Flay()
        {
            Console.WriteLine("我是天鹅可以飞");
        }

        public void Swim()
        {
            Console.WriteLine("我可以游泳");
        }

        public override void Walk()
        {
            throw new NotImplementedException();
        }
    }
    class TuoNiao : IWalk
    {
        public void Walk()
        {
            Console.WriteLine("我可以走");
        }
    }
    class QIE : IWalk
    {
        public void Walk()
        {
            Console.WriteLine("我可以走");
        }
    }
    class Plan : IFly
    {
        public void Flay()
        {
            Console.WriteLine("我可以飞");
        }
    }
    #endregion

  interface IUSB
    {
        void ReadState();
    }

    class MoveSave : IUSB
    {
        private string name;

      public   MoveSave (string name )
        {
            this.name = name;
        }
        public void ReadState()
        {
            Console.WriteLine(name +"可以进行传输");
        }
    }
    class MP3 : IUSB
    {
        public void ReadState()
        {
            Console.WriteLine("可以进行传输了");
        }
    }
    class Computer 
    {
        public IUSB flacity;  //传输接口作为变量
  
    }
    class Program
    {
        static void Main(string[] args)
        {
            MoveSave USave = new MoveSave("U盘");
            MoveSave Msove = new MoveSave("移动硬盘");
            MP3 Xmp3 = new MP3();
            Computer XMi = new Computer();
            XMi.flacity = USave;  //里氏替换原则,接口作为父类装了类的子类
            XMi.flacity.ReadState();

        }
    }

🎶（R）面向对象相关-命名空间

• 实践经验：
  
  1.要引用其他项目的命名空间时，在解决方案中添加需要项目的引用
  2.相同命名空间有同名类时用命名空间+”."的格式进行区分

//当引用其他项目的命名空间时
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UI;
using Graph;
namespace _命名空间Text
{
    class Program
    {
        static void Main(string[] args)
        {
               UI.Image a = new UI.Image();
            Graph.Image b = new Graph.Image();
        }
    }
}

🎶（S）面向对象相关-Object的方法

• 实践经验：
  
  1.七个方法：两个静态方法（判断两个对象，判断两个引用对象）
  两个普通方法（得到运行时返回的类型，浅拷贝引用对象）
  三个虚方法（自定义判断规则，自定义返回的Tostring，自定义返回的哈希码）
  2.以下是虚方法重写制定Tostring 和 浅拷贝引用对象（A变B不变）
  

  class Player
    {
        string name;
        int blood;
        int attack;
        int defens;
        //重写万物之父中的ToString方法
        public override string ToString()
        {
            return "玩家"+name+"血量"+blood+"攻击力"+attack+"防御力"+defens;
        }
    }
    class Monster
    {
     public   int attack = 10;
        int defend = 20;
        int blood = 30 ;   

        public object Man()
        {
            return new Monster().MemberwiseClone();
            //适合给引用对象实施浅拷贝——A变B不变
        }
        public void print()
        {
            Console.WriteLine(attack +" "+defend+" "+blood );
        }
    }
    class Program
    {
       static void Main(string[] args)
       {
           // Player text = new Player();
           // Console.WriteLine(text.ToString());
            Monster A = new Monster();
            Monster B = A.Man() as Monster ; //as比（）更安全-引用对象
            B.attack = 30;
            B.print();
            A.print();  
       }  
    }

🎶（T）面向对象相关-String

• 实践经验：
  
  1.七个API：拼接Format，替换Replace，截取Substring，移除Remove，查找Indexof，切割Split，大小写转换ToUpper/Tolower
  2.String是特殊的引用类型，你变它不变，原因是它已经自己来开辟了空间
  3.使用拼接一般会在堆里面开辟三个空间
  4，所以它的缺点就是多次赋值开辟空间浪费了空间
  
• 第50题： 开辟了3个堆的空间（= null的时候不开辟，“123”是存在常量池中）
• 第49题： String和string,int32和int 前者是Framwork当中的类，后者可以映射成为前者，最好写后者

        //string中的截取方法：a.Split();
        //string中的替换方法：a.replace();
        //string中的移除方法：a.Remove();
        //string中的拼接方法：String.Format();

        //
        static void Main(string[] args)
        {
            string a = "1|2|3|4|5|6|7";
            string [] b = a.Split('|');
            string c = "";
            
          
            for (int i = 0; i < b.Length ; i++)
            {
                b[i] = (int.Parse(b[i])+1).ToString() ;
                if(i < b.Length )
               c= string.Format("{0}{1}{2}",c,b[i],'|');
        }


            Console.WriteLine(c);
        }

🎶（U）面向对象相关-优化内存

• 减少new的使用
• 减少GC回收机制的运行
• 合理使用static（static与程序同生共死，不会受GC回收影响）
• 合理的使用String 和StringBuilder

⭐相关文章⭐

⭐本站最全-unity常用API大全（万字详解），不信你不收藏

⭐【2023unity游戏制作-mango的冒险】-4.场景二的镜头和法球特效跟随

⭐“狂飙”游戏制作—游戏分类图鉴（网易游学）

你们的点赞👍 收藏⭐ 留言📝 关注✅是我持续创作，输出优质内容的最大动力！文章来源地址https://www.toymoban.com/news/detail-452541.html

到了这里，关于【Unity之c#专题篇】—核心章题单实践的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！