Java 读书笔记 5

初始化与清理

1.重载和区分重载
： 书上例子很好，洗衣服，洗车，洗狗；同样都是洗，却洗的是不一样的东西，似乎用一个名字做不同的事情，理所应当；
而且呢，还告诉我们为什么不一样，因为给的参数不一样，当来着是衣服的时候，就用洗衣服的方式来洗，如果是车，就用车的方式；
不可以通过返回值区分，你洗狗洗出来特干净，他就不干净，但是方法实际是相同的；
不可以通过访问修饰符区分，你就给你家洗衣服，洗衣店谁家衣服都洗，但是方法还是一样的；

2.基本类型与重载；
简单来说呢，基本类型在重载时，由于类型不同重载就会出现问题；
上代码喽

public class Test  {
    public void testfloat(float a)
    {
        System.out.println("lll");
    }
    public  void  testdouble(double a)
    {
        System.out.println("222");
    }
}

        Test test = new Test();
        double a = 0;
        float b= 0;
        test.testfloat(a);//这样写报错    大类型不能向下转换，直接报错
        test.testfloat((float) a);
        test.testdouble(b);    小类型转化为大类型

其实想想就明白了，32位转化为64位。又没什么损失，反过来的话，就会丢失精度；况且如果能够来回转的话，我估计你最后都不知道出来的是哪个类型的；

3.this关键字

• 一般的this肯定这么用的最多，这时其实不写this也是一样的啦；写上this更加清晰，指的是本对象里的某个属性等于参数。

public class Hello { 

    String s = "Hello"; 

    public Hello(String s){ 
        System.out.println("s = " + s); 
        System.out.println("1 -> this.s = " + this.s); 
        this.s = s; 
        System.out.println("2 -> this.s = " + this.s); 
    } 

    public static void main(String[] args) { 
    Hello x=new Hello("HelloWorld!"); 
    } 
}

• 还有就是调用自己的其他构造函数，继承什么的题目里经常会有的那种

public class Flower{ 
           Flower (int petals){} 
           Flower(String ss){} 
           Flower(int petals, Sting ss){ 
                //petals++;调用另一个构造函数的语句必须在最起始的位置 
                this(petals); 
               //this(ss);会产生错误，因为在一个构造函数中只能调用一个构造函数 
           } 
} 

• 这次学到了这个

public class A { 
  public A() { 
    new B(this).print();     //将自身当成参数传递过去
  } 

  public void print() { 
    System.out.println("Hello from A!"); 
  } 
} 

public class B { 
  A a; 
  public B(A a) { 
    this.a = a; 
  } 

  public void print() { 
    a.print(); 
    System.out.println("Hello from B!"); 
  } 
} 

• 匿名类 this一般代表整个匿名类，日后再说

public class A { 
    int i = 1; 

    public A() { 
        Thread thread = new Thread() { 
            public void run() { 
                for(;;) { 
                    A.this.run();       //匿名类
                    try { 
                        sleep(1000); 
                    } catch(InterruptedException ie) {     }

                } 
           } 
        }; //注意这里有; 
        thread.start(); 
    } 

    public void run() { 
        System.out.println("i = " + i); 
        i++; 
    } 

    public static void main(String[] args) throws Exception { 
        new A(); 
    }
} 

初始化顺序（对于类来说）

1.静态变量初始化 //由于static不可初始化局部变量，就没有小函数的担心啦；
2.普通变量初始化
3.变量都初始化后，方法开始执行