从头认识java-目录

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/raylee2007/article/details/49100439

第一章 对象

1.1 编程语言抽象过程以及java的基础特性

1.2 对象-服务提供者

1.3 隐藏具体实现

1.4 复用代码

1.4 复用代码

1.5 继承(1)

1.5 继承(2)

1.6 多态

1.7 单根继承与集合

1.8 创建和操纵对象(1)

1.8 创建和操纵对象(2)

第二章 操作符

2.1 操作符

2.2 算术操作符

2.3 自增自减与关系操作符

2.4 逻辑运算符

2.5 三元运算符和字符串操作符

2.6 逗号操作符

第三章 控制执行流程

3.1 for each

3.2 return break continue

第四章 初始化与清理

4.1 创建与初始化对象

4.2 方法重载

4.3 默认构造器

4.4 this

4.5 对象的清理

4.6 成员的初始化

4.7 构造器初始化(1)

4.7 构造器初始化(2)

4.7 构造器初始化(3)

4.8 数组的初始化(1)

4.8 数组的初始化(2)-可变参数列表

4.9 枚举类型

第五章 访问权限

5.1 为什么需要访问权限?

5.2 包(package)

5.3 public private protected

第六章 复用类

6.1 聚合(aggregation)

6.2 继承(Generalization)(1)

6.2 继承(Generalization)(2)

6.3 组合使用聚合和继承

6.4 如何在聚合与继承之间选择

6.5 向上转型

6.6 final(1)-属性域

6.6 final(2)-属性域

6.6 final(3)-方法

6.6 final(4)-类与忠告

6.7 初始化与类的加载

第七章 接口

7.1 抽象类与抽象方法

7.2 接口

7.3 接口怎样解耦?

7.4 实现多重接口

7.5 怎样通过继承扩展接口?

7.6 适配设计模式究竟适配类?还是适配接口?

7.7 嵌套接口

7.8 接口与工厂模式

第八章 内部类

8.1 内部类

8.2 链接到外部类

8.3 内部类的.this和.new语法

8.4 内部类与向上转型

8.5 在方法和作用域里的内部类

8.6 匿名内部类

8.8 使用匿名内部类改造7.8章节的工厂方法

8.9 嵌套类

8.10 接口里面的类

8.11 为什么需要内部类?

8.11 为什么需要内部类?(2)

8.12 内部类的继承

第九章 容器

9.1 类型安全的容器

9.2 容器类型

9.3 向容器添加一组数据与容器的打印

9.4 List的简介与性能

9.5 迭代器Iterator

9.6 ListIterator的双向迭代

9.7 LinkedList

9.8 栈(Stack)

9.9 set

9.10 Map

9.11 Queue

9.12 接口Collection与Iterator

9.13 foreach与迭代器

第十章 异常

10.1 为什么需要异常?

10.2 异常参数以及捕获异常

10.3 自定义异常类型

10.4 捕获所有异常

10.5 栈轨迹和重新抛出异常

10.6 finally(1)-特性

10.6 finally(2)-finally用来做什么

10.6 finally(3)-异常的丢失

10.7 使用异常的限制汇总

第十一章 字符串

11.1 不变的字符串

11.2 "+"与StringBuilder

11.3 格式化输出(1)

11.3 格式化输出(2)

11.4 正则表达式(1)-感性认知

11.4 正则表达式(2)-基本语法

11.4 正则表达式(3)-Pattern和Matcher

11.5 扫描输入(1)-简介

11.5 扫描输入(2)-scanner的边界与使用正则表达式扫描

第十二章 类型信息

12.1 为什么需要RTTI(Run-Time Type Identification)?

12.2 Class对象(1)-简介

12.2 Class对象(2)-使用与注意点

12.2 Class对象(3)-.class

12.2 Class对象(4)-泛化

12.3 instanceof、isInstance和isAssignableFrom

12.4 利用反射提取类的方法与构造器

12.5 代理以及动态代理

12.6 接口与类型信息(怎么绕过接口直接调用类的所有方法)

第十三章 深入泛型

13.1 泛型与容器(容器的演变)

13.2 利用元组的方式返回多类型对象

