谈谈JAVA中对象和类、this、super和static关键字

发表于 更新于 分类于 阅读次数：

Java对象究竟是什么？

对象：对象是类的一个实例，有状态和行为。

类：类是一个模板，它描述一类对象的行为和状态。
例如

人 是一个类

其状态有：姓名、性别、身高、体重等

其行为：吃饭、睡觉、聊天、运动等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Person {
    /**
     * 状态 or 属性
     */
    String name;//姓名
    String sex;//性别
    int height;//身高
    int weight;//体重
    
    /**
     * 行为
     */
    public void sleep(){
    	System.out.println(this.name+"--"+ "睡觉");
	}
    public void eat(){
        System.out.println("吃饭");
    }
    public void Dance(){
        System.out.println("跳舞");
    }
}

对象就是指具体的哪个人，比如”小张” 就是对象，可以通过new 来创建出来

1
2
3
4
5
6
7
public static void main(String[] args) {
    Person zhang = new Person();
    zhang.name = "小张";
    zhang.sex ="男"；
    zhang.height=180;
    zhang.weight=150;
}

通过上面的例子，我们可以发现 面向对象提出一种计算机世界里解决复杂软件工程的方法论，拆解问题复杂度，从人类思维角度提出解决问题的步骤和方案。

因为面向过程让计算机有步骤地顺次做一件事情，是一种过程化的叙事思维，简单明了。但是随着软件项目越来越庞大的时候，发现用面向过程语言开发，软件维护、软件复用存在着巨大的困难。

创建对象的过程

一般来说，我们创建对象 可以通过new来 创建一个，比如从上面的例子中这一句：

1
Person zhang = new Person();

虽然我们写的时候是简单的一句，但是JVM内部的实现过程却是复杂的：

  1. 将硬盘上指定位置的Person.class文件加载进内存
  2. 执行main方法时，在栈内存中开辟了main方法的空间（压栈-进栈），然后在main方法的栈区分配了一个变量zhang。
  3. 执行new，在堆内存中开辟一个 实体类的 空间，分配了一个内存首地址值
  4. 调用该实体类对应的构造函数，进行初始化（如果没有构造函数，Java会补上一个默认构造函数）。
  5. 将实体类的 首地址赋值给zhang，变量zhang就引用了该实体。（指向了该对象）

JVM内存分配情况

创建多个对象时，内存的变化

当我们new 多个对象时，属性会另外开辟堆空间存放，而方法只有一份，不会额外消耗内存

创建多个对象时-JVM内存分配情况

我们接着来看一个例子：

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
    Person ming = new Person();
    ming.name = "ming";
    ming.sleep();

    Person wang = new Person();
    wang.name = "wang";
    wang.sleep();
}

运行结果：

ming–睡觉

wang–睡觉

对象ming的 属性在堆内存，方法在方法区。当我们在通过Person类来 新增一个wang对象时，栈内存会有一个对象名称wang，来指向在堆内存中 新创建的另一个Person对象，属性存放在堆内存中。我们可以看出对象ming和对象wang 属性 2者互不影响，相互独立。

但是 对象ming和对象wang的方法区 是共用的。 那为何2者属性输出结果不一样呢？

其实 方法就像一套指令模板，谁都可以传入数据交给它执行，然后得到对应执行结果。

但是 JVM是如何确保 ming.sleep(); 返回的结果是 小明在睡觉 而不是 小王在睡觉 或者其他情况？

Java的this其实就是解决这个问题的，接下来我们慢慢道来。

无处不在的this和super关键字

this 表示当前对象的引用，可以理解为指向对象本身的一个”指针”,但是JAVA中是没有指针这个概念的。

我们知道在C/C++中，指针是指向内存中的地址，该地址就是存储变量的值。该地址所存储的变量值是"公有"的，此处的”公有”是对于拥有该地址的变量而言。它们随时都可以访问该地址的内容，并且可对其进行修改，一经修改则所有指向该地址的变量值也将改变。

c++中也有结构体、对象的概念，但是为什么他们不像java一样有”封装”的概念？

因为在c、c++中指针很强大，可以通过指针直接访问操作内存中的数据。而java没有指针，这样封装就能极大地提升安全性。

虽然java中没有指针的概念，但this(“指针”)无处不在.

从上面的例子 我们可以看出

1
2
3
   public void sleep(){
   	System.out.println(this.name+"--"+ "睡觉");
}

