24.万物之父中的方法

CSharp > CSharp核心 > CSharp核心语法知识 CSharp 语法知识 CSharp核心 面向对象关联知识点
发布时间 :
字数:3.6k 阅读 : 评论:
  1. 24.面向对象关联知识点-万物之父中的方法
    1. 24.1 知识点
      1. 知识回顾
      2. 辅助举例的测试类
      3. object中的主要成员图示
      4. object中的静态方法
        1. 主函数内
          1. 静态方法 Equals
          2. 静态方法 ReferenceEquals
      5. object中的成员方法
        1. 主函数内
          1. 普通方法 GetType
          2. 普通方法 MemberwiseClone
      6. object中的虚方法
        1. 主函数内
          1. 虚方法 Equals
          2. 虚方法 GetHashCode
          3. 虚方法 ToString
      7. 总结
    2. 24.2 知识点代码
    3. 24.3 练习题
      1. 有一个玩家类，有姓名，血量，攻击力，防御力，闪避率等特征。请在控制台打印出“玩家XX，血量XX，攻击力XX，防御力XX”XX为具体内容
      2. 一个Monster类的引用对象A，Monster类有 攻击力、防御力、血量、技能ID等属性。我想复制一个和A对象一模一样的B对象。并且改变了B的属性，A不会受到影响。请问如何实现？
    4. 24.4 练习题代码

24.面向对象关联知识点-万物之父中的方法

24.1 知识点

知识回顾

  • 万物之父 object
  • 所有类型的基类是一个引用类型
  • 利用里氏替换原则可以装载一切对象
  • 存在装箱拆箱

辅助举例的测试类

class Test
{
    // Test中的值类型变量
    public int testInt = 1;
    
    // Test中的引用类型变量
    public MyTest mytest = new MyTest();

    // Object的成员方法

    // MemberwiseClone()在object中是保护类型的，用public包裹一层，在外部测试
    public Test Clone()
    {
        // MemberwiseClone()会返回自己类的一个对象，as转成自己类后返回，用于测试
        return MemberwiseClone() as Test;
    }

    // object中的虚方法

    // 重写Object虚方法Equals(object obj)
    public override bool Equals(object obj)
    {
        return base.Equals(obj);
    }

    // 重写Object虚方法GetHashCode()
    public override int GetHashCode()
    {
        return base.GetHashCode();
    }

    // 重写Object虚方法ToString()
    public override string ToString()
    {
        return "林文韬申明的Test类";
    }
}

class MyTest
{
    public int myTestInt = 2;
}

object中的主要成员图示

object中的静态方法

主函数内

静态方法 Equals
// 判断两个对象是否相等
// 最终的判断权，交给左侧对象的Equals方法，
// 不管值类型还是引用类型都会按照左侧对象Equals方法的规则来进行比较

// Object.Equals(,) 省略Object.也可以，因为class Program也默认继承Object类
Console.WriteLine(Equals(1, 1)); // True

// 值类型直接比较值
Console.WriteLine(Object.Equals(1, 1)); // True
Console.WriteLine(Object.Equals(1, 2)); // False

Test t1 = new Test();
Test t2 = t1;
Test t3 = new Test();

// 引用类型比较的是栈中存的地址，地址相同返回True，否则返回False
Console.WriteLine(Object.Equals(t1, t2)); // True
Console.WriteLine(Object.Equals(t1, t3)); // False
静态方法 ReferenceEquals
// 比较两个对象是否是相同的引用，主要是用来比较引用类型的对象。
// 值类型对象返回值始终是False。
Console.WriteLine(Object.ReferenceEquals(1, 1)); // False，值类型对象返回值始终是False
Console.WriteLine(Object.ReferenceEquals(t1, t2)); // True
Console.WriteLine(Object.ReferenceEquals(t1, t3)); // False

object中的成员方法

主函数内

普通方法 GetType
// 该方法在反射相关知识点中是非常重要的方法，之后我们会具体的讲解这里返回的Type类型。
// 该方法的主要作用就是获取对象运行时的类型Type，
// 通过Type结合反射相关知识点可以做很多关于对象的操作。
Test t4 = new Test();
Type type = t4.GetType();
普通方法 MemberwiseClone
// 该方法用于获取对象的浅拷贝对象，口语化的意思就是会返回一个新的对象，
// 但是新对象中的引用变量会和老对象中一致。

Test t5 = t4.Clone();

