Java学习笔记

1.Java中toString方法的作用。

该方法是Object中的方法，因此，所有的对象都有这个方法。它通常只是为了方便输出，比如System.out.println(xx)，括号里面的“xx”如果不是String类型的话，就自动调用xx的toString()方法。

例子1：
public class A{
    public String toString(){return "this is A";}
}
如果某个方法里面有如下句子：
A obj=new A();
System.out.println(obj);
会得到输出:this is A

例子2：
public class A{
    public String getString(){return "this is A";}//toString改个名字试试看
}
A obj=new A();
System.out.println(obj);
会得到输出:xxxx@xxxxxxx的类名加地址形式
System.out.println(obj.getString());
会得到输出:this is A

2.强制类型转换。

引用类型的强制类型转换，简单地讲，就是把父类型转换成子类型。但是这种转换并不一定都能成功。

例如：

Father father = new Son();   那么，需要将这个对象的类型还原的时候，也就是强制转换，Son son = (Son)father;---------可以成功

Father father = new Father();  Son son = (Son)father; -------------------------这时候就会报错，运行时报错，编译能通过的

编译器只检查类型之间有无继承关系，有则通过；运行时检查真正类型，是则通过。

因此，强制类型转换能否成功，在于这个的对象的真实类型，也就是它是使用什么类的构造方法构造出来的。

http://bbs.csdn.net/topics/360106633

3.synchronized (class)等问题。

任何的java元素都包含在类里边，对于任何的类，编译之后都对应了一个相应的.Class文件，同时Java也定义了Class类，它的实例对应各种Class文件，也就是说String.class是Class类的一个实例，Object.class也是Class的一个实例……。至于XX.class显然是一个Class的实例，而不是一个类。synchronized (XXX.class)和synchronized（this）这样的语句在语法上是同一类型的，只不过后者锁的是当前对象，而前者锁的是Class的一个实例xxx.class。

synchronized(this)，这里的this是指当前对象。也就是说不管ta还是tb，刚开始运行这段代码的时候会给这段代码加个锁，这样即使运行到中间被替换了，另一个线程也不会执行这段代码，因为这段代码加锁了，而钥匙在给代码加锁的那个线程手里，只有加锁的线程运行完这段代码，才会给代码解锁。然后其他线程才能执行这段代码。

public class SyTest {
private String a="123";
private String b="321";
 private void test1() throws InterruptedException {
  synchronized (a.getClass()) {
   System.out.println("A");
   Thread.sleep(1000);
  }
 }
private void test2() throws InterruptedException {
  synchronized (b.getClass()) {
   System.out.println("B");
   Thread.sleep(1000);
  }
}
public static void main(String args[]){
      new Thread(){
          public void run(){
                try {
                    new SyTest().test1();
                } catch (InterruptedException ex) {
                    Logger.getLogger(SyTest.class.getName()).log(Level.SEVERE, null, ex);
                }
          }
      }.start();
      new Thread(){
          public void run(){
                try {
                    new SyTest().test2();
                } catch (InterruptedException ex) {
                    Logger.getLogger(SyTest.class.getName()).log(Level.SEVERE, null, ex);
                }
          }
      }.start();
  }
}
A先打出来，然后休眠一段。但是此时A处于休眠状态，没有释放锁A.class，所以之后B需要等一段才输出。a.getClass()和b.getClass()其实是对同一对象进行加锁。

4.java里面的volatile修饰符。

Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。
这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。
而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。
使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。
由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。 
就跟C中的一样 禁止编译器进行优化~~~~

5.上转型对象调用重写的静态方法

多态是动态绑定，才有父类引用指向子类对象。
而如果是调用的是静态变量或方法的，因为是静态，则不存在多态，所以，父类引用调用和子类同名的静态方法或静态变量时，会调用父类中的而不是子类中的方法。
如果父类中的方法是静态的，子类也有一个相同的方法名的方法，这也不叫重写，属于两个方法。因为静态方法和变量属于类，不参与多态之中来。