2012年3月18日星期日

引用(别名)是什么?

由一个简单的JAVA问题引发了一场热情洋溢的群众喜闻乐见的讨论,同时扯到C++上。。。
先上代码:


public class test {
public static void main(String[] args){
int a = 4;
int b = a;
String s1 = "abc";
String s2 = s1;
String s3 = "def";
String s4 = "def";
System.out.println(a == b);     // 1
System.out.println(s1 == s2);   // 2
System.out.println(s3 == s4);   // 3
s3 = "abc";
System.out.println(s1 == s3);   // 4
s2 = "abcdef".substring(3,6);
System.out.print(s2 + "\t" + s4 + "\t");  
System.out.println(s2 == s4);   // 5
System.out.println(s2.equals(s4));  // 6
s3 = args[0];
System.out.print(s1 + "\t" + s3 + "\t");
System.out.println(s1 == s3);  // 7
System.out.println(s1.equals(s3));   // 8
  a--;
  System.out.println(a + " " + b);     // 9
}
}



output example:

上面的结果能说明一些问题:
注释3处表示,s3,s4指向同一个内存地址,也就是说,“abc”这个字符串在编译时经过优化存放在全局数据区,并不会产生两个相同的string。

注释4处表示,s3 = "abc"这句是将s3指向"abc"这个字符串对象,而并不是修改s3原先指向的"def"处的内容。这证实了书上说的“string对象是不可变的”。

注释5、6处证明了 == 比较的是两个引用所指向对象的物理地址,而不是对象的值。用equals()比较值的结果是true,用 == 比较内存地址的结果是false,因为s2是从另一个字符串的返回的string子串,虽然内容和"abc"一样,但物理地址是不同的。
注释7、8处同理。从args传入参数。

(后来加上去的)注释9处,是验证b是否为a的引用。结果显示为 "3 4",说明a,b是独立的。同样的句式,用在string上和用在int上效果完全不一样,何解?因为int是基本类型,而String是一个类。
确实,很多时候我们潜意识里以为String和int都是基本类型,其实不然。

说到底,s2是s1的一个浅copy,不是深copy。
这里引用一段师兄的话
关于别名,其实就是编译器在编译时帮某个变相定义的另外一个名字而已,你就把引用当作在编译时编译器帮你默认写了个typedef。它其实不会产生额外内存开销(至少在C/C++里面是这样),只是编译的trick,按照我的理解,它应该仅存在于编译后产生的符号表里面,所以本身也没有地址。
 也就是说,一般情况下,引用(别名)本身是不占空间的,这和C++的定义是一致的。符号表是关键....

附一个stackoverflow上关于引用的解释: http://stackoverflow.com/questions/1179937/how-does-a-c-reference-look-memory-wise

再次清楚的意识到自己的基础知识该有多差。。。细节决定成败啊!
还是要潜心钻研学术,低调求发展。。。
“勿在浮沙筑高台”


2012年3月3日星期六

JAVA中的多态机制与类初始化

将一个方法调用同一个方法主体关联起来,称为绑定。
在运行时根据对象的类型进行绑定称为后期绑定(动态绑定),这是实现多态的前提。

由多态引申出一个对象初始化具体步骤的问题,自己想了一个模型:
class Shape {
  int a;
  double b;
  Shape(){f1();}
  void f1(){println("shape.f1");}
  private void f2(){println("shape.f2");}
}

public class Circle extends Shape {
  void f1(){println("circle.f1");}   //override
  void f2(){println("circle.f2");}
  public static void main(String[] args){
    Shape s = new Circle();
    s.f1();
    s.f2();
  }
}


output:
circle.f1
circle.f1
shape.f2


将派生类对象向上转型为基类,根据实际对象调用重载的方法,是多态的特性。开始我很疑惑,怎么可以在基类的构造器调用派生类的重载函数?在内存中,对象的具体实现是怎样的呢?就是以怎样的形式存在于内存空间中的呢?这就要涉及对象的初始化步骤:

