三周学习简单的总结 = =

 

[package]

Package实际上同时表现了文件的物理路径，同时定义了default类型的对象的范围（在同一个package下应许访问）。

可以用import导入，也可以直接用package路径.访问。

[API]

把它当成库函数来使了 = =。

[==与equals]

在JAVA中，==只比较等号两端是否是同一个对象，

要比较两个对象的值，需要用相关的equals方法。

[JUnit /单元测试思想]

@_@ 好抽象。。

[OO – 面向对象]

@_@ 依然好抽象。。

[设计模式]

= = 要结合具体应用才比较好理解阿。

[static]

米有什么总结。。 - -

[final]

final可以声明类（最终类），但是该类将无法被其他类继承。

final方法不能被重写。

[继承与组合]

继承：子类是由父类衍生出来。JAVA中是单继承，不过可以用接口实现多继承。

组合：在该类中构造了要组合的对象，捆绑销售，组合的类之间并非派生关系。

[重载与重写]

重写是指子类对父类中已经定义的方法进行具体实现（即覆盖）——它的方法名和参数列表都与父类中的一致。

重载一般存在于同一个类中，同一个方法可以写多个，区别在参数列表不同。

[在构造函数中使用super或this调用构造器]

必须放在第一句。

[各种块的执行顺序（static,main入口,无名块,构造器）]

（假设main入口所在的类为Main）

       Main类的static块（只运行一次） 》 main方法中用到的各个类{

              各个类内部的顺序：

                     父类的static块（只运行一次） >

                     子类的static块（只运行一次） >

                     父类的无名块（每次都运行）    >

                     父类的构造器（如果没有用super特别声明就调用默认构造器）>

                     子类的无名块（每次都运行）    >

                     子类的构造器

              }

       // 如果一个类没有构造相应对象，则该类中的任意块都不会执行。

【相关代码】

1. class A
2. {
3.     static{
4.         System.out.println("a. static");
5.     }
6.     {
7.         System.out.println("a. noname1");
8.     }
9.     public A()
10.     {
11.         System.out.println("a. constructor");
12.     }
13.     {
14.         System.out.println("a. noname2");
15.     }
16. }
18. abstract class B
19. {
20.     static{
21.         System.out.println("b . static");
22.     }
23.     {
24.         System.out.println("b. noname");
25.     }
26.     public B()
27.     {
28.         System.out.println("b. constructor");
29.     }
30.     public B(String b){
31.         System.out.println("b. string constructor");
32.     }
33. }
35. class C extends B
36. {
37.     static{
38.         System.out.println("c . static");
39.     }
40.     {
41.         System.out.println("c. noname");
42.     }
43.     public C()
44.     {
45.         System.out.println("c. constructor");
46.     }
47.     public C(String c){
48.         System.out.println("c. string constructor");
49.     }
50. }
52. class D
53. {
54.     static{
55.         System.out.println("d. static");
56.     }
57.     {
58.         System.out.println("d. noname1");
59.     }
60.     public D()
61.     {
62.         System.out.println("d. constructor");
63.     }
64.     {
65.         System.out.println("d. noname2");
66.     }
67. }
69. class Main 
70. {
71.     static{
72.         System.out.println("main . static");
73.     }
74.     {
75.         System.out.println("main. noname");
76.     }
77.     public static void main(String[] args) 
78.     {
79.         System.out.println("main");
80.         Main main = new Main();
81.         B b = new C();
82.         C c = new C("C");
83.         A a = new A();
84.     }
85.     {
86.         System.out.println("main. noname2");
87.     }
88.     public Main(){
89.         C c= new C();
90.         System.out.println("main. constructor");
91.     }
92. }

【执行结果】

1.                    main. static
2.                    main
3.                    main. noname
4.                    main. noname2
5.                    b. static
6.                    c. static
7.                    b. noname
8.                    b. constructor
9.                    c. noname
10.                    c. constructor
11.                    main. constructor
12.                    b.noname
13.                    b. constructor
14.                    c. noname
15.                    c. constructor
16.                    b. noname
17.                    b. constructor
18.                    c. noname
19.                    c. string constructor
20.                    a. static
21.                    a. noname1
22.                    a. noname2
23.                    a. constructor

[抽象]

在抽象类中可以定义变量和方法（没有具体实现的方法要定义为抽象方法——当然构造函数不可以是抽象方法）。

不可以构造抽象类的具体对象，但是可以利用虚方法多态——不能new出来，但可以声明该类型的引用并使它指向该类型的具体子类对象。

抽象类的非抽象子类，必须实现抽象类中定义的所有抽象方法，可以重写抽象类中的其他方法。

抽象方法只有在抽象类中实现。

[接口]

没有什么特殊感想……只是把它当成一个特殊的抽象类来用。

它与抽象类的不同貌似在于：

l  接口使多继承得以实现：一个类可以实现多个接口；而一个子类只能继承一个父类。

{{{

补充：为什么JAVA中不应许类的多继承？

假设A类与B类中都有一个方法test。C同时继承了A,B两个类，那么C调用的test方法究竟是A还是B中的test()呢？而接口中只有方法的定义，没有方法的具体实现，test()还是要在C中重写，因此不会出现类的多继承时引发的问题。

}}}

l  接口中不能带有具体方法的实现内容；而一个抽象类中可以对其中的非抽象方法写具体实现。

l  接口中只能写常量——虽然表面上它也可以写变量（需要赋初值），但是在实现对该变量的操作时会有错误提示：无法对最终变量指定值——说明它其中的变量都默认带有final属性和static的属性，所有它的衍生对象该变量的值都是唯一且相同的；抽象类中则既可以写常量也可以写变量。

l  接口中的常量，范围只能声明为public或默认，不能声明为protected或private。

l  接口没有内部接口；抽象类有内部类 = =。

l  接口不能创建对象；抽象类可以用虚方法调用实现。

l  接口不能继承类，可以继承多个接口（使用extends关键字）；类可以继承一个父类（使用extends关键字，该父类可以不是抽象类），还可以继承多个接口（使用implements关键字）。

[多态（与虚方法调用）]

一个对象只能有一个明确的数据类型，而这个类型是指声明它时的类型。

比如B类是A类的子类，

我们可以写 A a = new B();来声明一个B对象（虚方法调用），

但它的本质还是A类型。该语句就相当于A a = null; a = new B();

{{{

       //    同理，A a = new A();时，实际上也是拆分成A a = null; a = new A();两句。

说明实质上是该语句生成了两个对象，一个是A类对象，另一个是指向该对象的引用对象。

}}}

我们使用该对象时只能调用A类中的变量和方法，无法调用B类中新增加的变量和方法。

※  为了确定该对象是A类的哪一个子类，可以用instanceof 关键字来判断。

[内部类]

就是类里面定义的类。。点点点就可以叻。。与外部类的区别在于

l  内部类可以声明为protected或private，也可以用static修饰。

l  static的内部类不能调用外部类中的非static变量和方法；

非static的内部类不能声明static变量和方法。

[异常处理]

对于C++没学完的我来说很新鲜的东西 = = 。但是不知道有什么好总结。。

自定义的异常类就是Exception类的抽象而已。。它代表了一个具体的异常（比如自定义的乌鸦喝水里的“装入物过大”异常——TooBigException = =）。。

如果直接throw/throws Exception的话，范围过大，因此最好判断细节的具体的Exception。

在try-catch-finally中，即使try/catch中已经return，finally块的语句依然会执行。

[集合框架]

少少看了下。其实我觉得和C++的STL很像 = =。。

[总结]

= = 实在是好抽象…。

 

[scjp09]linyq: 2008-8-2