final修饰的变量是引用不能改变，还是引用的对象不能改变？？？构造器子类父类关系

总得来说对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

对于这个问题，我们不能只记结论，要拿实例说话，参看以下代码：

public class Demo {
    public static void main(String[] args) {
        final StringBuilder sb = new StringBuilder("haha");
        //同一对象的hashCode值相同
        System.out.println("sb中的内容是：" + sb);
        System.out.println(sb + "的哈希编码是:" + sb.hashCode());
        sb.append("我变了");
        System.out.println("sb中的内容是：" + sb);
        System.out.println(sb + "的哈希编码是:" + sb.hashCode());
        System.out.println("-----------------哈希值-------------------");
        Demo test = new Demo();
        System.out.println(test.hashCode());
        System.out.println(Integer.toHexString(test.hashCode()));
        System.out.println(test.getClass().getName() + "@" + Integer.toHexString(test.hashCode()));
        //在API中这么定义toString()等同于 getClass().getName() + '@' + Integer.toHexString(hashCode())
        //返回值是 a string representation of the object.
        System.out.println(test.toString());
    }
}

结果：

sb中的内容是：haha
haha的哈希编码是:396873410
sb中的内容是：haha我变了
haha我变了的哈希编码是:396873410
-----------------哈希值-------------------
1706234378
65b3120a
demo1.Demo@65b3120a
demo1.Demo@65b3120a

 

分析结果，两次的hashCode都是一样的，表示引用变量没变，引用变量所指向的对象中的内容还是可以改变的

总得来说对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

-----------------------------------------

例如，对于如下语句：
final StringBuffer a = new StringBuffer("immutable");
执行如下语句将报告编译期错误：
a = new StringBuffer("");
但是，执行如下语句则可以通过编译：
a.append("broken!");
有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：
public void method(final StringBuffer param)
{
}
实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：
param.append("a");这是因为变量param的引用并没有变化，所以是不会出错的。

但是下面的就会出错了，因为int类型的数据是直接放在了栈内存当中的，它不需要想对象一样需要有一个引用，如果

修改了x就是修改了引用，所以如果修改了x那么就会出错。

 public int addOne(final int x) {
 return x++;
 }

又比如如下的例子：

public class Something{
public static void main(String[] args) {
Other o = newOther();
new Something().addOne(o);
}
public void addOne(final Other o) {
o.i++;
}
}
class Other {
public int i;
}

 

这个在编译的时候也是不会出错的，因为这个时候修改的不是对象的引用而是对象的属性，因为只有对象是final类型的，所以只要不去修改对象就不会出现错误的。

构造器

子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。

如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。

实例

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){
    super(300);
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    SubClass sc = new SubClass();
    SubClass sc2 = new SubClass(200); 
  }
}

输出结果为：

SuperClass(int n)
SubClass
SuperClass()
SubClass(int n):200