scjp的基础概念

1.我们不能改变一个数组的大小，可以通过new一个新的数组，然后把值赋过去来得一个内容和原来一样而大小不一样的数组。

2.当数组越界时，可以编译，但在运行时会报ArrayIndexOutOfBoundsException的异常。

3.length是数组的一个属性，而不是方法。

4.数组初始化的方法：

  int[] i = {0,1,2,3,4,5};

  int i[] = {0,1,2,3,4,5};

  int []i = new int[]{0,1,2,3,4,5};

target 2 定义类和变量

1.protected是在同一个包内可见，子类也可见；没有访问修饰符的类变量在类内部和同一个包的子类可见，不在同一个包内的

子类不可见。

2.static修饰符可以用于内部类，方法和变量。一个类的所有实例共享类的static部分。

3.static部分不能引用非static变量，否则会编译错误。

4.static方法不能在子类重写为非static方法，同样，非static方法也不能重写为static方法。但重载是可以的。

5.static方法在子类中不能被重写，但可以被隐藏(static方法是静态绑定的)。

6.native只能用来修饰方法，不能以代码块来结尾，只能以分号。如：public native void fastcalc();

7.abstract可以用在类和方法上。

8.如果一个类含有一个或多个abstract方法，或者继承了不准备实现的abstract方法，那么这个类一定要声明为abstract，否则编译错误。

9.final可以用在类，方法和变量上。

10.任何final类中的方法，自动成为final方法。

11.final方法不能在子类中重写，否则会编译错误。

12.final变量的值不能被修改，并且必须要在一定的时候赋值(定义或构造器中)。

13.synchronized保证同一时间只有一个线程访问方法或程序块。

14.transient表示一个变量在序列化过程中不能被写出？

15.volatile它告诉编译器一个变量可能在线程异步时被修改？

16.方法的返回类型必须紧跟在方法名之前。

17.Everything declared in interface are implicit or explicit public. If you don't put anything there, they are public (not default). No access modifiers other than public allowed.

18.在定义Interface的时候，只能用public或(default)修饰.

19.final 变量一定要初始化，否则编译报错。可以在定义的时候就初始化，或者在构造器里初始化，不能在其他的方法内部初始化，否则会报The final field can't be assigned.

20.一个java文件最多只能有一个public类，如果一个java文件中没有public限定符的类，该文件仍然可以正常运行.

1.修饰interface的modifier有两个：public和default。 如果是default的话，那么它就和class一样，只能在包内可见。修饰class的只有public，default，abstract，final，而且abstract和final不能同时使用。

2.interface里边的variables都是public static final的；所有method都是public abstract。

3.override rules:方法名、返回类型、参数必须和父类的一样；Access modifier不能比原来的范围小；如果父类方法没throws exception，那么子类不能throws exception，如果父类方法throws exception，那么子类可以不throws exception，或throws的exception不能比原来的还要general(父子都可以抛出多个exception，只要父类的exception有一个覆盖子类的就可以)。

4.modifier之间没有先后顺序，如：public static final,final static public.  static和abstract不能并存，所有在interface里边的method不能使static的。

5.在class内部定义的interface的modifier只能是public，protected，private，abstract&static，并且abstract和static可以同时存在。

6.class不能implements定义在它内部的interface。

target 3 默认的构造器

1.任何被认为是构造器的方法都没有返回值。如果一个方法有和类名一样的名字还有返回值，那么它不是构造器。

2.如果有了一个带参数的构造器，那么无参构造器将被释放，在程序中就不能new一个无参的实例。

3.构造方法不能是abstract,static,synchronized,native和final.

4.当父类定义了带参的构造器，而没有定义无参的构造器的时候，new子类的时候一定要明确制定父类的构造器，否则会编译错误。

5.当构造函数有返回值的时候，它就不再是构造函数了，就是一个普通的函数，它可以与构造函数有一样的参数，或者说他们就毫无关联了。

6.如果一个类被声明为abstract了，那么即使它没有一个abstract方法，也不能new那个类的实例。All classes which have abstract method(s) must be declared abstract, but not vice versa.

target 4 重载和重写

1.在子类中重写方法时，必须也父类的方法名和返回值一致，否则编译器会认为是重载，报有两个相同方法的异常。如果父类的方法是private的（也就是子类继承不到的方法），那么就可以方法名相同，返回类型不同，他们就没有什么关系了。

chapter 2 流程控制和差错处理

target 5 if和switch语句

1.switch语句的参数必须是byte,char,short和int。

