虚拟机的复制：直接在要复制的虚拟机存储文件夹下复制一个副本，更改副本名称，并使用VMware等相关软件打开，先不要开启，重命名好虚拟机，然后启动虚拟机，更改配置
 
复制虚拟机
 
复制虚拟机
 
使用已装备好的一台虚拟机，这里用的是master001号虚拟机
 进入master001的存储文件夹，复制四个副本（本人练习需要，大家可以只复制一个副本），作为新的虚拟机，修改四个新虚拟机的名称并用VMware打开
 
 通过选择“我已复制该虚拟机”来告诉VMware平台“我这台虚拟机需要生成一个新的MAC地址”，如果选择其他，则无法生成新的MAC地址
 
 
修改虚拟配置
 
查看MAC地址
 
cat /etc/udev/rules.d/70-persistent-net.rules
 
最后一条为最新的MAC地址，并记住ATTR和NAME的值
 
 
修改MAC地址和IP地址
 
需要到profile文件中修改最新的MAC地址和网络名称
 
vi /etc/sysconfig/network-scripts/ifcfg-eth0		//未修改前的“eth0”未更改
 
 
修改主机名
 
vi /etc/sysconfig/network
//改写：
HOSTNAME=master002
//重启使修改生效
reboot
 
验证修改成功
 
使用ifconfig命令
 
 修改成功
 
虚拟机的快照：快照是数据存储的某一时刻的状态记录，需要进行克隆
 
拍摄快照
 
打开VMware，在菜单项选择自己需要复制的虚拟机，不要开机，右键点击或者在菜单栏点击虚拟机选择快照，再点击拍摄快照
 
 编辑快照名称并保存，这就是一个快照文件了。快照还需要用克隆来组建一个完整的虚拟机，虚拟机的克隆可以看接下来的操作。
 
 
虚拟机的克隆：使用快照制作一台虚拟机，有两种选择：一种是依赖于拍摄快照的源虚拟机；一种是完全独立的“副本”
 
克隆虚拟机
 
步骤如下图：
 
 
 点击完成后就有一个系的虚拟机的，按照分类来开启虚拟机
 同一个虚拟机不能有一样的IP地址，所以需要更改虚拟机配置
 
修改虚拟配置
 
查看MAC地址
 
cat /etc/udev/rules.d/70-persistent-net.rules
 
最后一条为最新的MAC地址，并记住ATTR和NAME的值
 
 
修改MAC地址和IP地址
 
需要到profile文件中修改最新的MAC地址和网络名称
 
vi /etc/sysconfig/network-scripts/ifcfg-eth0		//未修改前的“eth0”未更改
 
 
修改主机名
 
vi /etc/sysconfig/network
//改写：
HOSTNAME=master002
//重启使修改生效
reboot
 
验证修改成功
 
使用ifconfig命令
 
 修改成功

1 ，速度问题 ：
 
我们知道，手动安装 linux 系统需要耗费很多时间，所以，平时，我们在学习中，一半采用复制和克隆的方式来创建虚拟机。原因是，复制与克隆都可以快速的让我们拥有一台虚拟机，而不需要花费太多时间。
 
2 ，.vmx 文件 ：
 
我们在复制虚拟机的时候，打开文件夹后，会看到很多文件，我们需要打开 .vmx 文件。
 打开这个文件后，虚拟机就会出现在 vmware 中，不能点击别的文件，只有这个文件才是可执行文件。
 
 
3 ，mac 地址是什么东西 ：
 
同学们应该注意到了，我们每次新建一个虚拟机，都要重新生成 mac 地址，那么这个 mac 地址是做什么用的呢？
 MAC地址（Media Access Control Address）：媒体访问控制地址，是网卡的唯一标识。
孙 ： 每一台电脑都有唯一的 mac 地址，出厂的时候，就自带了 mac 地址，每台电脑都不一样，就像我们每个人都有一个身份证号码一样。
为什么我们需要重新生成 max 地址呢？
 无论是复制还是克隆，都是讲虚拟机的相关文件，原封不动的拿过来用，那么，mac 地址就会重复，所以，我们需要重新生成一个不重复的，唯一的 mac 地址。
 
 
4 ，为什么要修改 vim /etc/udev/rules.d/70-persistent-net.rules 文件
 
这个文件，是管理网卡和 mac 地址的对应关系的。
这个文件中本来就有一个 mac 地址。
我们又重新生成了一个 mav 地址。
所以这个里面就出现了 2 个 mac 地址。
每个 mac 地址对应一块网卡，所以他就生成了两块网卡。
我们不需要两块网卡，有一块就够了
我们把之前的一行配置信息删除掉，也就相当于，把第一个 mac 地址和第一块网卡删除掉。
把最下面的配置信息，修改为 eth0 ，就相当于，把这个 mac 地址给了 eth0 。
网卡命名规则 ：我们同学学过了 java ，应该知道，在程序的设计中，数字是从 0 开始的。
 所以，第一块网卡的名字是 eth0
 第二块网卡的名字是 eth1
 第三块网卡的名字是 eth2 …
 
