1. 目录
   
2. 1.        类与对象        3
   
3. 1.1.        定义类        3
   
4. 1.2.        定义成员        3
   
5. 1.3.        定义方法        3
   
6. 1.4.        对象的创建及其内存分配        4
   
7. 1.5.        this的概念        5
   
8. 1.6.        对象与二维数组的内存分配图        5
   
9. 2.        方法        6
   
10. 2.1.        方法的参数传递        6
    
11. 2.2.        递归方法        7
    
12. 2.3.        方法重载        8
    
13. 2.4.        变量：成员变量VS局部变量        8
    
14. 2.5.        Main函数详解        9
    
15. 3.        三大特性一：封装（encapsulation）        9
    
16. 3.1.        封装的特点及原则        9
    
17. 3.2.        访问控制修饰符        9
    
18. 3.3.        构造函数        10
    
19. 3.4.        静态特点及注意事项        11
    
20. 3.5.        静态VS非静态        11
    
21. 3.6.        静态什么时候用？        11
    
22. 3.7.        静态代码块的特点和作用？        11
    
23. 3.8.        单例设计模式        12
    
24. 4.        三大特性二：继承（inheritance）        12
    
25. 4.1.        什么是继承        13
    
26. 4.2.        为什么要使用继承        13
    
27. 4.3.        继承的特点        13
    
28. 4.4.        强制类型转换        13
    
29. 4.5.        子类覆盖（Override）父类方法        13
    
30. 4.6.        继承的应用细节        14
    
31. 4.7.        子类对象实例化        14
    
32. 4.8.        子类当做父类使用时需要注意        14
    
33. 4.9.        抽象类概述        15
    
34. 4.10.        抽象的抽象：接口        15
    
35. 4.11.        一个对象的实例化过程：        17
    
36. 5.        三大特性三：多态（Polymorphism）        18
    
37. 5.1.        多态概述        18
    
38. 5.2.        多态成员特点        18
    
39. 5.3.        向上转型        18
    
40. 5.4.        Instanceof        19
    
41. 5.5.        final修饰符        20
    
42. 5.6.        内部类概述        20
    
43. 5.7.        内部类使用方法及注意        22
    
44. 5.8.        静态内部类&局部内部类        24
    
45. 5.9.        匿名内部类        25
    
46. 6.        错误收集        25
    
47. 7.        异常        25
    
48. 7.1.        异常概述        26
    
49. 7.2.        异常小例一：        27
    
50. 7.3.        异常的分类        28
    
51. 7.4.        throw VS throws        29
    
52. 7.5.        异常处理机制        31
    
53. 7.6.        什么时候try什么时候throw        31
    
54. 7.7.        访问异常信息        32
    
55. 7.8.        异常处理原则        33
    
56. 7.9.        try catch final组合特点        33
    
57. 7.10.        异常处理中的Finally        34
    
58. 8.        线程        34
    
59. 8.1.        进程与线程        34
    
60. 8.2.        多线程的利与弊        35
    
61. 8.3.        JVM启动时的多线程        35
    
62. 8.4.        创建线程两种方式和区别        36
    
63. 8.5.        start方法和run方法区别        37
    
64. 8.6. 这两天家里有点事..正在整理

复制代码

Java是面向对象的程序设计语言，提供了定义类、成员等基本的功能，类可以理解为一种自定义的数据类型，可以使用类来定义变量，所有使用类定义的变量都是引用变量，他们会引用到类的对象。

类是用于描述客观世界里某一类对象的共同特征，对象则是类的具体存在，java使用构造函数来创建该类的对象

面向对象的特征：

封装(encapsulation)

继承(inheritance)

多态(polymorphism)

1.  类与对象

l  类是对象的描述，对象是类的实例。将执行者———》》》》指挥者

邱俊杰 发表于 2012-4-23 15:32
之前有看到一个网站也是你的名字、是什么回事？你的网站么？

嗯 个人博客 www.itcast.info :lol

之前有看到一个网站也是你的名字、是什么回事？你的网站么？