由浅拷贝讨论到深拷贝再讨论到接口(二):针对接口编程

继续上篇文章，把一个对象a深拷贝给对象b，我们采用继承ICloneable接口来实现。

 

（一）有人就要问了：为什么要继承这个接口？我自己写个方法，也能实现深拷贝。

    public class Clone
    {
        //这是一个Framework层级的方法,旨在通用,当传入一个对象时,能返回这个对象的深拷贝.
        public object DeepClone(object objA)
        {
            object objB = new object();
            //具体实现仁者见仁智者见智,笔者就不献丑了.
            objB = objA;
            return objB;
        }
    }

然后这样调用：

            School a = new School();
            a.Id = 1;
            a.Name = "A school";
            a.Student.Name = "Li lei";

            Clone clone = new Clone();
            School b = (School)clone.DeepClone(a);//深拷贝

完整代码如下：

using System;

 namespace NY
{
    class Program
    {
        static void Main(string[] args)
        {
            School a = new School();
            a.Id = 1;
            a.Name = "A school";
            a.Student.Name = "Li lei";

            Clone clone = new Clone();
            School b = (School)clone.DeepClone(a);//深拷贝
         }
    }

    public class Clone
    {
        //这是一个Framework层级的方法,旨在通用,当传入一个对象时,能返回这个对象的深拷贝.
         public object DeepClone(object objA)
        {
            object objB = new object();
            //具体实现仁者见仁智者见智,笔者就不献丑了.
             objB = objA;
            return objB;
        }
    }

    public class School
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public Student Student { get; set; }

        public School()
        {
            this.Student = new Student();
        }
    }

    public class Student
    {
        public string Name { get; set; }
    }
}
 

最后，Clone类编写者发出邮件：
早上好！我在Framework层新增了Clone类，里面有个方法是DeepClone，实现了深拷贝。

大家调用的很欢快，一切看上去其乐融融。

（二）针对接口编程，可以解决依赖性等待。
继续上例，由alex担任前台编写，michael担任Clone类编写。那么，在miclael没写好这个类之前，alex写的这段代码：Clone clone = new Clone();是编译不过的。于是，整个项目miclael成了关键路径，所有人都在等待他的完成才能继续手上的工作。怎么办？针对接口编程。

我们先写好一个接口：

    public interface IClone
    {
        object DeepClone(object objA);
    }

 

然后alex就可以针对接口编程了

            School a = new School();
            a.Id = 1;
            a.Name = "A school";
            a.Student.Name = "Li lei";

            IClone clone = new Clone();//针对接口编程
            School b = (School)clone.DeepClone(a);//深拷贝

michael压力也没那么大了，他可以慢慢开发Clone类 

    public class Clone : IClone
    {

        public object DeepClone(object objA)
        {
            object objB = new object();
            //michale窃喜:我慢慢的想~我慢慢的想~
            objB = objA;
            return objB;
        }
    }

 

完整代码如下：

using System;

 namespace NY
{
    class Program
    {
        static void Main(string[] args)
        {
            School a = new School();
            a.Id = 1;
            a.Name = "A school";
            a.Student.Name = "Li lei";

            IClone clone = new Clone();//针对接口编程
             School b = (School)clone.DeepClone(a);//深拷贝
         }
    }

    public interface IClone
    {
        object DeepClone(object objA);
    }

    public class Clone : IClone
    {
        //这是一个Framework层级的方法,旨在通用,当传入一个对象时,能返回这个对象的深拷贝.
         public object DeepClone(object objA)
        {
            object objB = new object();
            //michale窃喜:我慢慢的想~我慢慢的想~
             objB = objA;
            return objB;
        }
    }

    public class School
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public Student Student { get; set; }

        public School()
        {
            this.Student = new Student();
        }
    }

    public class Student
    {
        public string Name { get; set; }
    }
}
 

大家编写的很欢快，一切又其乐融融。

（三）针对接口编程，可以实现松耦合--对修改关闭对扩展开放。
我们的产品终于销售出去了，可是好景不长，A客户对我们的产品很满意，可是B客户却有着自己的特殊要求，使得我们不得不改造DeepClone方法。
但，此时，我们很高兴，因为我们不用改造DeepClone方法，那么，怎么做？

新建个类CloneForB，实现IClone接口。

    public class CloneForB : IClone
    {
        public object DeepClone(object objA)
        {
            object objB = new object();
            objB = objA;
            return objB;
        }

    }

alex部分的代码修改如下：

        IClone clone = GetClone();//针对接口编程

        private static IClone GetClone()
        {
            if(...) return new Clone();   
            if(...) return new CloneForB();  
        }

 

完整代码如下：

using System;

 namespace NY
{
    class Program
    {
        static void Main(string[] args)
        {
            School a = new School();
            a.Id = 1;
            a.Name = "A school";
            a.Student.Name = "Li lei";

            IClone clone = GetClone();//针对接口编程
             School b = (School)clone.DeepClone(a);//深拷贝
        }

        private static IClone GetClone()
        {
            if(...) return new Clone();   
            if(...) return new CloneForB();  
        }
    }

    public interface IClone
    {
        object DeepClone(object objA);
    }

    public class Clone : IClone
    {
        public object DeepClone(object objA)
        {
            object objB = new object();
            objB = objA;
            return objB;
        }
    }

    public class CloneForB : IClone
    {
        public object DeepClone(object objA)
        {
            object objB = new object();
            objB = objA;
            return objB;
        }

    }

    public class School
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public Student Student { get; set; }

        public School()
        {
            this.Student = new Student();
        }
    }

    public class Student
    {
        public string Name { get; set; }
    }
}

 

如果是B客户，我们就跳到了为B客户新写的类中，这样，就避免了原来的Clone类遭到破坏。

（四）恭喜你！你已经一步步被笔者带入了面向对象编程的世界
  (1)  OOP设计原则--针对接口编程
  (2)  设计模式--工厂模式

（五）写在最后
写到这里，笔者陆陆续续收到各位高手对于上篇博文的回复，深受领教，原来实现深拷贝还有那么多种方式。原本还想推荐ICloneable接口的~笔者这篇博文的目的：介绍针对接口编程，已经完成了，那么就此而止吧。但，笔者会有后续博文，为大家介绍其他实现深拷贝的方式，敬请期待！