ming.sleep()和wang.sleep()语句调用的代码是方法区同一个内存，但是在JVM运行过程中，可以根据由哪个对象发起对sleep()的调用，方法中所用到的成员变量数据就使用哪个对象的数据。这个本质就像是方法传参一样，隐式传递this

1
2
3
4
5
this表示当前对象的引用：
    this.属性 区别成员变量和局部变量
    this.() 调用本类的某个方法
    this() 表示调用本类构造方法，只能用在构造方法的第一行语句。
    this关键字只能出现在非static修饰的代码中

我们来看一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Main {
    public static void main(String[] args) {
        Nanjing nanjing = new Nanjing();

        Beijing beijing = new Beijing();

    }
}
public class Country {
	String name;
    public Country(){ //构造器
        System.out.println(this.getClass().getName());
    }
}

public class Beijing extends Country{
}

public class Nanjing extends Country{
}

结果：

com.company.Nanjing

com.company.Beijing

子类Nanjing和Beijing 啥都没干，但是却通过父类Country的构造器，得到子类的名字。

当程序执行new Nanjing()语句去实例化子类时,它会去隐式调用父类的构造器，等同于：

1
2
3
4
5
public class Nanjing extends Country{
	public Nanjing() {
		super();//显式 调用父类的构造器
	}
}

这一过程中，会去隐式传递this,不然各个子类的名称 不会显示

我们再来改造一下Nanjing类的代码：

1
2
3
4
5
6
public class Nanjing extends Country{
    public Nanjing() {
        System.out.println("nanjing 自定义构造器");
    }
}

结果：

com.company.Nanjing

nanjing 自定义构造器

我们可以看出： 如果 子类Nanjing自定义构造器，会优先调用父类的构造器，再调用自己的构造器

我们接着来看下 super关键字

super 表示自己超（父）类对象的引用,可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。

1
2
3
4
5
6
7
8
9
10
11
super表示父类对象：
    super.属性 表示父类对象中的成员变量
    super.方法()表示父类对象中定义的方法
    super() 表示调用父类构造方法
        可以指定参数，比如super("Nanjin");
        任何一个构造方法的第一行默认是super();
        可以写上，如果未写，会隐式调用super();
    super()只能在构造方法的第一行使用。
    this()和super()都只能在构造的第一行出现，所以只能选择其一。
    写了this()就不会隐式调用super()。
    super 关键字在子类中显式调用父类中被覆盖的非静态成员方法和成员变量

我们来看一个super调用父类方法的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Father {

  void message() {
    System.out.println("This is Father");
  }

}

class Son extends Father {
  void message() {
    System.out.println("This is son");
  }

  void display() {
    message();
    super.message();
  }

}

class Main {
  public static void main(String args[]) {
    Son s = new Son();
    s.display();
  }

}

结果：

This is son
This is father

可以看出 super和this功能差不多，主要区别：this 指向当前对象，super指向 离自己最近的一个父类,就不展开深入说了。

static关键字 为何如此特殊

Java中static`关键字主要用于内存管理, 可以用来修饰变量或者方法。

由于JAVA面向对象处处可见，在面向对象的思维下，方法与对象存在一种强耦合，简单点来说就是 方法在没有对象的情况下无法调用。

static关键字就是被设计来解决这个问题的。

我们来看一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Country {
    String name = "china";
    
    public void show() {
        System.out.println(name);
    }

}

public static void main(String[] args) {
        Country c1 = new Country();
        Country c2 = new Country();
        c1.name = "china new";
        c2.show();

    }

结果：

china

如果用static修饰呢：

1
2
3
4
5
6
7
8
public class Country {
    static String name = "china";
    
    public void show() {
        System.out.println(name);
    }

}

结果：

china new

我们可以看出：

如果给一个属性加上static，那么这个属性不再属于某一个对象了，而是是属于类的，是所有对象共享的，共用同一个static属性

可以通过类对象名.变量名 的方式访问,比如： Country.nanme

当程序进行类加载时，静态方法随着类加载而加载进JVM中，此时并没有对象实例化，优先于对象的创建。static属性在一个单独的内存区，而不是在new出的对象内存中

JVM内存分布

另外一般来说 静态方法不能访问实例变量，其实是由于Java不会在调用静态方法时传递this，没有this就没法处理差异化数据。

非static方法可以调用static方法，但static方法不能调用非static方法

尾语

笔者花了2个星期，重学java基础，期间查了许多资料和书籍，把Java中对象和类、this、super和static关键字都串起来，简单聊聊这些背后设计的原理，希望对大家有所帮助