5 ，为什么要修改 vim /etc/sysconfig/network-scripts/ifcfg-eth0
 
这个文件是直接配置网络信息的文件。

一、什么是对象克隆？
 
首先我们需要知道，什么是对象的克隆，或者说复制。一个业务逻辑，需要一个新的对象，但是类型和值都是之前的，也就是说，新状态和之前完全一样。使用new和赋值语句或者set注入都是可以的，但是，这会花费大量开销去做，效率低，并且还会产生冗余代码。
 恰好java语言本身契合了原型设计模式，给我们提供了一个clone方法在Object对象中，只要需要克隆的对象实现Cloneable接口，那么我们只要简单的调用一下该方法就可以获得表面完全不同的对象。
 例1：
 
public class User implements Cloneable{
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return super.clone();
    }
}
......
User u = new User();
User uCopy = u.clone();
//显然u和uCopy已经是两个不同的对象了
System.out.println(u == uCopy);//false
 
二、如何实现对象克隆
 
上文也是提到，克隆对象基本只要两步：
 
实现Cloneable接口
实现clone()方法，并调用父类clone()
需要注意，Object的clone()方法是在java平台层实现的native方法，具有开销小，速度快的特点。而且，原始的Object方法是被protected修饰的，在这里需要修改为public，如果不这么做，浅克隆时没有问题，深克隆就会遇到权限不够的问题。java继承还有个原则，就是子类覆写父类方法，访问修饰符权限不能低于父类。
 
三、什么是浅克隆和深克隆
 
例2：
 
/**
 * 浅克隆/浅拷贝
 * @datetime  2018-10-09 09:43:22
 * @author Belmode
 *
 */
public class ShallowClone {
    public static void main(String[] args) throws Exception {
        Person p = new Person("李达康", "55", "汉东省京州市");
        Person p2 = (Person) p.clone();
        //一级对象
        System.out.println(p == p2);//false
        //二级对象
        System.out.println(p.personalInfo == p2.personalInfo);//true
        //三级对象
        System.out.println(p.personalInfo.name == p2.personalInfo.name);//true
    }
}
class PersonalInfo implements Cloneable{
    String name;
    String age;
    String address;
    public PersonalInfo(String name, String age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    PersonalInfo personalInfo;
    
    public Person(String name, String age, String address) {
        this.personalInfo = new PersonalInfo(name, age, address);
    }
    
    @Override
    public Object clone() throws CloneNotSupportedException {
         return super.clone();
    }
}
 
在本例中，Person类拥有PersonalInfo类作为属性，两者都实现了Cloneable接口，并且重写了clone()方法。
 在ShallowClone类的main方法中，构建了一个Person对象p，调用clone()方法，产生p2，p和p2不是一个对象，但是p和p2内部的personalInfo属性是同一对象，这就会导致一个致命的问题，当我修改p.personalInfo内部的属性值，结果p2.personalInfo也被修改了。
p.personalInfo.name = "孙正义";
System.out.println(p2.personalInfo.name); //孙正义
 
 
这是什么原因导致的？
这是因为java中不仅仅有基本变量，还有引用变量
浅拷贝：仅仅克隆基本类型变量，而不克隆引用类型的变量
深克隆：既克隆基本类型变量，也克隆引用类型变量
 
 
其实本来原生的clone()方法也是，复制了引用的，但是为什么引用类型还是同一个呢？
 就是因为java中，只有值传递，没有引用传递，引用在内存中还是值，是地址的hash值，一个特殊标记唯一堆内存块的值。
 图1：
 
 
 
 
在JVM虚拟机中，事实上就是一个java.exe或者javaw.exe进程里， 会存在栈内存和堆内存，堆内存又可细分，这里就不多说了，想深入了解的可以问度娘。在方法区中存储着Person和PersonalInfo的类模板，通过new 派生出 p和pesonalInfo的实例，如图中箭头所示。此时p里引用着personalInfo实例（其实应该从p实例里的方框画箭头到栈位置的personalInfo标签，这里为了下面说明，就没那么做了）
 在栈内存中存储的都是hashcode，类似于eb5238b，存在p的位置，就产生了图中的箭头
 
图2：调用clone()方法，克隆出p2
 
 

