Thinking in java 笔记

1：static函数中不能直接使用非static 的函数和数据。

2：只有数据成员回自动初始化，函数中的变量是不会自动初始化的。

3：this表示此一对象，当前对象；用在constructor中 this(arg)调用另外一个constructor,但是不能使用第二次this(arg),且必须放在首行；this.s = s ;

 Super：普通继承类中调用父类函数 super.method(args)；

构造函数中调用父类构造函数用super(args),且只能在首行调用一次

如果基类中写了非default构造函数，则子类必须调用super(args);

只要自己写了构造函数，无论有参无参，都不会有默认的构造函数，生成该实例时，都需要调用自己的构造函数。

习惯：自己写构造函数，子类主动调用父类构造函数。

4：初始化顺序 (1)对象产生或static数据成员或函数调用，装载class文件

              (2)装载时就初始化所有的static数据/函数无论用到没用到

              (3)初始化primitiva 和 references

              (4)定义处的初始化

              (5)执行构造函数，只有new时才调用，单纯用static不调用

5:  在类中定义一数据成员时候直接初始化，不可以分行初始化。

即：ClassName aa ；

    aa ＝ new ClassName()；

int i；i=1;

必须int i ＝ 1；ClassName aa＝ new ClassName();

但可以int i；ClassName aa ;  {i=1;aa=New ClassName()}

或者 static int i;staic ClassName aa ;

static{i=1;aa=New ClassName()}

6: 数组：

在定义并初始化时是不能制定其大小的

(1)  Integer[] a = new Integer[]{new Integer(1),new Integer(2),};

(2)  Integer[] a = {new Integer(1),new Integer(2),};

(3)  Integer[] a;

a = new Integer[]{new Integer(3),new Integer(3),new Integer(3),};

在类中能够定义并明确初始化；也可只定义，但方法中初始化，包括构造函数；在方法中，可定义，然后初始化。此属性仅仅限制于方法内使用

   以下错误

   a ＝ new Integer[];

   a = {new Integer(3),new Integer(3),new Integer(3),}; a 是一引用
(4) Integer[] a;

a = new Integer[3]; 指定其大小后，只能一个一个初始化                 

   a[0] = new Integer(2);

(5)Integer[] a = new Integer[3]; 指定其大小后，只能一个一个初始化

  a[0] = new Integer(2);
数组的copy，fill，sort，binarySearch，equal  都有静态方法  在java.util.Arrays  System.arrayCopy()？？？？？？？？？？

(6)注意多数组  

 Integer[][] a;

    a = new Integer[3][];

    for (int i = 0; i < a.length; i++) {

      a[i] = new Integer[3];

      for (int j = 0; j < a[i].length; j++) {

        a[i][j] = new Integer(i * j);

      }

}

7：类只有public和default两种.方法和属性各有四种。

8：不能继承构造函数为private的类

9：在函数中定义的变量只能default；
10: 类的构造函数是private，则可通过定义一返回该类的static函数，或者该类类型的static变量，后者只能产生一个类对象。

201垃圾回收相关

10：常量的定义方式常常是 public static final,可能是编译器常量，可能是执行期常量。未在定义处初始化的final变量必须在构造函数中初始化。Final参数时候就相当于PL/SQL的in，正常情况的参数是 in out

    Final函数是子类不能改变的，final类是不能继承的。

11：类装载时即对static 变量，static块进行初始化，而static方法在使用时才调用。

12：初始化顺序: 装载基类，子类à基类，子类的static初始化à变量设置初值和nullà如果有new，则定义处初始化后才是基类构造函数，子类构造函数。

         à如只是使用static变量，变量定义处仍不进行初始化。先构成基类才子类。

13：构造函数以及构造函数之前初始化时候不要调用非final和private型的函数，否则有可能调用子类中被覆写的方法。P241

   一个类是不知道子类的，但是在使用父类的函数时候实际调用的确实子类的。

14：接口中的数据成员自动是 public static final可以方便的产生常量群，而函数自动是public

15：嵌套于类中的private interface 可以被实现为嵌套类中的public，private类，但是这种实现private签套接口的类只能被拥有其使用权的类所操纵。P259

16：外围类和外围接口只能是public 和default，而内隐的可以是任何。

17：interface 中的函数自动为 public，实现 interface 时候必须将函数声名为 public，interface中数据是public static final，但不能是blank final，因为blank fianal需要在构造函数中初始化。可以是执行期初始化final，如：final int i；

    i ＝ new Random().nextInt();

17: 嵌套于接口的接口只能为 public

17：可以通过 extends  来扩充 interface

17：匿名class可以实现接口，可以继承类，但匿名类的父类有非default的构造函数时候，只需在new时将参数传入即可。因无构造函数，故采用实体初始化的方式{int a ；a= a;}

18：匿名class中用到的别的对象必须声名为final

19: 非static inner class对象拥有一个指向outer class的引用，所以产生非static inner class时候必须先有outer对象，且可以访问任何外围类对象。Static inner class对象产生时不需要外围类对象存在，也就无法访问外围类的对象。

20: private 的内隐类实现其他接口后，在另外一类中得到指向接口的引用后是无法向下转换的。

21：继承内隐类时因为需要outer类，所以内隐类的子类的构造函数需要一个外围类的引用。继承outer类时，覆写内隐类是没有作用的，虽无作用，但也可以明确指出：子类中的inner类继承父类中的inner类，且可以同名，在这种情况下，父类中生成的inner类不会扩散，即不会生成子类中的inner类。见p275

22：在外类中取得非static内隐类必须有outer对象，有了outer对象后可以通过函数或者new，但是不能直接new private型的内隐类。如果该内隐类实现别的接口，或者继承别的类，则无法向下强制转型。

    产生inner类对象时候必须有一个指向outer对象的引用，除了statc inner类

      在inner中取得outer类时候，只需OuterClassName.this;

      在外类中取用static inner类对象时，可以在outer类中定义一返回static inner类对象的static函数，然后外类中调用该函数取得static inner类

public class Untitled2 {

  static class A {

    int i = 4;

  }

 

 

  class B {}

 

 

  A bb() { 

//    System.out.println(Untitled2.this); àthis是非static

//    new Untitled2().new A(); àA不需outer类，也不能有

    return new A();

  }

 

 

  B cc() {

    new Untitled2().new B();  à必须有outer类，

    return new B();à所以可以直接new，因为调用cc()时已有outer类对象

  }

 

 

  public static void main(String[] args) {

    A sdfs = new A();

//   new Untitled2().new A();à不需，也不能有outer类对象

//    new B(); à没有outer对象

    B dd = new Untitled2().new B();

  }

 

 

}

 

 

class Mihu {

  static void lasjf() {

//   new A();

    System.out.println(Untitled2.bb().i); à需要bb()是static

//    new B();

    new Untitled2().new B();

    new Untitled2().cc();

  }                                        }