一切皆对象

一切皆对象

在 Java 中，一切皆为对象。这里需要区分引用和对象。

对象和引用

//等号左侧的变量名为引用
//等号右边的为对象。
String str = "Hello World";
String str1 = new String("Hello World");
//false
System.out.println(str==str1);
//true
System.out.println(str==str.intern());

对于 str 和 str1 引用了不同的地址，但 str 和 str1 在常量池中的地址却是一样的。


数据存储

在程序运行时，有以下五个地方用于存放数据：

1. 寄存器：位于处理器，存储速度最快，但是数量有限，不允许直接控制。
2. 栈：位于 RAM ，速度仅次于寄存器。先进后出，压栈出栈。Java 中引用、局部变量、基本类型都存储于此。
3. 堆：位于 RAM ，用于存储 Java 对象，且不需要知道对象的生命周期，创建和回收比栈费时。
4. 常量存储：通常直接放于程序代码内部。
5. 非RAM存储：流对象和持久化对象。如：文件的存储。

基本类型

Java 中基本类型的大小、最大值、最小值及包装器对应表。Java 5.0 之后提供了自动装箱和拆箱功能。


高精度数字

Java 提供 BigInteger 和 BigDecimal 用于高精度计算，两者没有对应的基本类型。原则上，只要计算机有足够内存，两者能表示的位数就是无限大。
BigInteger:支持任意精度的整数。
BigDecimal:支持任意精度的定点数

public static void main(String[] args) {
   Scanner scanner = new Scanner(System.in);
   System.out.println("请输入需要计算的值,如:100000000000000000 1988930304");
   while (scanner.hasNext()) {
       BigInteger a = scanner.nextBigInteger();
       BigInteger b = scanner.nextBigInteger();
       System.out.println("和为=" + a.add(b));
   }
}

作用域

作用域决定了变量的可见性和生命周期。但是在 Java 中对象不具备和基本类型一样的生命周期。一个 Java 对象可以存活于作用域之外。

public void scope() {
    //变量i在方法执行结束时就会失效
    int i = 0;
    //引用str在方法执行结束时就会失效，我们无法用引用str继续访问这个对象
    //但引用所指向的对象会一直存在直到被系统的垃圾回收器回收。
    String str = new String("Hello World!");
}

垃圾回收有两种方法：引用计数法和可达性分析法。在 Java 中使用的是后一种

• 引用计数法

直接计数，简单高效，Python便是采用该方法。但是如果出现 两个对象相互引用，即使它们都无法被外界访问到，计数器不为0它们也始终不会被回收。为了解决该问题，java采用的是可达性分析法。

• 可达性分析法

这个方法设置了一系列的“GC Roots”对象作为索引起点，如果一个对象 与起点对象之间均无可达路径，那么这个不可达的对象就会成为回收对象。这种方法处理 两个对象相互引用的问题，如果两个对象均没有外部引用，会被判断为不可达对象进而被回收（如下图）。


方法、参数和返回值

在 Java 中，方法属于类的一部分，方法的基本形式如下：

public/protect/private/defualt 返回类型 methodName(参数列表) {}

方法名和参数列表唯一的标识一个方法。
方法调用有两种方式：

//调用对象的方法
object.method(arg1,arg2);
//调用类方法，类方法用 static 进行修饰
Class.method(arg1,arg2);

方法中的参数如果为对象，则传递的参数为引用，对引用的修改会导致原始数据的改变。下面的例子是用来测试修改引用类型参数的内容会不会影响到原始数据的 demo。
补充：

1. 对 String 类型的参数修改会表现出基本类型参数的特性，具体原因分析可见：Java-String类型的参数传递问题
2. 值传递和引用传递的区别

• 值传递：方法操作的是参数变量（也就是原型变量的一个值的拷贝）改变的也只是原型变量的一个拷贝而已，而非变量本身。所以变量原型并不会随之改变。
• 引用传递：也叫做传址，即方法操作参数变量时是拷贝了变量的引用，而后通过引用找到变量（在这里是对象）的真正地址，并对其进行操作。当该方法结束后，方法内部的那个参数变量随之消失。但是要知道这个变量只是对象的一个引用而已，它只是指向了对象所在的真实地址，而非对象本身，所以它的消失并不会带来什么负面影响。回头来看原型变量，原型变量本质上也是那个对象的一个引用（和参数变量是一样一样的），当初对参数变量所指对象的改变就根本就是对原型变量所指对象的改变。所以原型变量所代表的对象就这样被改变了，而且这种改变被保存了下来。

public static void main(String[] args) {
   //按理说，执行change方法修改参数，但是并没有按预期输出
   //这是个值得探寻的问题
   String str = "1";
   System.out.println("str=" + str + "，address in memory=" + str.getClass() + "@" + str.hashCode());
   change(str);
   System.out.println(str.toString());
   System.out.println("after ref,str=" + str+ "，address in memory=" + str.getClass() + "@" + str.hashCode());

   //执行change方法对参数进行修改会影响到原始数据
   Person person = new Person(10);
   System.out.println("person=" + person.toString());
   change(person);
   System.out.println("after person=" + person.toString());
}

private static void change(String string) {
   System.out.println(string+ "，address in memory=" + string.getClass() + "@" + string.hashCode());
   string = "123";
   System.out.println(string+ "，address in memory=" + string.getClass() + "@" + string.hashCode());
}

private static void change(Person person) {
   person.setAge(11);
}

public static class Person {
   private int age;

   public Person(int age) {
       this.age = age;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       this.age = age;
   }

   @Override
   public String toString() {
       return "Person{" +
               "age=" + age +
               '}';
   }
}

输出如下：

str=1，address in memory=class java.lang.String@49
1，address in memory=class java.lang.String@49
123，address in memory=class java.lang.String@48690
1
after ref,str=1，address in memory=class java.lang.String@49
person=Person{age=10}
after person=Person{age=11}

注释

文档标签