Console.WriteLine("克隆对象后");
Console.WriteLine("t4.testInt = " + t4.testInt);
Console.WriteLine("t4.mytest.testInt = " + t4.mytest.myTestInt);
Console.WriteLine("t5.testInt = " + t5.testInt);
Console.WriteLine("t5.mytest.myTestInt = " + t5.mytest.myTestInt);

// 观察克隆出来的对象 发现
// 改变对象中的值类型变量时，被克隆对象的对应值类型变量不会变
// 改变对象中的引用类型变量，被克隆对象的对应引用类型变量会变
// 新对象中的引用变量会和老对象中一致，指向同一个地址

t5.testInt = 20;
t5.mytest.myTestInt = 21;

Console.WriteLine("改变克隆体信息后");
Console.WriteLine("t4.testInt = " + t4.testInt);
Console.WriteLine("t4.mytest.testInt = " + t4.mytest.myTestInt);
Console.WriteLine("t5.testInt = " + t5.testInt);
Console.WriteLine("t5.mytest.myTestInt = " + t5.mytest.myTestInt);

object中的虚方法

主函数内

虚方法 Equals
// 默认实现还是比较两者是否为同一个引用，即相当于ReferenceEquals。
// 但是微软在所有值类型的基类System.ValueType中重写了该方法，用来比较值相等。
// 我们也可以重写该方法，定义自己的比较相等的规则
虚方法 GetHashCode
// 该方法是获取对象的哈希码
// （一种通过算法算出的，表示对象的唯一编码，不同对象哈希码有可能一样，具体值根据哈希算法决定），
// 我们可以通过重写该函数来自己定义对象的哈希码算法，正常情况下，我们使用的极少，基本不用。
虚方法 ToString
// 该方法用于返回当前对象代表的字符串，我们可以重写它定义我们自己的对象转字符串规则，
// 该方法非常常用。当我们调用打印方法时，默认使用的就是对象的ToString方法后打印出来的内容。

// 不重写类的ToString方法，直接输出对象时，默认打印 命名空间.类名
Random r = new Random();
Console.WriteLine(r); // System.Random

// 重写类的ToString方法后，打印出什么可以自定义
Console.WriteLine(t5);

 // 林文韬申明的Test类

总结

按重要性排序，其他了解即可

  • 虚方法 ToString 自定义字符串转换规则
  • 成员方法 GetType 反射相关
  • 成员方法 MemberwiseClone 浅拷贝
  • 虚方法 Equals 自定义判断相等的规则

24.2 知识点代码

using System;

namespace Lesson22_面向对象相关_万物之父中的方法
{
    #region 辅助举例的 测试类
    class Test
    {
        //Test中的值类型变量
        public int testInt = 1;
        //Test中的引用类型变量
        public MyTest mytest = new MyTest();



        //Object的成员方法

        //MemberwiseClone()在object中是保护类型的 用public包裹一层 在外部测试
        public Test Clone()
        {
            // MemberwiseClone()会返回自己类的一个对象 as转成自己类后返回 用于测试
            return MemberwiseClone() as Test;
        }


        //object中的虚方法

        //重写Object虚方法Equals(object obj)
        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }

