当前位置:首页 > 程序设计 >
《Java编程的逻辑》电子书封面

Java编程的逻辑

  • 发布时间:2020年11月24日 16:19:11
  • 作者:马俊昌
  • 大小:39.3M
  • 类别:Java编程电子书
  • 格式:PDF
  • 版本:原书清晰扫描版
  • 评分:9.8

    Java编程的逻辑 PDF 原书清晰扫描版

      给大家带来的一篇关于Java编程相关的电子书资源,介绍了关于Java编程、Java编程逻辑方面的内容,本书是由机械工业出版社出版,格式为PDF,资源大小39.3M,马俊昌编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:8.8。

      内容介绍

      读者评价

      对知识点的讲解步骤清晰易于理解,在某些知识点上对我来说有种醍醐灌顶的感受。当然可能因为篇幅以及本书定位的缘故,对一些如算法的详细具体实现等都会略过,但也会给出基本的算法步骤讲解,总之就是能够点到为止。它对涉及到的部分源码也会给出关键步骤的分析,对像我这种以前看过java源码但看得一头雾水的来说,帮助挺大的。

      当时按出版日期查询,看见了这本书,看目录里面有很多剖析的内容,引起了兴趣,考虑后下单了,看了第一章,想到不错,思维逻辑清晰,讲的特别仔细,有很多平时不注意的地方,感觉后面肯定也不会差的。很荣幸是第一个买的,吼吼。

      市面上的Java书如过江之鲫,数不胜数,深的太深,浅的太浅,唯有这本,深入浅出,既讲了原理又讲了应用,例子又鲜明,关键是作者的文字功底好

      详细解析java源码及实现思想,很全面。不足,某些章节有些无趣,看不下去,就跳过了

      专业评价

      我觉得你的文章跟一般Java教程的不同在于,你把各个知识点的“为什么”都解释得很清楚,非常对味,非常感谢。很多网上教程,都是直接教如何做的,主要是动手能力。可是做完了还是云里雾里。结合你的文章,一下子就通透了。—Hannah

      老马说编程,太好了。把神秘的编程,通俗地讲解,使编程者认识了本质。每个专题的介绍都是深入浅出,有分析,有总结,有详细例子,真是爱不释手的宝书。—张工荣成

      其实老马写的东西网上都有大把的类似文章,但是老马总是能把复杂的东西讲得深入浅出,把看似简单的东西分析得细致深入!—VitaminChen

      文章比其他文章的亮点:有情景带入,重点突出,让人耳目一新,读起来很方便。感谢辛苦付出。—hellojd

      虽然我使用Java多年,可是阅读作者的文章仍然觉得受益匪浅。并发总结得很好,对前面讲的并发知识作了很好的总结和梳理。—彭越

      我不是初学者,依然能从这里学到很多东西。对不了解原理的非初学者来说,像回头捡落下的宝贝似的。关于编码,之前一直云里雾里的,找了几篇文章都没读进去。你的讲解浅显易懂!—Keyirei

      用平实的语言把计算机科学的思维方法由浅入深,娓娓道来,让人如沐春风,醍醐灌顶。这里面没有复制、粘贴的拼凑,更没有生硬古怪的翻译腔,文章中句句都能感觉到老马理解、实践、贯通后表达出来的逻辑严密周全和通透流畅。—杜鹏

      最近从PHP转Java,从您的文章学到了很多知识,很系统地重构了对计算机以及程序语言的认知,很感谢。—房飞

      多线程一直连概念也模糊,阅读后真的受益匪浅!异常处理,看着简单,刚开始学习时,自己也是胡乱try和throw,不过到开发时,才体会到正确处理的重要性。感谢这篇文章。比起学习使用庞大的框架,我觉得基础知识是更重要的,对于一个知识点的理解,细细琢磨,知道实现原理,也是一种收获。—Chain

      内容精选

      函数

      一些可以重复调用的功能,将功能代码封装在函数中,就只需要在多个地方调用该函数即可,可减少冗余代码

      函数的主要组成部分

      • 函数名
      • 参数
      • 操作(函数中实现的功能代码)
      • 返回值 (没返回值的情况下返回类型为void)
      • 修饰符 (进行可操作权限的区分)

      常见的函数有main函数,该函数比较特殊是程序的入口,运行时会先找到main函数然后逐行执行。

      /**
       * 模版方法设计模式
       * @author 李幸
       * @date 2018/3/20
       * @time 23:10
       */
      public class TemplateMethod {
          public static void main(String[] args) {
              Template template = new SubTemplate();
              template.spendTime();
          }
      }

      参数

      函数中的参数可以是变量,常量,运算表达式,也可以是其他函数执行返回的结果

      值传递

      说道参数,就要提到java中参数的传递方式,java中的传递方式都是值传递的所以外部传入的变量在函数内部做改变时不会影响外部变量的值,但是如果是传递对象的话那么就会改变对象中的值,因为传递对象的时候实际传递的是对象的引用,就导致函数内部的变量与函数外部的变量引用了同一份内容,所以外部对象中的值会被修改。

      在jdk1.5之后java支持可变长参数

      public class Test {
          public static void main(String[] args) {
              Test test = new Test();
              test.sum(1,23,3,4,5);
          }
          public void sum(int ... nums){
              int sum = 0;
              for(int i : nums){
                  sum += i;
              }
              System.out.println(sum);
          }
      }

      如果传入的值类型一致且需要多个不确定的情况下就可以用这种形式来定义,就免去了写多个重载方法了,需要注意的是可变长参数必须在参数列表的最后才可以。

      函数的返回

      在函数内部如果想要在一定条件退出该函数或者想要返回结果可以使用return

      public class Test {
          public static void main(String[] args) {
              Test test = new Test();
              int sum = test.sum(1,23,3,4,5);
          }
          public int sum(int ... nums){
              int sum = 0;
              for(int i : nums){
                  sum += i;
              }
              return sum;
          }
      }

      如果不想返回值只想终止函数那么方法返回值的修饰必须为void

      函数的重载

      同一个类中如果函数名相同,函数的参数列表不同,函数参数个数相同但是类型不同的情况下就构成了函数的重载

      public class Test {
          public static void main(String[] args) {
              Test test = new Test();
              int sum = test.sum(1,23,3,4,5);
          }
          public int sum(String str,int ... nums){
              int sum = 0;
              for(int i : nums){
                  sum += i;
              }
              return sum;
          }
          public int sum(int min,int ... nums){
              int sum = 0;
              for(int i : nums){
                  sum += i;
              }
              return sum;
          }
      }

      两个sum函数重载了

      在调用函数的过程中,对于参数也会自动进行类型转化以适配适合的函数来进行调用

      ……

      内容介绍

      Java专家撰写,力求透彻讲解每个知识点,逐步建立编程知识图谱。本书以Java语言为例,由基础概念入手,到背后实现原理与逻辑,再到应用实践,融会贯通。

      全书共六大部分,其要点如下。

      第一部分(第1~2章)讲解计算机程序的基本执行流程与元素,以及数据背后的二进制表示,帮读者掌握编程的基本概念。

      第二部分(第3~7章)讲解面向对象的编程原理与逻辑,涉及类、继承与多态、接口与抽象类、异常与常用基础类,让读者透彻了解Java的重要基础——面向对象。

      第三部分(第8~12章)介绍泛型与容器及其数据结构和算法,涵盖泛型、列表和队列、各种Map和Set、堆与优先级队列等。

      第四部分(第13~14章)介绍文件处理。涵盖文件的基本概念、二进制文件和字节流、文本文件和字符流、文件和目录操作,以及文件处理的一些高级技术,包括常见文件类型的处理、随机读写文件、内存映射文件、标准序列化机制,以及Jackson序列化。

      第五部分(第15~20章)介绍并发,包括线程的传统基础知识和Java并发包。传统基础知识包括线程的基本概念与基本的同步、协作和中断机制;Java并发包涵盖原子变量、显式锁、显式条件、并发容器、异步任务执行服务、同步和协作工具类。

      第六部分(第21~26章)介绍动态和声明式编程编程思路、API与技巧,涵盖反射、注解、动态代理、类加载机制、正则表达式、Java 8引入的函数式编程等。

      这本书和别的书有什么不同?

      简单来说,其他书大多教你怎么用,而这本书帮助你透彻理解,从基本概念到高层框架,剖析实现原理与JDK源代码,融合专业理论与应用实践,使你透彻理解Java编程的实现原理和思维逻辑,融会贯通。具体来说:

      1)对于每个编程概念,不仅介绍了语法和用法,还分析了为什么要有这个概念,实现原理是什么,背后的思维逻辑是什么;

      2)对于Java的主要API(如Java基础类、各种容器类、文件、并发包等),不仅介绍了用法、示例和应用,还剖析了大量JDK源代码,解释了其内部实现机制;

      3)对于实践中常用的系统程序和框架,如键值数据库、消息队列、序列化框架、DI(依赖注入)容器、AOP(面向切面编程)框架、热部署、模板引擎等,本书利用基本API演示了其基本实现原理;

      4)本书不仅注重实现原理,同样重视实用性,介绍了很多实践中常用的技术,包含了不少实际开发中积累的经验和教训,使读者可以少走一些弯路;

      5)本书虽然是Java语言描述,但以更为通用的编程逻辑为主,融入了很多通用的编程相关知识,如二进制、编码、数据结构和算法、设计模式、操作系统、编程思维等;

      6)本书高度注重表述,尽力站在读者的角度,循序渐进、简洁透彻、通俗易懂。

      作者介绍

      马俊昌,邻家科技CTO和联合创始人。北京理工大学博士,曾就职于IBM,从事中间件、云计算架构和开发工作,在万普世纪负责移动广告平台大数据分析和算法优化工作。2014年联合创立邻家科技,主要产品“到位APP”是一个到家生活服务平台。十多年来,一直从事Java编程,积累了比较丰富的经验。平时喜欢读书,研究技术与创新,乐于分享编程心得,欢迎关注我的微信公众号“老马说编程”,和你一起探索编程本质。

      目录:

      • Contents 目录
      • 读者评论
      • 前言
      • 第一部分 编程基础与二进制
      • 第1章 编程基础2
      • 1.1 数据类型和变量3
      • 1.2 赋值4
      • 1.2.1 基本类型4
      • 1.2.2 数组类型6
      • 1.3 基本运算8
      • 1.3.1 算术运算8
      • 1.3.2 比较运算10
      • 1.3.3 逻辑运算10
      • 1.3.4 小结11
      • 1.4 条件执行11
      • 1.4.1 语法和陷阱11
      • 1.4.2 实现原理14
      • 1.5 循环16
      • 1.5.1 循环的4种形式16
      • 1.5.2 循环控制19
      • 1.5.3 实现原理20
      • 1.5.4 小结20
      • 1.6 函数的用法21
      • 1.6.1 基本概念21
      • 1.6.2 进一步理解函数23
      • 1.6.3 小结27
      • 1.7 函数调用的基本原理27
      • 1.7.1 栈的概念27
      • 1.7.2 函数执行的基本原理28
      • 1.7.3 数组和对象的内存分配29
      • 1.7.4 递归调用的原理30
      • 1.7.5 小结31
      • 第2章 理解数据背后的二进制33
      • 2.1 整数的二进制表示与位运算33
      • 2.1.1 正整数的二进制表示33
      • 2.1.2 负整数的二进制表示34
      • 2.1.3 十六进制35
      • 2.1.4 位运算36
      • 2.2 小数的二进制表示37
      • 2.2.1 小数计算为什么会出错37
      • 2.2.2 二进制表示38
      • 2.3 字符的编码与乱码39
      • 2.3.1 常见非Unicode编码39
      • 2.3.2 Unicode编码42
      • 2.3.3 编码转换44
      • 2.3.4 乱码的原因45
      • 2.3.5 从乱码中恢复46
      • 2.4 char的真正含义49
      • 第二部分 面向对象
      • 第3章 类的基础52
      • 3.1 类的基本概念52
      • 3.1.1 函数容器52
      • 3.1.2 自定义数据类型53
      • 3.1.3 定义第一个类55
      • 3.1.4 使用第一个类55
      • 3.1.5 变量默认值57
      • 3.1.6 private变量57
      • 3.1.7 构造方法58
      • 3.1.8 类和对象的生命周期60
      • 3.1.9 小结61
      • 3.2 类的组合61
      • 3.2.1 String和Date61
      • 3.2.2 图形类62
      • 3.2.3 用类描述电商概念63
      • 3.2.4 用类描述人之间的血缘关系65
      • 3.2.5 目录和文件66
      • 3.2.6 一些说明67
      • 3.2.7 小结68
      • 3.3 代码的组织机制68
      • 3.3.1 包的概念68
      • 3.3.2 jar包71
      • 3.3.3 程序的编译与链接71
      • 3.3.4 小结72
      • 第4章 类的继承73
      • 4.1 基本概念73
      • 4.1.1 根父类Object74
      • 4.1.2 方法重写74
      • 4.1.3 图形类继承体系75
      • 4.1.4 小结80
      • 4.2 继承的细节80
      • 4.2.1 构造方法81
      • 4.2.2 重名与静态绑定82
      • 4.2.3 重载和重写83
      • 4.2.4 父子类型转换85
      • 4.2.5 继承访问权限protected85
      • 4.2.6 可见性重写86
      • 4.2.7 防止继承final87
      • 4.3 继承实现的基本原理88
      • 4.3.1 示例88
      • 4.3.2 类加载过程90
      • 4.3.3 对象创建的过程91
      • 4.3.4 方法调用的过程92
      • 4.3.5 变量访问的过程93
      • 4.4 为什么说继承是把双刃剑94
      • 4.4.1 继承破坏封装94
      • 4.4.2 封装是如何被破坏的94
      • 4.4.3 继承没有反映is-a关系97
      • 4.4.4 如何应对继承的双面性97
      • 第5章 类的扩展100
      • 5.1 接口的本质100
      • 5.1.1 接口的概念101
      • 5.1.2 定义接口101
      • 5.1.3 实现接口102
      • 5.1.4 使用接口103
      • 5.1.5 接口的细节105
      • 5.1.6 使用接口替代继承106
      • 5.1.7 Java 8和Java 9对接口的增强106
      • 5.1.8 小结108
      • 5.2 抽象类108
      • 5.2.1 抽象方法和抽象类108
      • 5.2.2 为什么需要抽象类109
      • 5.2.3 抽象类和接口109
      • 5.2.4 小结110
      • 5.3 内部类的本质111
      • 5.3.1 静态内部类111
      • 5.3.2 成员内部类113
      • 5.3.3 方法内部类115
      • 5.3.4 匿名内部类117
      • 5.4 枚举的本质119
      • 5.4.1 基础120
      • 5.4.2 典型场景122
      • 第6章 异常125
      • 6.1 初识异常125
      • 6.1.1 NullPointerException(空指针异常)125
      • 6.1.2 NumberFormatException(数字格式异常)126
      • 6.2 异常类128
      • 6.2.1 Throwable128
      • 6.2.2 异常类体系129
      • 6.2.3 自定义异常130
      • 6.3 异常处理131
      • 6.3.1 catch匹配131
      • 6.3.2 重新抛出异常131
      • 6.3.3 finally132
      • 6.3.4 try-with-resources133
      • 6.3.5 throws134
      • 6.3.6 对比受检和未受检异常135
      • 6.4 如何使用异常135
      • 6.4.1 异常应该且仅用于异常情况136
      • 6.4.2 异常处理的目标136
      • 6.4.3 异常处理的一般逻辑137
      • 第7章 常用基础类138
      • 7.1 包装类138
      • 7.1.1 基本用法139
      • 7.1.2 共同点140
      • 7.1.3 剖析Integer与二进制算法144
      • 7.1.4 剖析Character149
      • 7.2 剖析String155
      • 7.2.1 基本用法156
      • 7.2.2 走进String内部157
      • 7.2.3 编码转换157
      • 7.2.4 不可变性158
      • 7.2.5 常量字符串159
      • 7.2.6 hashCode160
      • 7.2.7 正则表达式161
      • 7.3 剖析StringBuilder162
      • 7.3.1 基本用法162
      • 7.3.2 基本实现原理162
      • 7.3.3 String的 和 =运算符165
      • 7.4 剖析Arrays166
      • 7.4.1 用法166
      • 7.4.2 多维数组171
      • 7.4.3 实现原理172
      • 7.4.4 小结174
      • 7.5 剖析日期和时间174
      • 7.5.1 基本概念174
      • 7.5.2 日期和时间API175
      • 7.5.3 局限性182
      • 7.6 随机183
      • 7.6.1 Math.random183
      • 7.6.2 Random184
      • 7.6.3 随机的基本原理185
      • 7.6.4 随机密码187
      • 7.6.5 洗牌189
      • 7.6.6 带权重的随机选择189
      • 7.6.7 抢红包算法191
      • 7.6.8 北京购车摇号算法192
      • 7.6.9 小结193
      • 第三部分 泛型与容器
      • 第8章 泛型196
      • 8.1 基本概念和原理196
      • 8.1.1 一个简单泛型类197
      • 8.1.2 容器类199
      • 8.1.3 泛型方法201
      • 8.1.4 泛型接口202
      • 8.1.5 类型参数的限定202
      • 8.1.6 小结205
      • 8.2 解析通配符205
      • 8.2.1 更简洁的参数类型限定205
      • 8.2.2 理解通配符206
      • 8.2.3 超类型通配符208
      • 8.2.4 通配符比较211
      • 8.3 细节和局限性211
      • 8.3.1 使用泛型类、方法和接口211
      • 8.3.2 定义泛型类、方法和接口213
      • 8.3.3 泛型与数组214
      • 8.3.4 小结217
      • 第9章 列表和队列218
      • 9.1 剖析ArrayList218
      • 9.1.1 基本用法218
      • 9.1.2 基本原理219
      • 9.1.3 迭代221
      • 9.1.4 ArrayList实现的接口225
      • 9.1.5 ArrayList的其他方法227
      • 9.1.6 ArrayList特点分析229
      • 9.1.7 小结229
      • 9.2 剖析LinkedList229
      • 9.2.1 用法230
      • 9.2.2 实现原理232
      • 9.2.3 LinkedList特点分析238
      • 9.3 剖析ArrayDeque239
      • 9.3.1 实现原理239
      • 9.3.2 ArrayDeque特点分析244
      • 第10章 Map和Set245
      • 10.1 剖析HashMap245
      • 10.1.1 Map接口245
      • 10.1.2 HashMap247
      • 10.1.3 实现原理247
      • 10.1.4 小结256
      • 10.2 剖析HashSet256
      • 10.2.1 用法256
      • 10.2.2 实现原理258
      • 10.2.3 小结259
      • 10.3 排序二叉树260
      • 10.3.1 基本概念260
      • 10.3.2 基本算法261
      • 10.3.3 平衡的排序二叉树263
      • 10.3.4 小结264
      • 10.4 剖析TreeMap264
      • 10.4.1 基本用法265
      • 10.4.2 实现原理267
      • 10.4.3 小结273
      • 10.5 剖析TreeSet274
      • 10.5.1 基本用法274
      • 10.5.2 实现原理275
      • 10.5.3 小结276
      • 10.6 剖析LinkedHashMap276
      • 10.6.1 基本用法276
      • 10.6.2 实现原理279
      • 10.6.3 LinkedHashSet282
      • 10.6.4 小结282
      • 10.7 剖析EnumMap283
      • 10.7.1 基本用法283
      • 10.7.2 实现原理285
      • 10.7.3 小结287
      • 10.8 剖析EnumSet287
      • 10.8.1 基本用法287
      • 10.8.2 应用场景288
      • 10.8.3 实现原理291
      • 10.8.4 小结294
      • 第11章 堆与优先级队列295
      • 11.1 堆的概念与算法296
      • 11.1.1 基本概念296
      • 11.1.2 堆的算法298
      • 11.1.3 小结302
      • 11.2 剖析PriorityQueue302
      • 11.2.1 基本用法302
      • 11.2.2 实现原理304
      • 11.2.3 小结309
      • 11.3 堆和PriorityQueue的应用309
      • 11.3.1 求前K个最大的元素309
      • 11.3.2 求中值311
      • 11.3.3 小结314
      • 第12章 通用容器类和总结315
      • 12.1 抽象容器类315
      • 12.1.1 AbstractCollection316
      • 12.1.2 AbstractList319
      • 12.1.3 AbstractSequentialList321
      • 12.1.4 AbstractMap323
      • 12.1.5 AbstractSet325
      • 12.1.6 AbstractQueue325
      • 12.1.7 小结326
      • 12.2 Collections326
      • 12.2.1 查找和替换327
      • 12.2.2 排序和调整顺序329
      • 12.2.3 添加和修改332
      • 12.2.4 适配器333
      • 12.2.5 装饰器338
      • 12.2.6 小结342
      • 12.3 容器类总结342
      • 12.3.1 用法和特点342
      • 12.3.2 数据结构和算法344
      • 12.3.3 设计思维和模式344
      • 第四部分 文件
      • 第13章 文件基本技术348
      • 13.1 文件概述348
      • 13.1.1 基本概念和常识348
      • 13.1.2 Java文件概述352
      • 13.2 二进制文件和字节流355
      • 13.2.1 InputStream/OutputStream355
      • 13.2.2 FileInputStream/File-OutputStream357
      • 13.2.3 ByteArrayInputStream/ByteArrayOutputStream359
      • 13.2.4 DataInputStream/Data-OutputStream361
      • 13.2.5 BufferedInputStream/BufferedOutputStream363
      • 13.2.6 实用方法364
      • 13.2.7 小结365
      • 13.3 文本文件和字符流365
      • 13.3.1 基本概念366
      • 13.3.2 Reader/Writer368
      • 13.3.3 InputStreamReader/Output-StreamWriter368
      • 13.3.4 FileReader/FileWriter369
      • 13.3.5 CharArrayReader/Char-ArrayWriter370
      • 13.3.6 StringReader/StringWriter370
      • 13.3.7 BufferedReader/Buffered-Writer371
      • 13.3.8 PrintWriter372
      • 13.3.9 Scanner374
      • 13.3.10 标准流374
      • 13.3.11 实用方法376
      • 13.3.12 小结377
      • 13.4 文件和目录操作378
      • 13.4.1 构造方法378
      • 13.4.2 文件元数据378
      • 13.4.3 文件操作379
      • 13.4.4 目录操作380
      • 第14章 文件高级技术383
      • 14.1 常见文件类型处理384
      • 14.1.1 属性文件384
      • 14.1.2 CSV文件385
      • 14.1.3 Excel388
      • 14.1.4 HTML389
      • 14.1.5 压缩文件391
      • 14.2 随机读写文件394
      • 14.2.1 用法394
      • 14.2.2 设计一个键值数据库BasicDB396
      • 14.2.3 BasicDB的实现397
      • 14.2.4 小结401
      • 14.3 内存映射文件402
      • 14.3.1 基本概念402
      • 14.3.2 用法403
      • 14.3.3 设计一个消息队列BasicQueue404
      • 14.3.4 实现消息队列406
      • 14.3.5 小结409
      • 14.4 标准序列化机制409
      • 14.4.1 基本用法409
      • 14.4.2 复杂对象411
      • 14.4.3 定制序列化411
      • 14.4.4 序列化的基本原理413
      • 14.4.5 版本问题414
      • 14.4.6 序列化特点分析414
      • 14.5 使用Jackson序列化为JSON/XML/MessagePack415
      • 14.5.1 基本概念415
      • 14.5.2 基本用法415
      • 14.5.3 容器对象418
      • 14.5.4 复杂对象419
      • 14.5.5 定制序列化420
      • 14.5.6 Jackson对XML支持的局限性428
      • 14.5.7 小结428
      • 第五部分 并发
      • 第15章 并发基础知识430
      • 15.1 线程的基本概念430
      • 15.1.1 创建线程430
      • 15.1.2 线程的基本属性和方法432
      • 15.1.3 共享内存及可能存在的问题435
      • 15.1.4 线程的优点及成本438
      • 15.2 理解synchronized439
      • 15.2.1 用法和基本原理439
      • 15.2.2 进一步理解synchronized443
      • 15.2.3 同步容器及其注意事项445
      • 15.3 线程的基本协作机制450
      • 15.3.1 协作的场景450
      • 15.3.2 wait/notify450
      • 15.3.3 生产者/消费者模式453
      • 15.3.4 同时开始455
      • 15.3.5 等待结束456
      • 15.3.6 异步结果458
      • 15.3.7 集合点461
      • 15.3.8 小结462
      • 15.4 线程的中断463
      • 15.4.1 取消/关闭的场景463
      • 15.4.2 取消/关闭的机制463
      • 15.4.3 线程对中断的反应464
      • 15.4.4 如何正确地取消/关闭线程467
      • 15.4.5 小结467
      • 第16章 并发包的基石468
      • 16.1 原子变量和CAS468
      • 16.2 显式锁473
      • 16.3 显式条件483
      • 第17章 并发容器490
      • 17.1 写时复制的List和Set490
      • 17.2 ConcurrentHashMap493
      • 17.3 基于跳表的Map和Set498
      • 17.4 并发队列501
      • 第18章 异步任务执行服务505
      • 18.1 基本概念和原理505
      • 18.2 线程池513
      • 18.3 定时任务的那些陷阱518
      • 第19章 同步和协作工具类527
      • 19.1 读写锁ReentrantReadWrite-Lock527
      • 19.2 信号量Semaphore529
      • 19.3 倒计时门栓CountDownLatch531
      • 19.4 循环栅栏CyclicBarrier533
      • 19.5 理解ThreadLocal535
      • 第20章 并发总结541
      • 20.1 线程安全的机制541
      • 20.2 线程的协作机制543
      • 20.3 容器类544
      • 20.4 任务执行服务546
      • 第六部分 动态与函数式编程
      • 第21章 反射550
      • 21.1 Class类551
      • 21.2 应用示例559
      • 21.3 反射与泛型561
      • 第22章 注解564
      • 22.1 内置注解564
      • 22.2 框架和库的注解566
      • 22.3 创建注解568
      • 22.4 查看注解信息570
      • 22.5 注解的应用:定制序列化571
      • 22.6 注解的应用:DI容器573
      • 第23章 动态代理577
      • 23.1 静态代理577
      • 23.2 Java SDK动态代理579
      • 23.3 cglib动态代理584
      • 23.4 Java SDK代理与cglib代理比较585
      • 23.5 动态代理的应用:AOP585
      • 第24章 类加载机制592
      • 24.1 类加载的基本机制和过程593
      • 24.2 理解ClassLoader594
      • 24.3 类加载的应用:可配置的策略597
      • 24.4 自定义ClassLoader598
      • 24.5 自定义ClassLoader的应用:热部署599
      • 第25章 正则表达式603
      • 25.1 语法603
      • 25.2 Java API612
      • 25.3 模板引擎618
      • 25.4 剖析常见表达式619
      • 第26章 函数式编程628
      • 26.1 Lambda表达式628
      • 26.2 函数式数据处理:基本用法637
      • 26.3 函数式数据处理:强大方便的收集器647
      • 26.4 组合式异步编程658
      • 26.5 Java 8的日期和时间API668

      学习笔记

      Java编程中的构造函数详细介绍

      本文主要是为新手、对java语言感兴趣的人和那些没有系统学习过java基础知识的人进行一个总结,在文章中对构造函数进行了较为详细的说明和讨论,也包含了我个人对于java面向对象中构造函数的一些看法。希望走在java学习道路上的同行者可以有一个较为清晰的认知和理解。当然仅为个人观点,水平有限,不足之处,还请大家多多指出,互相交流学习。 1.构造函数的概念 很多java新手谈到构造函数就会犯晕,我们先来看看什么是构造函数。 首先,构造函数是函数的一种特殊形式,特殊在哪里?构造函数中不需要定义返回类型(void是无需返回值的意思,请注意区分两者),且构造函数的名称与所在的类……

      以上就是本次介绍的Java编程电子书的全部相关内容,希望我们整理的资源能够帮助到大家,感谢大家对码农之家的支持。

      上一篇:Python编程:从入门到实践

      下一篇:Python数据分析基础

      展开 +

      收起 -

      下载地址:百度网盘下载
      Java编程相关电子书
      JavaScript函数式编程指南
      JavaScript函数式编程指南 影印版

      这书关键介绍怎样根据ECMAScript6将函数式编程关键技术于编码,以减少编码的多元性。这书共三一部分內容。*一部分函数式观念是为第二一部分的学习培训作铺垫的,这一部分引入了对函数式

      立即下载
      JavaScript编程全解
      JavaScript编程全解 高清版

      JavaScript编程全解 全方位地介绍了JavaScript开发中的各个主题,无论是前端还是后端的JavaScript开发者都可以在本书中找到自己需要的内容。本书对HTML5、Web API、Node.js及WebSocket等最新的热门技术也

      立即下载
      第三方JavaScript编程
      第三方JavaScript编程 高清版

      第三方JavaScript应用程序是自包含的应用组件,通常都是小脚本或插件,能够为Web站点增加功能。它们往往是由独立的组织或个人提供的,代码和文件都是来自于远程的Web地址。 《第三方JavaS

      立即下载
      Java并发编程从入门到精通
      Java并发编程从入门到精通 高清版

      《Java并发编程从入门到精通》 作者结合自已10多年Java并发编程经验,详细介绍了Java并发编程的基础概念、工作原理、编程技巧和注意事项,对Java高性能高并发编程有极大的参考价值。 本书内

      立即下载
      JavaScript ES6函数式编程入门经典
      JavaScript ES6函数式编程入门经典 原书扫描版

      本书使用JavaScript ES6带你学习函数式编程。你将学习柯里化、偏函数、高阶函数以及Monad等概念。具有一定的参考价值,感兴趣的小伙伴们可以参考一下

      立即下载
      Java编程思想
      Java编程思想 影印第4版

      《 计算机科学丛书:Java编程思想(第4版) 》获得了全世界程序猿的普遍称赞,即便是枯燥的定义,在BruceEckel的文本感染力和小而立即的程序编写实例眼前也会解决于无形中。从Java的基本英

      立即下载
      Java WebSocket编程:发、部署和保护动态Web应用
      Java WebSocket编程:发、部署和保护动态Web应用 高清版

      精通Java WebSocket应用开发,充分利用最先进的通信技术构建动态企业级Web应用。《Java WebSocket编程 开发、部署和保护动态Web应用》一书由Java WebSocket编程权威专家撰写,提供了实际的开发策略和

      立即下载
      Java 9并发编程实战
      Java 9并发编程实战 原书完整版 立即下载
      读者留言
      网友NO.41380
      网友NO.41380

      自己的读书笔记,只是个笔记还有一种态度 碎碎念:近期的生活经历告诉我:不要把消极的一面示人,那样你只会成为一个小丑,这个世界上能帮你的只有你自己;另外事情没有想象当中的那么坏,退一步、何苦逼自己,生活本就如此,不示人、不示世,学习! 1、多个重名函数时,首先按参数类型匹配,然后看变量的动态类型,进行动态绑定 2、一个父类的变量能不能转换为一个子类的变量,取决于这个父类变量的动态类型(引用的对象类型)是不是这个子类或子类的子类 3、protected修饰符可被子类访问,同包下的其他类访问 4、子类对象属于父类,必须支持父类all对外的行为(is-a)降低可见性=no 5、动态绑定:据对象实际类型查找要执行的方法,子类找不到 看父类:虚方法表: 类加载时为每个对象创建一个表、记录类对象all动态绑定的方法(含父类方法)及地址,子类重写了父类方法后只保留子类的 6、变量的访问是静态绑定 7、继承破坏封装性:对子类而言,通过继承实现无安全保障(父类修改内部实现,它的功能可能被破坏)对基类而言,让子类继承和重写方法,可能丢失修改内部实现的自由 8、抽象类和接口配合关系:接口声明能力,抽象类提供默认实现,一个接口常对应一个抽象类; 抽象类可定义实例变量,java8中接口有一个静态、默认方法

      网友NO.27646
      网友NO.27646

      Java编程的逻辑阅读总结 数据类型和变量 数据在计算机内部都是二进制的形式表示的,为方便操作高级语言引入了数据类型和变量的概念。 数据类型是对数据的归类,以便于理解和操作,Java中有四种基本类型: 整数类型:有四种整形 byte,short,int,long 分别占 1,2,4,8字节 布尔类型:表示真假 浮点类型:两种浮点类型 float,double 分别占 4,8字节 字符类型: 表示单个字符 占用内存控件两个字节 为了操作数据,需要吧数据存放在内存,所谓内存在程序看来就是一块有地址的连续空间,数据放到内存中某一位置,为了方便操作,就会给该位置起一个名字,编程语言通过变量来描述这一过程。 赋值 定义了变量和就确定了一块内存空间,但该空间的值是不确定的,就需要给该空间制定一个明确的值 基本类型 需要注意的是: 数字常量默认为int类型,浮点常量默认为double类型 数组类型 需要注意的是: 数据类型可以先给长度再赋值,也可以直接赋值,但是不能既给长度也赋值 不用类型的数据都有默认值 数值类型为0,布尔类型为false,浮点型为0.0,字符型为空字符 数据的长度可以动态决定但是决定了后不可改变 数组在内存中有两块内存空间,一块用于存数组本身内容,一块用于存数组内容的地址

      xz577网友
      xz577网友

      书不错的,看得出来作者有很深厚的工程底蕴,不像那种教程书一样泛泛而谈,推荐!

      彭志泽

      彭志泽 提供上传

      资源
      14
      粉丝
      10
      喜欢
      1269
      评论
      10

      Copyright 2018-2020 www.xz577.com 码农之家

      版权投诉 / 书籍推广 / 赞助:520161757@qq.com