2.defaut;语句不一定要放在末尾，放在开始，程序运行的结果是一样的。满足条件的还是会先执行。

3.如果case没有break;语句，那么它后面的不管条件满足与否，都会执行。

target 6 循环，continue和break

1.

chapter 6 重写、重载、运行时类型和OO

target 3

1.Outer.Inner i = new Outer().Inner();在创建内部类的同时创建了外部类的实例。如果是static inner class，那么也可以用new Outer.Inner();来创建内部类的实例。

2.成员类无法脱离外部类的实例而存在，它可以访问外部类中的变量。

3.局部类只有在它的代码块和方法中可见。在局部类定义中的代码只能使用包容块中的final局部变量或final方法的参数。

4.一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员，但可以有final static成员。

  二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量。

  三.非静态内部类的非静态成员可以访问外部类的非静态变量。

5.定义在类内部的内部类只能用private,protected,public, static, final, abstract

  定义在方法内部的内部类只能用final, abstract

  定义在方法内部的内部类只能访问方法的final型变量或final型参数

  方法内部的属性只能声明为final。

6.所有种类的内部类都可以继承、都可以实现零个或多个接口，可以继承和实现Outer类或接口。

7.静态方法内部不能含有静态内部类。

8.final variables cannot be changed.

 final methods cannot be overridden.

 final classes cannot be inherited.

9.null可以访问静态方法或变量，如

class ST {

  static int n = 3;

  static int getInt() {

    return n + 35;

  }

  public static void main(String[] args) {

    ST st = null; // st has the type of ST

    System.out.println(st.n);       // 3

    System.out.println(st.getInt());// 38

    // the above lines are equivalent to the followings

    System.out.println(ST.n);       // 3

    System.out.println(ST.getInt());// 38

  }

}

10.The default constructor implicitly generated by Java compiler should have the same accessibility as the class.

11.Q. What kind of Java methods does not participate polymorphism?

A:Polymorphism for Java method is always there except the following three situations:

   1. The method is declared as final

   2. The method is declared as private

   3. The method is declared as static In those three cases, static binding will be performed by the compiler. Compiler does not have the knowledge, nor care about the method was, is, or will be overridden by none, one, or many subclass(es). The decision is made by the runtime, which is called dynamic binding.

12.静态绑定的有：field, private method, static method, final method

动态绑定的有：override,In Java, methods are default to dynamic binding, unless they are declared as static, private, or final.

13.当我们用Base类的引用指向Sub类的Instance,我们用该引用当用field或method的时候，编译器只会检查Base类有没有相应的field(static binding)或method，没有的话就会编译错误。

14.当用Integer, Float, Double类型作参数时，传递的还是值，不是引用。？？？？

15.只有创建静态内部类的时候不需要实例化外部类，也不能通过Outer Instance来创建，只能Outer.Inner i = new Outer.Inner();创建。而非静态内部类就需要外部类的实例来创建，如Outer.Inner i = new Outer().new Inner();

16.class 不可能同时是final和abstract的。

17.申明static方法->定义static方法和执行static块（从上往下，没有先后关系）->声明非静态方法->定义和执行非静态块。

18.整形(byte,char,short,int)和整形相加时如果结果超出范围(编译器会计算它的结果)implicitly convert to int; int + float = float; int + double = double. (byte,char,short,int) + long = long; long + float = float; long + double = double; float + double = double.

 

 

Chapter 7  多线程

1. 创建线程有两个方法：继承Thread或实现Runnable接口。可以同时继承Thread和实现Runnable接口。
2. run()在Thread类和Runnable接口中都被定义为public void的，override的时候必须写成public void run(){}的形式。