1.访问public类的main()函数 【static 方法】
2.加载并找出该类的编译代码(.class文件中)
3.加载过程中若存在基类(由extends可知)则先加载基类编译代码
4.根基类的static初始化,接着是导出类的static块
5.创建对象:所有类成员变量初始化(或置0);从根基类开始按顺序调用构造函数
6.实例变量按顺序初始化


关于成员函数在类中的表示方式,和师兄讨论过之后恍如大悟。他是站在C++的角度解释这个问题,但是我觉得很有道理。
首先,要清楚,函数并无“实例”的概念。程序被载入后,函数是在内存中的代码区而不是在数据区。函数不会被实例化,类在初始化生成this指针的时候,并不将任何函数装入内存,装入内存的是函数入口的偏移指针,这个入口指针可以一早确定并赋值给代表virtual function的类成员变量。
也就是说,s对象初始化的时候,f1(),f2()作为类成员变量(实际上是“指针变量”),其实存储的是对应函数的入口地址,而非函数代码本身。override之后,f1()接口处存放的就是派生类的函数入口,而非基类的函数入口。f2()由于定义为final,则其内容无法被修改,故依然指向基类的函数入口。

从上面的例子来看,circle从shape类继承来的是一个int,一个double,一个"指针变量",和一个"常指针";对象初始化的时候覆盖了f1()指针变量地址,然后创建了另一个指针变量f2()(扩展接口),所以就可以通过基类的构造器调用派生类的函数了(步骤5)。

2012年2月21日星期二

JAVA中访问权限控制的问题

记得在C++中,private部分主要是数据成员,public部分主要是函数成员,也就是类接口。如果没有特别声明public或者protect,private,也不会强调包访问权限这个概念。《thinking in JAVA》中的一些例子总是让人有眼前一亮的感觉。
现在想想,当时学的C++真是皮毛都算不上。囧rz

正题:
通过将构造函数声明为private,控制类外程序无法直接创建新类,而需要通过类接口来创建。书上说是可以通过特定函数(类接口)来实现特殊功能,比如控制数量。细心一想确实如此,要统计生成的对象数目,用一个计数器就可以了,但构造函数本身无法控制不生成对象,因为调用构造函数本身的同时就生成了一个对象。但是用函数成员的话只需要一个if就可以解决。

里面还提到一个设计模式的例子。private构造函数,类接口本身只提供一个类内生成对象的引用。称之为singleton(单例)。这种想法之前还真没接触过。。

example code:


/* Following the form of the example Lunch.java, create a class called
* ConnectionManager that manages a fixed array of Connection objects. The client
* programmer must not be able to explicitly create Connection objects, but can
* only get them via a static method in ConnectionManager. When ConnectionManager
* runs out of objects, it returns a null reference. Test the classes in main(). */


class connection{
private static int count = 0;
private connection(){System.out.println("connection created!");}
public static connection makecon(){
count ++;
return new connection();
}
public int howmany(){return count;}

}


public class CM{
private int num = 3;
connection[] con = new connection[3];
CM(){
for(connection x : con){
x = connection.makecon();
System.out.println(x.howmany());
}
}
public connection getcon(){
if(num != 0){
System.out.println("get " + (num - 1) + "th connection");
return con[--num];
}
else {
System.out.println("no connection left!");
return null;
}
}

public static void main(String[] args)
{
CM cm1 = new CM();
connection c1 = cm1.getcon();
connection c2 = cm1.getcon();
connection c3 = cm1.getcon();
connection c4 = cm1.getcon();
}
}


原书答案中,生成固定数组的foreach语句是用一个大括号包起来,而我将其放在构造函数中。之前还没出现过
{
 for(...){}
}
这种用法,开始不明白,后来想起,类中只能存在数据成员和函数成员,不能出现这种函数语句的吧?。。。C++中反正我是没见过 = =