let location1 = {province: '湖北', city: '武汉', country: '武昌'};

let location2 = {province: '湖北', city: '武汉', country: '武昌'};

console.log(location1 === location2);

let location3 = {province: '江苏', city: '南京', country: '中山'};

let location4 = location3;

console.log(location3 === location4);

location1 等于 location2的意思是location1 指向的内存和location2 指向的内存是同一块内存区域。

如果location1 和 location2虽然存储的值相等，但是如果属于不同的内存区域，那么两者仍然不相等。

 

Java面向对象(二) 静态域、代码块和内存区域图
静态域

将域定义成static后，每个类中只有一个这样的域，与类相关的，也称为类成员。但是每个对象对于所有的实例域却都有自己的一份拷贝。
静态域会随着类的加载而加载并初始化，存在于方法区内存中的字节码文件的静态区域中。
优先于对象存在，先有方法区的类加载，后才可能会有堆内存的对象实例化。
静态域会被所有的对象共享，也称为共享区。
一般共性用静态，特性用非静态。
一般通过类名直接调用，虽然也可以通过对象名调用，但是不推荐，也不合适。

static关键字注意事项

在静态方法中没有this关键字

静态是随着类的加载而初始化，而this是随着对象的创建而存在的。
静态比对象优先存在。


静态方法只能访问静态成员和静态成员方法，即静态只能访问静态

静态方法：

成员变量：只能访问静态变量
成员方法：只能访问静态成员方法


非静态方法：

成员变量：可以是静态的，也可以是非静态的
成员方法：可以是静态的成员方法，也可以是非静态的成员方法。





静态变量和成员变量区别

静态变量也叫类变量，成员变量也叫对象变量。
所属不同

静态变量属于类
成员变量属于对象


内存中的位置不同：

静态变量存储于方法区的静态区
成员变量存储于堆内存



代码块
代码块概述

Java中，使用{}括起来的代码称为代码块

代码块的分类

根据位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块和同步代码块

代码块的应用

局部代码块

在方法中出现，可以限定变量的生命周期，及早释放，提高内存利用率。


构造代码块（初始化代码块）

在类中方法外出现，将多个构造器中的相同代码放到一起，每次调用构造器都执行，并且在构造方法前执行。


静态代码块

在类中方法外出现，并且用static修饰，用于给代码块中的代码静态化，加入静态域中，在类加载的时候直接执行，并且只执行一次。
静态代码块优先于main方法执行。
一般常用于加载驱动、IO操作等消耗资源的代码



代码块面试题
根据程序写输出结果，考察执行顺序
class Student {
		static {
			System.out.println("Student 静态代码块");
		}
		
		{
			System.out.println("Student 构造代码块");
		}
		
		public Student() {
			System.out.println("Student 构造方法");
		}
}
	
class StudentTest {
    static {
        System.out.println("StudentTest静态代码块");
    }

    public static void main(String[] args) {
        System.out.println("我是main方法");

        Student s1 = new Student();
        Student s2 = new Student();
    }
}

测试结果：
StudentTest静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法

分析：
​	main方法是Java程序的入口，JVM先找main方法，先把有main方法的类加载到内存中，此时StudentTest类的静态代码块直接随着类的加载而先执行；
​	随后main方法开始执行，当Student类被实例化后，Student类的静态代码块先执行，并且只执行一个，不管实例化多少对象；
​	之后，每实例化一次Student类，类中的构造代码块比构造方法就会先执行，并且每实例化一次就执行一次。
初始化执行顺序总结

当程序执行时，如果需要创建某个类的对象，那么Java会先检查是否加载了这个类，如果没有加载，则先执行类的加载再生成对象。如果已经加载，则直接生成对象。
类的执行顺序过程：

首先类先加载到方法区内存中，类的静态域会先被加载并且初始化并且优先于main方法执行。Java中类的加载时按需加载，需要时才加载，并且只加载一次。

静态成员变量和静态代码块的执行顺序同代码中的顺序一致。


每创建一次对象时，先初始化对象中的成员变量，再执行构造代码块，其次再执行构造方法。

类中的变量会在任何方法（包括构造器）调用之前得到初始化，即使变量散布于方法定义之间。





Java内存区域分配

此分配图基于Java8之前版本

对于HotSpot虚拟机来说，Java类的实例对象在内存中存储分为三块区域，分别是对象头、实例数据、对齐填充。



对象头

对象头包含两部分，第一部分用于存储对象自身运行时的数据，包括GC分代年龄、哈希码、锁状态、线程持有的锁等数据，这部分的数据长度在32位和64位虚拟机中分别为32位和64位，被称为“Mark Word”。

对象头的另一部分用于存储对象的类元数据的指针，虚拟机通过这个指针可以知道对象是哪个类的实例。



实例数据

实例数据用于存储在程序代码中定义的各种类型的字段内容，也包含从父类继承来的。这部分数据的存储顺序会受到虚拟机分配策略参数和字段在代码中定义的顺序的影响。



对齐填充

在HotSpot虚拟机中，对象的大小要求是8字节的整数倍，因为对象头的大小正好是8字节的一倍或两倍，而实例数据部分可能不是8字节的整数倍，所以需要凑齐8字节的整数倍，就用到了对齐填充部分，它仅仅是用于占位的作用。 

最近读《研磨设计模式》对这段话不太理解：    多个实例的
static变量会共享同一块内存区域。
Java 中 static的特性：

  static 变量在类装载的时候进行初始化。
  多个实例的 static变量会共享同一块内存区域。
做了个例子验证一下

例子：

class A {
	 static  int num = 1;
	private String name;

	public String getName(String name) {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void show() {
		System.out.println("name:" + name + " num:" + num);
	}
}

public class Test {
	public static void main(String[] args) {
		A a = new A();
		a.setName("classA");
		a.num++;

		A b = new A();
		b.setName("classB");

		a.show();
		b.show();
	}
}


输出结果：


name:classA num:2
name:classB num:2

反例：

package Singleton;

class A {
	  int num = 1;
	private String name;

	public String getName(String name) {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void show() {
		System.out.println("name:" + name + " num:" + num);
	}
}

public class Test {
	public static void main(String[] args) {
		A a = new A();
		a.setName("classA");
		a.num++;

		A b = new A();
		b.setName("classB");

		a.show();
		b.show();
	}
}


输出结果：


name:classA num:2
name:classB num:1


通过例子和反例确实可以证明，Java中多个实例的static变量会共享同一块内存区域，也就是多个对象共享一个类的同一个静态成员变量