attachment 1:
1. 当对象被做为其它对象方法的参数使用时，传入该对象方法的是对象的地址，在方法中对对象内部变量的重新赋值造成的改变会立即实际改变作用，而对做为参 数传入的对象地址重新赋值会在方法调用结束后还原为原来的地址。基本类型变量做为方法的参数时，只是传值进去，方法结束后，变量仍然是原来的值。
2.判断方法是否覆盖要看该的方法的返回值和参数是不是精确匹配，如果仅仅是方法的参数发生变化，返回值不变就是重载，如果子类中的同名方法，返回值发生改变将不能编译，提示类型不兼容。
3. 内部类：内部类如果定义在外部类的方法中，那么它可以访问外部类的所有实例变量（无论其访问控制符是什么），只能访问该方法的常量（有final控制 符）。在方法中定义的内部类，必须在方法中创建内部类对象，外部类才能通过该方法访问内部类。方法中的内部不能是static的，如果一个类中的内部类是 静态的，那么它就自动升级为顶级类，静态的内部类中的方法，无论静态还是非静态的，都只能直接访问外部类中的静态变量，在创建外部类对象的实例后，才能访 问外部类中的非静态变量。访问类内部定义的内部类（非方法内定义的），可以用new 外部类（）.new 内部类(),来创建类的实例。静态内部类创建实例。outer.inner classname=new outer.inner();
4.赋值语句：先对右边的语句进行计算后再把值赋给左边（计算按照运算符的优先级来）。例如：
float f=1/3;//f=0.0
float f=1/3f;//f=0.33333
float f=10;//f=10.0
5. 基本类型取值范围：char类的取值范围是0->2e(16)-1,其它整数类型的取值范围均为-2e(X)->2e(x)-1，没有任何后 缀的整数java默认为int型的，没有任何后缀的小数默认为double型的。010是int型的八进制数，0x11是int型的16进制数，如果 double型的也可以使用0x,0,但前提必须这个double型不能是小数或有小数后缀。
1//int,1.0//double,1L//(大小写均可以)long，1.0F//(大小写均可以)float,

6. 接口：所有接口中定义的变量均为public static final常量，public static final可以不写出来，但在定义时必须对这些常量赋值。所定义的所有方法必须为public，public也可以不写出来。接口方法不能用 static，接口可以用abstarct来修饰。
7.构造方法：构造方法没有返回值，连void也不能有，如果有了就成了普通的方法了。构造方 法调用super时，只能在第一行调用。构造方法不能是静态的。构造方法只能用public,protected,private三种限定符，但 private定义的构造方法不能在其它类中构造该类的对象，void classname()不是构造方法，但它是一个普通的方法，可以在类中显式的调用,class.classname();子类中建立子类对象时会首先调 用父类的无参构造方法。如果父类已经有了有参构造方法，java将不会再为类生成一个默认的无参构造方法，这时必须手动设置一个无参构造方法，以保证建立 子类对象时不会出错。构造方法不能被子类继承，例如：class Test extends Thread{};Test t=new Test(runable r);无法编译，因为没有Test（r）这个构造方法。
8.一个java文件最多只能有一个public类，如果一个java文件中没有public限定符的类，该文件仍然可以正常运行。
9. 静态方法：静态方法不能被覆盖为非静态方法，静态方法如果被覆盖为静态方法，那么覆盖的方法将被隐藏。静态方法中不可调用非静态方法和变量（原因就是后面 的），静态方法可以在没有建立类的实例之前被调用，静态方法中不用访问隐式变量this（原因它是非静态的），非静态的方法中不能定义静态的变量。非静态 的方法也不能覆盖为静态方法。
10.关键字：main,sizeof都不是java的keyword。goto,const虽然是keyword，但至少偿末使用。true,false,null虽然不是关键字，但它们是java定义的常量，也不能做为变量名。关键字全部都是小写的。
11.String中length()是一个方法不是属性，而在char[]中，length是属性而不是方法。
12. 基本类型变量初值问题：如果在方法内定义的变量，必须在使用前赋值。如果在方法外的类变量，在方法内使用时，可以不用赋初值，系统自动就赋了一个该类型的 缺省值。如果是基本类型的数组，无论在方法外还是在方法内，如果没有赋初值，系统都会自动赋以其缺省值，如果是对象数组，则缺省初值为null。
13.非静态的内部类中不能有静态的方法和变量。
14.多态：一个子类可以被看作是一个父类，并可以强制转换成父类，但父类不能强制转换成子类。多态将新创建的子类赋值给父类时，会传递一个子类的this指针给该父类对象，如果对该父类对象调用在子类中覆盖的方法时，会动态的绑定为子类的方法。例如：
class Super {
    public void T1(){
        System.out.print(”t1”);
    }
}
class A extends Super {
public void T1(){
    System.out.print(”t2”);
}
public static void main(){
    Super s=new A();
    s.T1();//将打印t2
}
} 
但如果是T1是static的，那么子类中的T1将无法覆盖父类中的T1，因为这时子类中的T1在多态绑定时会自动隐藏。
15.垃圾收集：一个程序可建议垃圾收集，runtime.gc(),System.gc()方法可以建议垃圾收集，但不能强制垃圾收集，不同的java开发环境中的垃圾处理机制不太一样。
16.swicth(i)里面的i只能接受int以下的基本数据类型，并且从匹配条件开始执行，直到到break或swicth结束。