        //重写Object虚方法 GetHashCode()
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
        //重写Object虚方法 ToString()
        public override string ToString()
        {
            return "林文韬申明的Test类";
        }
    }
    class MyTest
    {
        public int myTestInt = 2;
    }

    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("万物之父中的方法");

            #region 知识回顾
            //万物之父 object
            //所有类型的基类 是一个引用类型
            //可以利用里氏替换原则装载一切对象
            //存在装箱拆箱
            #endregion

            //主函数内

            #region 知识点一 object中的静态方法

            //静态方法 Equals 判断两个对象是否相等
            //最终的判断权，交给左侧对象的Equals方法，
            //不管值类型引用类型都会按照左侧对象Equals方法的规则来进行比较

            //Object.Equals(,) 省略Object.也可以 因为class Program也默认继承Object类
            Console.WriteLine(Equals(1, 1));//True

            //值类型直接比较值
            Console.WriteLine(Object.Equals(1, 1));//True
            Console.WriteLine(Object.Equals(1, 2));//False

            Test t1 = new Test();
            Test t2 = t1;
            Test t3 = new Test();

            //引用类型比较的是栈中存的地址 地址相同返回True 否则返回False
            Console.WriteLine(Object.Equals(t1, t2));//True
            Console.WriteLine(Object.Equals(t1, t3));//False

            //静态方法ReferenceEquals
            //比较两个对象是否是相同的引用，主要是用来比较引用类型的对象。
            //值类型对象返回值始终是False。
            Console.WriteLine(Object.ReferenceEquals(1, 1));//False 值类型对象返回值始终是False
            Console.WriteLine(Object.ReferenceEquals(t1, t2));//True
            Console.WriteLine(Object.ReferenceEquals(t1, t3));//False

            #endregion

            #region 知识点二 object中的成员方法

            //普通方法GetType
            //该方法在反射相关知识点中是非常重要的方法，之后我们会具体的讲解这里返回的Type类型。
            //该方法的主要作用就是获取对象运行时的类型Type，
            //通过Type结合反射相关知识点可以做很多关于对象的操作。
            Test t4 = new Test();
            Type type = t4.GetType();


            //普通方法MemberwiseClone
            //该方法用于获取对象的浅拷贝对象，口语化的意思就是会返回一个新的对象，
            //但是新对象中的引用变量会和老对象中一致。

            Test t5 = t4.Clone();

            Console.WriteLine("克隆对象后");
            Console.WriteLine("t4.testInt = " + t4.testInt);
            Console.WriteLine("t4.mytest.testInt = " + t4.mytest.myTestInt);
            Console.WriteLine("t5.testInt = " + t5.testInt);
            Console.WriteLine("t5.mytest.myTestInt = " + t5.mytest.myTestInt);
            //克隆对象后
            //t4.testInt = 1
            //t4.mytest.testInt = 2
            //t5.testInt = 1
            //t5.mytest.myTestInt = 2


            t5.testInt = 20;
            t5.mytest.myTestInt = 21;

            Console.WriteLine("改变克隆体信息后");
            Console.WriteLine("t4.testInt = " + t4.testInt);
            Console.WriteLine("t4.mytest.testInt = " + t4.mytest.myTestInt);
            Console.WriteLine("t5.testInt = " + t5.testInt);
            Console.WriteLine("t5.mytest.myTestInt = " + t5.mytest.myTestInt);
            //改变克隆体信息后
            //t4.testInt = 1
            //t4.mytest.testInt = 21
            //t5.testInt = 20
            //t5.mytest.myTestInt = 21

            //观察克隆出来的对象 发现
            //改变对象中的值类型变量时 被克隆对象的对应值类型变量不会变
            //改变对象中的引用类型变量 被克隆对象的对应引用类型变量会变
            //新对象中的引用变量会和老对象中一致 指向同一个地址
            #endregion

            #region 知识点三 object中的虚方法

            //虚方法Equals
            //默认实现还是比较两者是否为同一个引用，即相当于ReferenceEquals。
            //但是微软在所有值类型的基类System.ValueType中重写了该方法，用来比较值相等。
            //我们也可以重写该方法，定义自己的比较相等的规则

            //虚方法GetHashCode
            //该方法是获取对象的哈希码
            //（一种通过算法算出的，表示对象的唯一编码，不同对象哈希码有可能一样，具体值根据哈希算法决定），
            //我们可以通过重写该函数来自己定义对象的哈希码算法，正常情况下，我们使用的极少，基本不用。

            //虚方法ToString
            //该方法用于返回当前对象代表的字符串，我们可以重写它定义我们自己的对象转字符串规则，
            //该方法非常常用。当我们调用打印方法时，默认使用的就是对象的ToString方法后打印出来的内容。

            //不重写类的ToString方法 直接输出对象时 默认打印 命名空间.类名
            Random r = new Random();
            Console.WriteLine(r);//System.Random
            //重写类的ToString方法后 打印出什么可以自定义
            Console.WriteLine(t5);//林文韬申明的Test类

            #endregion
        }
    }

    //总结

    //按重要性排序
    //1.虚方法 toString 自定字符串转换规则
    //2.成员方法 GetType 反射相关
    //3.成员方法 MemberwiseClone 浅拷贝
    //4.虚方法 Equals 自定义判断相等的规则
    //其他了解即可
}

24.3 练习题

有一个玩家类，有姓名，血量，攻击力，防御力，闪避率等特征。请在控制台打印出“玩家XX，血量XX，攻击力XX，防御力XX”XX为具体内容

class语句块外 namespace语句块内

// 玩家类
class Player
{
    private string name;
    private int hp;
    private int atk;
    private int def;
    private int miss;

    public Player(string name, int hp, int atk, int def, int miss)
    {
        this.name = name;
        this.hp = hp;
        this.atk = atk;
        this.def = def;
        this.miss = miss;
    }

    // 重写ToString
    public override string ToString()
    {
        return string.Format("玩家{0},血量{1},攻击力{2},防御力{3},闪避{4}", name, hp, atk, def, miss);
    }
}