13.3 泛型接口的使用

13.4 泛型方法的使用

13.5 利用泛型构建复杂模型

13.6 类型擦除(type erasure)

13.7 什么时候使用泛型?

13.8 类型擦除的问题与解决

13.9 隐式和显示的创建类型实例

13.10 边界的作用

13.11 对比数组与泛型容器,观察类型擦除给泛型容器带来什么问题?

13.12 超类通配符

13.13 无界通配符

13.14 捕捉通配符替代的类型参数

13.15 使用泛型时出现的问题(1)-泛型不能使用基础类型

13.15 使用泛型时出现的问题(2)-实现参数化接口与重载

第十四章 探索数组

14.1 再次对比数组与容器

14.2 进一步了解数组

14.3 多维数组

14.4 Java提供的数组的实用功能(1)

14.4 Java提供的数组的实用功能(2)

第十五章 深入容器

15.1 填充容器(1)

15.1 填充容器(2)

15.1 填充容器(3)-Map

15.2 Collection的常用方法

15.2 Collection的常用方法(2)-注意点

15.3 使用HashSet需要注意的地方

15.4 使用TreeSet需要注意的地方

15.5 使用LinkedHashSet需要注意的地方

15.6 队列(Queue)

15.7 Map(1)-使用数组来简单模拟Map的创建

15.7 Map(2)-介绍HashMap的工作原理-put方法

15.7 Map(3)-介绍HashMap的工作原理-get方法

15.7 Map(4)-介绍HashMap的工作原理-hash碰撞(经常作为面试题)

15.7 Map(5)-介绍HashMap的工作原理-Key变了,能不能get出原来的value?(偶尔作为面试题)

15.7 Map(6)-介绍HashMap的工作原理-装载因子与性能

15.7 Map(7)-TreeMap与LinkedHashMap

第十六章 I/O

16.1 文件目录列表

16.2 遍历文件夹

16.3 IO的典型用法

16.4 nio的读与写(ByteBuffer的使用)

16.5 nio的数据转换

16.6 ByteBuffer是怎样存储的?

第十七章 多线程

17.1 多线程

17.2 线程中断(interrupt)

17.3 线程状态

17.4 详解同步(1)-由竞争条件引发的问题

17.4 详解同步(2)-详解竞争条件

17.4 详解同步(3)-对象锁

17.4 详解同步(4)-同步阻塞、synchronized和volatile

17.4 详解同步(5)- 死锁

17.5 阻塞队列(以生产者消费者模式为例)

17.6 Callable、Future和FutureTask

17.7 执行器(Executor)

第十八章 并发

18.1 为什么需要并发?

18.2 基本的线程机制(1)-初识多线程-1

18.2 基本的线程机制(1)-初识多线程-2

18.2 基本的线程机制(2)-Executors的使用

18.2 基本的线程机制(3)-线程的返回与sleep

18.2 基本的线程机制(4)-优先级

18.2 基本的线程机制(5)-守护线程与非守护线程

18.2 基本的线程机制(6)-使用构造器或者内部类来实现多线程的编码变体

18.2 基本的线程机制(7)join

18.2 基本的线程机制(8)多线程的异常捕捉

18.3 什么时候使用同步?

18.4 java多线程原子性操作里面的坑

18.5 临界区

18.6 synchronized在其他对象上同步和ThreadLocal来消除共享对象的同步问题


后记:

2016-1-28日,从头认识java算是完成了,上面有所不足的就是多线程和并发部分,个人感觉如果在写下去,就不是基础类型的了,因此在这里果断停掉,然后会在后面开一个专门学习多线程和并发的专栏,谢谢大家的支持,大家的点击给了非常大的动力,使得我充满动力,勇往之前,也多谢前面几位网友的校对,指出相应的问题,谢谢。

这个系列就到这里,谢谢!期待你们继续支持我!


特别专辑:

特辑-总结static

特辑-foreach在java里面两种实现原理总结

特辑-你不知道的static与final的位置问题

特辑-你不知道的main函数


这一章节就到这里,谢谢。

-----------------------------------

目录


没有更多推荐了,返回首页