8000 Merge branch 'master' of github.com:hollischuang/toBeTopJavaer · coder-chenhao/toBeTopJavaer@9cc1409 · GitHub
[go: up one dir, main page]
Skip to content

Commit 9cc1409

Browse files
author
hollis.zhl
committed
Merge branch 'master' of github.com:hollischuang/toBeTopJavaer
2 parents 1eeb3ab + 94b9746 commit 9cc1409

9 files changed

+79
-49
lines changed

‎basics/java-basic/constructor.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,4 +2,4 @@
22

33
构造函数跟一般的实例方法十分相似；但是与其它方法不同，构造器没有返回类型，不会被继承，且可以有范围修饰符。构造器的函数名称必须和它所属的类的名称相同。 它承担着初始化对象数据成员的任务。
44

5-
如果在编写一个可实例化的类时没有专门编写构造函数，多数编程语言会自动生成缺省构造器（默认构造函数）。默认构造函数一般会把成员变量的值初始化为默认值，如int -> 0，Integet -> null。
5+
如果在编写一个可实例化的类时没有专门编写构造函数，多数编程语言会自动生成缺省构造器（默认构造函数）。默认构造函数一般会把成员变量的值初始化为默认值，如int -> 0，Integer -> null。

‎basics/java-basic/enum-serializable.md

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@
5151
}
5252

5353

54-
通过反编译后代码我们可以看到，`public final class T extends Enum`，说明，该类是继承了Enum类的，同时final关键字告诉我们，这个类也是不能被继承的。当我们使用`enmu`来定义一个枚举类型的时候，编译器会自动帮我们创建一个final类型的类继承Enum类,所以枚举类型不能被继承，我们看到这个类中有几个属性和方法。
54+
通过反编译后代码我们可以看到，`public final class T extends Enum`，说明，该类是继承了Enum类的，同时final关键字告诉我们，这个类也是不能被继承的。当我们使用`enum`来定义一个枚举类型的时候，编译器会自动帮我们创建一个final类型的类继承Enum类,所以枚举类型不能被继承，我们看到这个类中有几个属性和方法。
5555

5656
我们可以看到：
5757

@@ -114,4 +114,4 @@
114114

115115
**3\.枚举实例创建是thread-safe(线程安全的)**
116116

117-
> 我们在<a href="/archives/199" target="_blank">深度分析Java的ClassLoader机制（源码级别）</a>和<a href="/archives/201" target="_blank">Java类的加载、链接和初始化</a>两个文章中分别介绍过，当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的。所以，**创建一个enum类型是线程安全的**。
117+
> 我们在<a href="/archives/199" target="_blank">深度分析Java的ClassLoader机制（源码级别）</a>和<a href="/archives/201" target="_blank">Java类的加载、链接和初始化</a>两个文章中分别介绍过，当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的。所以，**创建一个enum类型是线程安全的**。