 如图所示，p2是真的新实例，但是personalInfo也是复制的值，p2里的personalInfo属性保存personalInfo实例的地址值，所以，如黄线所示，还是引用到原本的personalInfo实例。
因此，修改p.personalInfo里的属性，p2.personalInfo里的值也会收到影响！！
 
 
 
那么，如果我修改p.personalInfo属性,p.personalInfo = new PersonalInfo.....那p2.pernalInfo会不会收到影响呢？
 答案是不会的。
 图3：
 
 
 
 
如图所示，会断开红叉处的连接，生成橙色连接。如橙线所示。
p对象和p2的personalInfo属性其实已经不同了。
 
话题有点跑偏了，因为会出现上面的原因，所以需要深克隆。
 
例3：
 
public class DeepClone {
    public static void main(String[] args) throws Exception {
        Person2 person = new Person2("李达康", "55", "汉东省京州市");
        Person2 person2 = (Person2) person.clone();
        //一级对象
        System.out.println(person == person2);//false
        //二级对象
        System.out.println(person.personalInfo == person2.personalInfo);//false
        //三级对象
        System.out.println(person.personalInfo.name == person2.personalInfo.name);//false
    }
}

class PersonalInfo2 implements Cloneable{
    String name;
    String age;
    String address;
    public PersonalInfo2(String name, String age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        PersonalInfo2 pInfo = (PersonalInfo2) super.clone();
        pInfo.name = new String(this.name);
        pInfo.age = new String(this.age);
        pInfo.address = new String(this.address);
        return pInfo;
    }
}
class Person2 implements Cloneable{
    PersonalInfo2 personalInfo;
    
    public Person2(String name, String age, String address) {
        this.personalInfo = new PersonalInfo2(name, age, address);
    }
    
    @Override
    public Object clone() throws CloneNotSupportedException {
       Person2 p = (Person2) super.clone();
       p.personalInfo = (PersonalInfo2) this.personalInfo.clone();
       return p;
    }
}
 
在这里，Person2调用父类clone(),克隆出新实例p，也给p.personalInfo调用 PersonalInfo2的父类方法，而在此中
 
    @Override
    public Object clone() throws CloneNotSupportedException {
        PersonalInfo2 pInfo = (PersonalInfo2) super.clone();
        pInfo.name = new String(this.name);
        pInfo.age = new String(this.age);
        pInfo.address = new String(this.address);
        return pInfo;
    }
 
对所有引用类型String全部new产生和之前不同的对象，达到深度克隆的目的。
 (因为String没有实现Cloneable接口，需要通过new派生，这里是举特殊例子。如果是实现Cloneable接口的类，直接嵌套调用clone()方法就好了。)
 这样，新的Person2实例，与之前的引用完全不同，但是值是一样的！深度克隆成功。
 
        Person2 person = new Person2("李达康", "55", "汉东省京州市");
        Person2 person2 = (Person2) person.clone();
        //一级对象
        System.out.println(person == person2);//false
        //二级对象
        System.out.println(person.personalInfo == person2.personalInfo);//false
        //三级对象
        System.out.println(person.personalInfo.name == person2.personalInfo.name);//false

        System.out.println(person.personalInfo.name);//李达康
        System.out.println(person2.personalInfo.name);//李达康

 
三、还有其他深度克隆方式吗？
 
对象序列化与反序列化。但是这么做开销更大，不建议如此。（这里不做举例）
 
总结：
 
1.浅克隆：只复制基本类型的数据，引用类型的数据只复制了引用的地址，引用的对象并没有复制，在新的对象中修改引用类型的数据会影响原对象中的引用。直接使用clone方法，再嵌套的还是浅克隆，因为有些引用类型不能直接克隆。
 2.深克隆：是在引用类型的类中也实现了clone，是clone的嵌套，并且在clone方法中又对没有clone方法的引用类型又做差异化复制，克隆后的对象与原对象之间完全不会影响，但是内容完全相同。
 3.使用序列化也能完成深复制的功能：对象序列化后写入流中，此时也就不存在引用什么的概念了，再从流中读取，生成新的对象，新对象和原对象之间也是完全互不影响的。

虚拟机克隆分为“完整克隆”（Full Clone）和“链接克隆”（Linked Clone）两种方式。
 
克隆过程中，VMware会生成和原始虚拟机不同的MAC地址和UUID，这就允许克隆的虚拟机和原始虚拟机在同一网络中出现，并且不会产生任何冲突。
 
VMware 完整克隆（Full Clone）
 
完全克隆的虚拟机不依赖源虚拟机，是完全独立的虚拟机，它的性能与被克隆虚拟机相同。
 
由于完整克隆不与父虚拟机共享虚拟磁盘，所以创建完整克隆所需的时间比链接克隆更长。如果涉及的文件较大，完整克隆可能需要数分钟才能创建完成。完整克隆只复制克隆操作时的虚拟机状态，因此无法访问父虚拟机的快照。
 
VMware 链接克隆（Linked Clone）
 
依赖于源虚拟机（称为父虚拟机）。由于链接克隆是通过父虚拟机的快照创建而成，因此节省了磁盘空间，而且克隆速度非常快，但是克隆后的虚拟机性能能会有所下降。
 
对父虚拟机的虚拟磁盘进行的更改不会影响链接克隆，对链接克隆磁盘所做的更改也不会影响父虚拟机。但是如果父虚拟机损坏或快照点删除，链接克隆的虚拟机也不能使用；如果父虚拟机移动位置，需要重新指定父虚拟机的位置，再启动链接克隆虚拟机。