java 学习笔记1

1、java多线程资料：

http://ifeve.com/java-concurrency-thread-directory/

 

2、enum 类，单例模式

必须提供一个私有得构造函数，并且提供一个无任何修饰符的构造函数：  adapterGateeay();private Gateway() {}

 

3、继承类初始化顺序（构造器也是static方法，尽管static关键字没有显示地写出来。因此更确切地讲，类是在其任何static成员被访问时加载的）

1）调用类的static的方法是，首先加载static 的成员，从父类到子类一次类推

2）创建类的对象时，首先加载父类：先是普通成员变量，然后是构造方法；接着是子类：先是普通成员变量，然后是构造方法

例子如下：

package chapter07;

import staticutil.Print.*;

 

class Insect {

privateint i=9;

privateint m = printInit("Insect.m initialized");

protectedint j;

Insect(){

print("i="+ i + ", j=" + j);

j=39;

}

privatestatic int x1 = printInit("static Insect.x1 initialized");

staticint printInit(String s){

print(s);

return47;

}

}

public class Bettleextends Insect {

privateint k = printInit("Bettle.k initialized");

publicBettle(){

print("k="+ k);

print("j="+ j);

}

privatestatic int x2 = printInit("static Bettle.x2 initialized");

publicstatic void main(String[] args){

print("Bettleconstructor");

Bettleb = new Bettle();

}

}

 

static Insect.x1initialized

static Bettle.x2initialized

Bettle constructor

Insect.m initialized

i=9, j=0

Bettle.k initialized

k=47

j=39

 

4、访问修饰符范围public>protected>默认(fridenly)>private

1）public 所有的类都能访问

2）protected 同一个包内可以访问，继承的子类可以访问

3）默认不加修饰符，只是包内访问权限

4）private 只在本类中可以访问

 

5、static关键字的作用

1）修饰变量：只类加载时被初始化，属于类级别的范围，所有对象共享此变量，切值加载一次

2：修饰方法：不需要创建对象即可访问的方法

 

6、final关键字的作用

1）修饰变量：说明该对象的变量在初始化后不能再改变，不同对象可以有不同的值；如果是引用类型只引用的地址不可变

2）修饰方法：说明该方法不能被继承，private修饰的方法默认是final的

3）修饰类：说明该类不能被继承，由于不能被继承隐式指定final的所有方法为final的

 

7、动态绑定

1）java中除static方法和final方法（private方法属于final方法）之外，其他所有方法都是动态绑定

2）变量是在编译时确定的

classSuper {

  public int field = 0;

  public int getField() { return field; }

}

 

classSub extends Super {

  public int field = 1;

  public int getField() { return field; }

  public int getSuperField() { returnsuper.field; }

}

 

publicclass FieldAccess {

  public static void main(String[] args) {

    Super sup = new Sub(); // Upcast

    System.out.println("sup.field = "+ sup.field +

      ", sup.getField() = " +sup.getField());

    Sub sub = new Sub();

    System.out.println("sub.field = "+

      sub.field + ", sub.getField() =" +

      sub.getField() +

      ", sub.getSuperField() = " +

      sub.getSuperField());

  }

}/* Output:

sup.field= 0, sup.getField() = 1

sub.field= 1, sub.getField() = 1, sub.getSuperField() = 0

*///:~

 

//:polymorphism/StaticPolymorphism.java

//Static methods are not polymorphic.

classStaticSuper {

  public static String staticGet() {

    return "Base staticGet()";

  }

  public String dynamicGet() {

    return "Base dynamicGet()";

  }

}

 

classStaticSub extends StaticSuper {

  public static String staticGet() {

    return "Derived staticGet()";

  }

  public String dynamicGet() {

    return "Derived dynamicGet()";

  }

}

 

publicclass StaticPolymorphism {

  public static void main(String[] args) {

    StaticSuper sup = new StaticSub(); //Upcast

    System.out.println(sup.staticGet());

    System.out.println(sup.dynamicGet());

  }

}/* Output:

BasestaticGet()

DeriveddynamicGet()

*///:~

 

8、抽象类

1）关键字abstract，在抽象类中可以包含一个或多个抽象方法，也可以不包含抽想方法

2）抽象类不可以创建具体对象，只能创建子类对象

 

9、接口（interface）

1）所有变量都隐含是static和final的

2）所有方法都隐含是public abstract的，即使不写

 

10、内部类

1）内部类可以访问外部类的所有成员方法

2）创建内部类之前必须创建外部类对象，通过外部类对象创建内部类：.new

publicclass DotNew {

  public class Inner {}

  public static void main(String[] args) {

    DotNew dn = new DotNew();

    DotNew.Inner dni = dn.new Inner();

  }

}///:~

3）内部类返回外部类对象用.this

publicclass DotThis {

  void f() {System.out.println("DotThis.f()"); }

  public class Inner {

    public DotThis outer() {

      return DotThis.this;

      // A plain "this" would beInner's "this"

    }

  }

  public Inner inner() { return new Inner(); }

  public static void main(String[] args) {

    DotThis dt = new DotThis();

    DotThis.Inner dti = dt.inner();

    dti.outer().f();

  }

}/* Output:

DotThis.f()

*///:~

4）匿名内部类，调用用参数的构造器，public class Parcel8 {

  public Wrapping wrapping(int x) {

    // Base constructor call:

    return new Wrapping(x) { // Passconstructor argument.

      public int value() {

        return super.value() * 47;

      }

    }; // Semicolon required

  }

  public static void main(String[] args) {

    Parcel8 p = new Parcel8();

    Wrapping w = p.wrapping(10);

  }

}///:~

publicclass Wrapping {

  private int i;

  public Wrapping(int x) { i = x; }

  public int value() { return i; }

}///:~

使用外部定义的对象例子，需要final修饰参数

publicinterface Destination {

  String readLabel();

}///:~

publicclass Parcel9 {

  // Argument must be final to use inside

  // anonymous inner class:

  public Destination destination(final String dest) {

    return new Destination() {

      private String label = dest;

      public String readLabel() { return label;}

    };

  }

  public static void main(String[] args) {

    Parcel9 p = new Parcel9();

    Destination d =p.destination("Tasmania");

  }

}///:~

5）嵌套类，不需要内部类对象与外围类对象之间有联系，可以将内部类声明为static

 

11、java泛型