‎basics/java-basic/integer-scope.md

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ Java中的整型主要包含byte、short、int和long这四种，表示的数字
55
先来看计算中8bit可以表示的数字：
66
最小值：10000000 （-128）(-2^7)
77
最大值：01111111（127）(2^7-1)
8-
具体计算方式参考：Java中，为什么byte类型的取值范围为-128~127? - CSDN博客
8+
具体计算方式参考：[Java中，为什么byte类型的取值范围为-128~127? - CSDN博客](https://blog.csdn.net/qq_23418393/article/details/57421688)
99

1010
整型的这几个类型中，
1111

@@ -27,4 +27,4 @@ Java中的整型主要包含byte、short、int和long这四种，表示的数字
2727

2828
输出结果：`i (2147483647) + j (2147483647) = k (-2)`
2929

30-
这就是发生了溢出，溢出的时候并不会抛异常，也没有任何提示。所以，在程序中，使用同类型的数据进行运算的时候，一定要注意数据溢出的问题。
30+
这就是发生了溢出，溢出的时候并不会抛异常，也没有任何提示。所以，在程序中，使用同类型的数据进行运算的时候，一定要注意数据溢出的问题。

‎basics/java-basic/java-pass-by.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ public static void main(String[] args) {
5151
ParamTest pt = new ParamTest();
5252
5353
int i = 10;
54-
pt.pass(10);
54+
pt.pass(i);
5555
System.out.println("print in main , i is " + i);
5656
}
5757

‎basics/java-basic/jvm-language.md

Lines changed: 42 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88

99
经常使用IDE的开发者可能会发现，当我们在Intelij IDEA中，鼠标右键想要创建Java类的时候，IDE还会提示创建其他类型的文件，这就是IDE默认支持的一些可以运行在JVM上面的语言，没有提示的，可以通过插件来支持。
1010

11-
<img src="https://www.hollischuang.com/wp-content/uploads/2018/11/languages.png" alt="" width="1102" height="372" class="aligncenter size-full wp-image-2968" />
11+
<img src="https://www.hollischuang.com/wp-content/uploads/2018/11/languages.png" />
1212

1313
目前，可以直接在JVM上运行的语言有很多，今天介绍其中比较重要的九种。每种语言通过一段『HelloWorld』代码进行演示，看看不同语言的语法有何不同。
1414

@@ -18,10 +18,11 @@ Kotlin是一种在Java虚拟机上运行的静态类型编程语言，它也可
1818

1919
#### Hello World In Kotlin
2020

21-
fun main(args: Array<String>) {
22-
println("Hello, world!")
23-
}
24-
21+
```kotlin
22+
fun main(args: Array<String>) {
23+
println("Hello, world!")
24+
}
25+
```
2526

2627
### Groovy
2728

@@ -31,10 +32,11 @@ Apache的Groovy是Java平台上设计的面向对象编程语言。它的语法
3132

3233
#### Hello World In Groovy
3334

34-
static void main(String[] args) {
35-
println('Hello, world!');
36-
}
37-
35+
```groovy
36+
static void main(String[] args) {
37+
println('Hello, world!');
38+
}
39+
```
3840

3941
### Scala
4042

@@ -44,30 +46,33 @@ Scala经常被我们描述为多模式的编程语言，因为它混合了来自
4446

4547
#### Hello World In Scala
4648

47-
object HelloWorld {
48-
def main(args: Array[String]) {
49-
System.out.println("Hello, world!");
50-
}
51-
}
52-
49+
```scala
50+
object HelloWorld {
51+
def main(args: Array[String]) {
52+
System.out.println("Hello, world!");
53+
}
54+
}
55+
```
5356

5457
### Jruby
5558

5659
JRuby是用来桥接Java与Ruby的，它是使用比Groovy更加简短的语法来编写代码，能够让每行代码执行更多的任务。就和Ruby一样，JRuby不仅仅只提供了高级的语法格式。它同样提供了纯粹的面向对象的实现，闭包等等，而且JRuby跟Ruby自身相比多了很多基于Java类库 可以调用，虽然Ruby也有很多类库，但是在数量以及广泛性上是无法跟Java标准类库相比的。
5760

5861
#### Hello World In Jruby
5962

60-
"puts 'Hello, world!'"
61-
63+
```ruby
64+
puts 'Hello, world!'
65+
```
6266

6367
### Jython
6468

6569
Jython，是一个用Java语言写的Python解释器。Jython能够用Python语言来高效生成动态编译的Java字节码。
6670

6771
#### Hello World In Jython
6872

69-
print "Hello, world!"
70-
73+
```py
74+
print "Hello, world!"
75+
```
7176

7277
### Fantom
7378

@@ -77,11 +82,11 @@ Fantom是与Groovy以及JRuby差不多的一样面向对 象的编程语言，
7782

7883
#### Hello World In Fantom
7984

80-
class Hello
81-
{
82-
static Void main() { echo("Hello, world!") }
83-
}
84-
85+
```fantom
86+
class Hello {
87+
static Void main() { echo("Hello, world!") }
88+
}
89+
```
8590

8691
### Clojure
8792

@@ -91,9 +96,10 @@ Clojure是Lisp编程语言在Java平台上的现代、函数式及动态方言
9196

9297
#### Hello World In Clojure
9398

94-
(defn -main [& args]
95-
(println "Hello, World!"))
96-
99+
```clojure
100+
(defn -main [& args]
101+
(println "Hello, World!"))
102+
```
97103

98104
### Rhino
99105

@@ -103,22 +109,24 @@ Rhino的特点是为JavaScript加了个壳，然后嵌入到Java中，这样能
103109

104110
#### Hello World In Rhino
105111

106-
print('Hello, world!')
107-
112+
```js
113+
print('Hello, world!')
114+
```
108115

109116
### Ceylon
110117

111118
Ceylon是一种面向对象，强烈静态类型的编程语言，强调不变性，由Red Hat创建。 Ceylon程序在Java虚拟机上运行，​​可以编译为JavaScript。 语言设计侧重于源代码可读性，可预测性，可扩展性，模块性和元编程性。
112119

113120
#### Hello World In Ceylon
114121

115-
shared void run() {
116-
print("Hello, world!");
117-
} F987
118-
122+
```ceylon
123+
shared void run() {
124+
print("Hello, world!");
125+
}
126+
```
119127

120128
### 总结
121129

122130
好啦，以上就是目前主流的可以在JVM上面运行的9种语言。加上Java正好10种。如果你是一个Java开发，那么有必要掌握以上9中的一种，这样可以在一些有特殊需求的场景中有更多的选择。推荐在Groovy、Scala、Kotlin中选一个。
123131

124-
[1]: https://www.hollischuang.com/archives/2322
132+
[1]: https://www.hollischuang.com/archives/2322

‎basics/java-basic/object-oriented-vs-procedure-oriented.md

Lines changed: 23 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
### 什么是面向过程？
22

3+
####概述: 自顶而下的编程模式.
4+
35
把问题分解成一个一个步骤，每个步骤用函数实现，依次调用即可。
46

57
就是说，在进行面向过程编程的时候，不需要考虑那么多，上来先定义一个函数，然后使用各种诸如if-else、for-each等方式进行代码执行。
@@ -8,8 +10,28 @@
810

911

1012
### 什么是面向对象？
13+
14+
####概述: 将事务高度抽象化的编程模式.
15+
1116
将问题分解成一个一个步骤，对每个步骤进行相应的抽象，形成对象，通过不同对象之间的调用，组合解决问题。
1217

1318
就是说，在进行面向对象进行编程的时候，要把属性、行为等封装成对象，然后基于这些对象及对象的能力进行业务逻辑的实现。
1419

15-
比如想要造一辆车，上来要先把车的各种属性定义出来，然后抽象成一个Car类。
20+
比如:想要造一辆车，上来要先把车的各种属性定义出来，然后抽象成一个Car类。
21+
22+
#### 举例说明区别
23+
24+
同样一个象棋设计.
25+
26+
面向对象:创建黑白双方的对象负责演算,棋盘的对象负责画布,规则的对象负责判断，例子可以看出,面向对象更重视不重复造轮子,即创建一次,重复使用.
27+
1241 28+
面向过程:开始—黑走—棋盘—判断—白走—棋盘—判断—循环。只需要关注每一步怎么实现即可.
29+
30+
#### 优劣对比
31+
32+
面向对象:占用资源相对高,速度相对慢
33+
34+
面向过程:占用资源相对低,速度相对快
35+
36+
37+

‎basics/java-basic/platform-independent.md

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@
4646

4747
**Java虚拟机**
4848

49-
所谓平台无关性，就是说要能够做到可以在多个平台上都能无缝对接。但是，对于不通的平台，硬件和操作系统肯定都是不一样的。
49+
所谓平台无关性，就是说要能够做到可以在多个平台上都能无缝对接。但是，对于不同的平台，硬件和操作系统肯定都是不一样的。
5050

5151
对于不同的硬件和操作系统，最主要的区别就是指令不同。比如同样执行a+b，A操作系统对应的二进制指令可能是10001000，而B操作系统对应的指令可能是11101110。那么，想要做到跨平台，最重要的就是可以根据对应的硬件和操作系统生成对应的二进制指令。
5252

@@ -64,7 +64,7 @@
6464

6565
**字节码**
6666

67-
各种不同的平台的虚拟机都使用统一的程序存储格式——字节码（ByteCode）是构成平台无关性的另一个基石。Java虚拟机只与由自己码组成的Class文件进行交互。
67+
各种不同的平台的虚拟机都使用统一的程序存储格式——字节码（ByteCode）是构成平台无关性的另一个基石。Java虚拟机只与由字节码组成的Class文件进行交互。
6868

6969
我们说Java语言可以Write Once ,Run Anywhere。这里的Write其实指的就是生成Class文件的过程。
7070

@@ -88,7 +88,7 @@
8888

8989
### 小结
9090

91-
对于Java的平台无关性的支持是分布在整个Java体系结构中的。其中扮演者重要的角色的有Java语言规范、Class文件、Java虚拟机等。
91+
对于Java的平台无关性的支持是分布在整个Java体系结构中的。其中扮演着重要角色的有Java语言规范、Class文件、Java虚拟机等。
9292

9393
* Java语言规范
9494
* 通过规定Java语言中基本数据类型的取值范围和行为
@@ -105,7 +105,7 @@ Java的平台无关性是建立在Java虚拟机的平台有关性基础之上的
105105

106106
前面我们提到过。JVM其实并不是和Java文件进行交互的，而是和Class文件，也就是说，其实JVM运行的时候，并不依赖于Java语言。
107107

108-
时至今日，商业机构和开源机构已经在Java语言之外发展出一大批可以在JVM上运行的语言了，如Groovy、Scala、Jython等。之所以可以支持，就是因为这些语言也可以被编译成字节码（Class文锦啊）。而虚拟机并不关心字节码是有哪种语言编译而来的。详见[牛逼了，教你用九种语言在JVM上输出HelloWorld][9]
108+
时至今日，商业机构和开源机构已经在Java语言之外发展出一大批可以在JVM上运行的语言了，如Groovy、Scala、Jython等。之所以可以支持，就是因为这些语言也可以被编译成字节码（Class文件）。而虚拟机并不关心字节码是有哪种语言编译而来的。详见[牛逼了，教你用九种语言在JVM上输出HelloWorld][9]
109109

110110
参考资料
111111

@@ -119,4 +119,4 @@ Java的平台无关性是建立在Java虚拟机的平台有关性基础之上的
119119
[6]: https://www.hollischuang.com/wp-content/uploads/2019/03/15539297082025.jpg
120120
[7]: https://www.hollischuang.com/wp-content/uploads/2019/03/15539303829914.jpg
121121
[8]: https://www.hollischuang.com/wp-content/uploads/2019/03/15539319645205.jpg
122-
[9]: https://www.hollischuang.com/archives/2938
122+
[9]: https://www.hollischuang.com/archives/2938

‎basics/java-basic/polymorphism.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@
4141
比如Spring 中的IOC出来的对象，你在使用的时候就不知道他是谁，或者说你可以不用关心他是谁。根据具体情况而定。
4242

4343

44-
另外，还有一种说法，包括维基百科也说明，动态还分为动态多态和静态多态。
44+
另外，还有一种说法，包括维基百科也说明，多态还分为动态多态和静态多态。
4545
上面提到的那种动态绑定认为是动态多态，因为只有在运行期才能知道真正调用的是哪个类的方法。
4646

4747
还有一种静态多态，一般认为Java中的函数重载是一种静态多态，因为他需要在编译期决定具体调用哪个方法、

‎basics/java-basic/principle.md

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@
1111
“需求总是变化”没有不变的软件，所以就需要用封闭开放原则来封闭变化满足需求，同时还能保持软件内部的封装体系稳定，不被需求的变化影响。
1212

1313

14-
### Liskov替换原则（Liskov-Substituion Principle）
14+
### Liskov替换原则（Liskov-Substitution Principle）
1515

1616
其核心思想是：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。在父类和子类的具体行为中，必须严格把握继承层次中的关系和特征，将基类替换为子类，程序的行为不会发生任何变化。同时，这一约束反过来则是不成立的，子类可以替换基类，但是基类不一定能替换子类。
1717
Liskov替换原则，主要着眼于对抽象和多态建立在继承的基础上，因此只有遵循了Liskov替换原则，才能保证继承复用是可靠地。实现的方法是面向接口编程：将公共部分抽象为基类接口或抽象类，通过Extract Abstract Class，在子类中通过覆写父类的方法实现新的方式支持同样的职责。
@@ -34,4 +34,4 @@ Liskov替换原则能够保证系统具有良好的拓展性，同时实现基
3434
接口有效地将细节和抽象隔离，体现了对抽象编程的一切好处，接口隔离强调接口的单一性。而胖接口存在明显的弊端，会导致实现的类型必须完全实现接口的所有方法、属性等；而某些时候，实现类型并非需要所有的接口定义，在设计上这是“浪费”，而且在实施上这会带来潜在的问题，对胖接口的修改将导致一连串的客户端程序需要修改，有时候这是一种灾难。在这种情况下，将胖接口分解为多个特点的定制化方法，使得客户端仅仅依赖于它们的实际调用的方法，从而解除了客户端不会依赖于它们不用的方法。
3535
分离的手段主要有以下两种：1、委托分离，通过增加一个新的类型来委托客户的请求，隔离客户和接口的直接依赖，但是会增加系统的开销。2、多重继承分离，通过接口多继承来实现客户的需求，这种方式是较好的。
3636

37-
以上就是5个基本的面向对象设计原则，它们就像面向对象程序设计中的金科玉律，遵守它们可以使我们的代码更加鲜活，易于复用，易于拓展，灵活优雅。不同的设计模式对应不同的需求，而设计原则则代表永恒的灵魂，需要在实践中时时刻刻地遵守。就如ARTHUR J.RIEL在那边《OOD启示录》中所说的：“你并不必严格遵守这些原则，违背它们也不会被处以宗教刑罚。但你应当把这些原则看做警铃，若违背了其中的一条，那么警铃就会响起。”
37+
以上就是5个基本的面向对象设计原则，它们就像面向对象程序设计中的金科玉律，遵守它们可以使我们的代码更加鲜活，易于复用，易于拓展，灵活优雅。不同的设计模式对应不同的需求，而设计原则则代表永恒的灵魂，需要在实践中时时刻刻地遵守。就如ARTHUR J.RIEL在那边《OOD启示录》中所说的：“你并不必严格遵守这些原则，违背它们也不会被处以宗教刑罚。但你应当把这些原则看做警铃，若违背了其中的一条，那么警铃就会响起。”

0 commit comments

Comments
 (0)
0