主函数内

// 主函数内
Player player = new Player("林文韬", 100, 10, 5, 20);
// Player类内重写了ToString
Console.WriteLine(player);//玩家林文韬,血量100,攻击力10,防御力5,闪避20

一个Monster类的引用对象A，Monster类有 攻击力、防御力、血量、技能ID等属性。我想复制一个和A对象一模一样的B对象。并且改变了B的属性，A不会受到影响。请问如何实现？

class语句块外 namespace语句块内

// 怪物类
class Monster
{
    public Monster(int atk, int def, int hp, int skillID)
    {
        Atk = atk;
        Def = def;
        Hp = hp;
        SkillID = skillID;
    }

    public int Atk
    {
        get;
        set;
    }

    public int Def
    {
        get;
        set;
    }

    public int Hp
    {
        get;
        set;
    }

    public int SkillID
    {
        get;
        set;
    }

    // 攻击力、防御力、血量、技能ID都是值类型 使用浅拷贝MemberwiseClone拷贝对象 改变其他对象的属性不会有影响
    public Monster Clone()
    {
        return MemberwiseClone() as Monster;
    }

    // 重写ToString
    public override string ToString()
    {
        return string.Format("攻击力{0},防御力{1},血量{2},技能{3}", Atk, Def, Hp, SkillID);
    }
}

主函数内

// 主函数内
Monster monster1 = new Monster(10, 20, 100, 1);
Monster monster2 = monster1.Clone();
monster2.Atk = 30;
monster2.SkillID = 100;
Console.WriteLine(monster1);//攻击力10,防御力20,血量100,技能1
Console.WriteLine(monster2);//攻击力30,防御力20,血量100,技能100

24.4 练习题代码

using System;

namespace Lesson22_练习题
{
    //class语句块外 namespace语句块内

    #region 练习题一
    //有一个玩家类，有姓名，血量，攻击力，防御力，闪避率等特征
    //请在控制台打印出“玩家XX，血量XX，攻击力XX，防御力XX”XX为具体内容

    //玩家类
    class Player
    {
        private string name;
        private int hp;
        private int atk;
        private int def;
        private int miss;

        public Player(string name, int hp, int atk, int def, int miss)
        {
            this.name = name;
            this.hp = hp;
            this.atk = atk;
            this.def = def;
            this.miss = miss;
        }

        //重写ToString
        public override string ToString()
        {
            return string.Format("玩家{0},血量{1},攻击力{2},防御力{3},闪避{4}", name, hp, atk, def, miss);
        }
    }
    #endregion

    #region 练习题二
    //一个Monster类的引用对象A，Monster类有 攻击力、防御力、血量、技能ID等属性。
    //我想复制一个和A对象一模一样的B对象。并且改变了B的属性，A不会受到影响。请问如何实现？

    //怪物类
    class Monster
    {
        public Monster(int atk, int def, int hp, int skillID)
        {
            Atk = atk;
            Def = def;
            Hp = hp;
            SkillID = skillID;
        }

        public int Atk
        {
            get;
            set;
        }

        public int Def
        {
            get;
            set;
        }
        public int Hp
        {
            get;
            set;
        }
        public int SkillID
        {
            get;
            set;
        }

        //攻击力、防御力、血量、技能ID都是值类型 使用浅拷贝MemberwiseClone拷贝对象 改变其他对属性不会有影响
        public Monster Clone()
        {
            return MemberwiseClone() as Monster;
        }

        //重写ToString
        public override string ToString()
        {
            return string.Format("攻击里{0},防御力{1},血量{2},技能{3}", Atk, Def, Hp, SkillID);
        }
    }
    #endregion
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("万物之父中的方法");
            //主函数内

            #region 练习题一

            Player player = new Player("林文韬", 100, 10, 5, 20);
            //Player类内重写了ToString
            Console.WriteLine(player);//玩家林文韬,血量100,攻击力10,防御力5,闪避20

            #endregion

            #region 练习题二


            Monster monster1 = new Monster(10, 20, 100, 1);
            Monster monster2 = monster1.Clone();
            monster2.Atk = 30;
            monster2.SkillID = 100;
            Console.WriteLine(monster1);//攻击里10,防御力20,血量100,技能1
            Console.WriteLine(monster2);//攻击里30,防御力20,血量100,技能100

            #endregion
        }
    }
}
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com

赏

©2016-2024 Tao

Built with Hexo and 3-hexo theme

×

喜欢就点赞,疼爱就打赏