Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
wushizhenking
CS-Notes
提交
5438ab4b
C
CS-Notes
项目概览
wushizhenking
/
CS-Notes
与 Fork 源项目一致
从无法访问的项目Fork
通知
2
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
C
CS-Notes
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
前往新版Gitcode,体验更适合开发者的 AI 搜索 >>
提交
5438ab4b
编写于
8月 13, 2018
作者:
C
CyC2018
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
auto commit
上级
f9c0e4cc
变更
1
隐藏空白更改
内联
并排
Showing
1 changed file
with
68 addition
and
41 deletion
+68
-41
notes/Java 基础.md
notes/Java 基础.md
+68
-41
未找到文件。
notes/Java 基础.md
浏览文件 @
5438ab4b
...
...
@@ -62,7 +62,10 @@ int y = x; // 拆箱
## 缓存池
new Integer(123) 与 Integer.valueOf(123) 的区别在于,new Integer(123) 每次都会新建一个对象,而 Integer.valueOf(123) 可能会使用缓存对象,因此多次使用 Integer.valueOf(123) 会取得同一个对象的引用。
new Integer(123) 与 Integer.valueOf(123) 的区别在于:
-
new Integer(123) 每次都会新建一个对象
-
Integer.valueOf(123) 会使用缓存池中的对象,多次调用会取得同一个对象的引用。
```
java
Integer
x
=
new
Integer
(
123
);
...
...
@@ -73,14 +76,6 @@ Integer k = Integer.valueOf(123);
System
.
out
.
println
(
z
==
k
);
// true
```
编译器会在自动装箱过程调用 valueOf() 方法,因此多个 Integer 实例使用自动装箱来创建并且值相同,那么就会引用相同的对象。
```
java
Integer
m
=
123
;
Integer
n
=
123
;
System
.
out
.
println
(
m
==
n
);
// true
```
valueOf() 方法的实现比较简单,就是先判断值是否在缓存池中,如果在的话就直接返回缓存池的内容。
```
java
...
...
@@ -125,7 +120,15 @@ static {
}
```
Java 还将一些其它基本类型的值放在缓冲池中,包含以下这些:
编译器会在自动装箱过程调用 valueOf() 方法,因此多个 Integer 实例使用自动装箱来创建并且值相同,那么就会引用相同的对象。
```
java
Integer
m
=
123
;
Integer
n
=
123
;
System
.
out
.
println
(
m
==
n
);
// true
```
基本类型对应的缓冲池如下:
-
boolean values true and false
-
all byte values
...
...
@@ -133,7 +136,7 @@ Java 还将一些其它基本类型的值放在缓冲池中,包含以下这些
-
int values between -128 and 127
-
char in the range
\u
0000 to
\u
007F
因此
在使用这些基本类型对应的包装类型时,就可以直接使用缓冲池中的对象。
在使用这些基本类型对应的包装类型时,就可以直接使用缓冲池中的对象。
[
StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
](
https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123
)
...
...
@@ -186,15 +189,15 @@ String 不可变性天生具备线程安全,可以在多个线程中安全地
-
String 不可变,因此是线程安全的
-
StringBuilder 不是线程安全的
-
StringBuffer 是线程安全的,内部使用 synchronized
来
同步
-
StringBuffer 是线程安全的,内部使用 synchronized
进行
同步
[
StackOverflow : String, StringBuffer, and StringBuilder
](
https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder
)
## String.intern()
使用 String.intern() 可以保证相同内容的字符串变量引用
相同
的内存对象。
使用 String.intern() 可以保证相同内容的字符串变量引用
同一
的内存对象。
下面示例中,s1 和 s2 采用 new String() 的方式新建了两个不同对象,而 s3 是通过 s1.intern() 方法取得一个对象引用
,这个方法
首先把 s1 引用的对象放到 String Pool(字符串常量池)中,然后返回这个对象引用。因此 s3 和 s1 引用的是同一个字符串常量池的对象。
下面示例中,s1 和 s2 采用 new String() 的方式新建了两个不同对象,而 s3 是通过 s1.intern() 方法取得一个对象引用
。intern()
首先把 s1 引用的对象放到 String Pool(字符串常量池)中,然后返回这个对象引用。因此 s3 和 s1 引用的是同一个字符串常量池的对象。
```
java
String
s1
=
new
String
(
"aaa"
);
...
...
@@ -214,7 +217,7 @@ System.out.println(s4 == s5); // true
在 Java 7 之前,字符串常量池被放在运行时常量池中,它属于永久代。而在 Java 7,字符串常量池被移到 Native Method 中。这是因为永久代的空间有限,在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
-
[
StackOverflow : What is String interning?
](
https://stackoverflow.com/questions/10578984/what-is-string-interning
)
-
[
StackOverflow : What is String interning?
](
https://stackoverflow.com/questions/10578984/what-is-string-interning
)
-
[
深入解析 String#intern
](
https://tech.meituan.com/in_depth_understanding_string_intern.html
)
# 三、运算
...
...
@@ -223,7 +226,7 @@ System.out.println(s4 == s5); // true
Java 的参数是以值传递的形式传入方法中,而不是引用传递。
以下代码中 Dog dog 的 dog 是一个指针,存储的是对象的地址。在将一个参数传入一个方法时,本质上是将对象的地址以值的方式传递到形参中。
但是如果在方法中改变对象的字段值会改变原对象该字段值,因为改变的是同一个地址指向的内容
。
以下代码中 Dog dog 的 dog 是一个指针,存储的是对象的地址。在将一个参数传入一个方法时,本质上是将对象的地址以值的方式传递到形参中。
因此在方法中改变指针引用的对象,那么这两个指针此时指向的是完全不同的对象,一方改变其所指向对象的内容对另一方没有影响
。
```
java
public
class
Dog
{
...
...
@@ -234,7 +237,11 @@ public class Dog {
}
String
getName
()
{
return
name
;
return
this
.
name
;
}
void
setName
(
String
name
)
{
this
.
name
=
name
;
}
String
getObjectAddress
()
{
...
...
@@ -262,6 +269,22 @@ public class PassByValueExample {
}
```
但是如果在方法中改变对象的字段值会改变原对象该字段值,因为改变的是同一个地址指向的内容。
```
java
class
PassByValueExample
{
public
static
void
main
(
String
[]
args
)
{
Dog
dog
=
new
Dog
(
"A"
);
func
(
dog
);
System
.
out
.
println
(
dog
.
getName
());
// B
}
private
static
void
func
(
Dog
dog
)
{
dog
.
setName
(
"B"
);
}
}
```
[
StackOverflow: Is Java “pass-by-reference” or “pass-by-value”?
](
https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value
)
## float 与 double
...
...
@@ -317,7 +340,7 @@ switch (s) {
}
```
switch 不支持 long,是因为 switch 的设计初衷是
为那些只需要对
少数的几个值进行等值判断,如果值过于复杂,那么还是用 if 比较合适。
switch 不支持 long,是因为 switch 的设计初衷是
对那些只有
少数的几个值进行等值判断,如果值过于复杂,那么还是用 if 比较合适。
```
java
// long x = 111;
...
...
@@ -341,33 +364,37 @@ Java 中有三个访问权限修饰符:private、protected 以及 public,如
可以对类或类中的成员(字段以及方法)加上访问修饰符。
-
成员可见表示其它类可以用这个类的实例对象访问到该成员;
-
类可见表示其它类可以用这个类创建实例对象。
-
成员可见表示其它类可以用这个类的实例对象访问到该成员;
protected 用于修饰成员,表示在继承体系中成员对于子类可见,但是这个访问修饰符对于类没有意义。
设计良好的模块会隐藏所有的实现细节,把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信,一个模块不需要知道其他模块的内部工作情况,这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
如果子类的方法
覆盖
了父类的方法,那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例,也就是确保满足里氏替换原则。
如果子类的方法
重写
了父类的方法,那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例,也就是确保满足里氏替换原则。
字段决不能是公有的,因为这么做的话就失去了对这个字段修改行为的控制,客户端可以对其随意修改。
可以使用公有的 getter 和 setter 方法来替换公有字段
。
字段决不能是公有的,因为这么做的话就失去了对这个字段修改行为的控制,客户端可以对其随意修改。
例如下面的例子中,AccessExample 拥有 id 共有字段,如果在某个时刻,我们想要使用 int 去存储 id 字段,那么就需要去修改所有的客户端代码
。
```
java
public
class
AccessExample
{
public
int
x
;
public
String
id
;
}
```
可以使用公有的 getter 和 setter 方法来替换公有字段,这样的话就可以控制对字段的修改行为。
```
java
public
class
AccessExample
{
private
int
x
;
public
int
getX
()
{
return
x
;
private
int
id
;
public
String
getId
()
{
return
id
+
""
;
}
public
void
set
X
(
int
x
)
{
this
.
x
=
x
;
public
void
set
Id
(
String
id
)
{
this
.
id
=
Integer
.
valueOf
(
id
)
;
}
}
```
...
...
@@ -387,7 +414,7 @@ public class AccessWithInnerClassExample {
}
public
int
getValue
()
{
return
innerClass
.
x
;
// 直接访问
return
innerClass
.
x
;
// 直接访问
}
}
```
...
...
@@ -396,7 +423,7 @@ public class AccessWithInnerClassExample {
**1. 抽象类**
抽象类和抽象方法都使用 abstract 进行声明。抽象类一般会包含抽象方法,抽象方法一定位于抽象类中。
抽象类和抽象方法都使用 abstract
关键字
进行声明。抽象类一般会包含抽象方法,抽象方法一定位于抽象类中。
抽象类和普通类最大的区别是,抽象类不能被实例化,需要继承抽象类才能实例化其子类。
...
...
@@ -415,7 +442,7 @@ public abstract class AbstractClassExample {
```
```
java
public
class
AbstractExtendClassExample
extends
AbstractClassExample
{
public
class
AbstractExtendClassExample
extends
AbstractClassExample
{
@Override
public
void
func1
()
{
System
.
out
.
println
(
"func1"
);
...
...
@@ -448,7 +475,7 @@ public interface InterfaceExample {
}
int
x
=
123
;
// int y;
// Variable 'y' might not have been initialized
// int y; // Variable 'y' might not have been initialized
public
int
z
=
0
;
// Modifier 'public' is redundant for interface fields
// private int k = 0; // Modifier 'private' not allowed here
// protected int l = 0; // Modifier 'protected' not allowed here
...
...
@@ -477,21 +504,21 @@ System.out.println(InterfaceExample.x);
-
从设计层面上看,抽象类提供了一种 IS-A 关系,那么就必须满足里式替换原则,即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系,它只是提供一种方法实现契约,并不要求接口和实现接口的类具有 IS-A 关系。
-
从使用上来看,一个类可以实现多个接口,但是不能继承多个抽象类。
-
接口的字段只能是 static 和 final 类型的,而抽象类的字段没有这种限制。
-
接口的
方法只能是 public 的,而抽象类的方法
可以有多种访问权限。
-
接口的
成员只能是 public 的,而抽象类的成员
可以有多种访问权限。
**4. 使用选择**
使用抽象类:
-
需要在几个相关的类中共享代码。
-
需要能控制继承来的成员的访问权限,而不是都为 public。
-
需要继承非静态(non-static)和非常量(non-final)字段。
使用接口:
-
需要让不相关的类都实现一个方法,例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法;
-
需要使用多重继承。
使用抽象类:
-
需要在几个相关的类中共享代码。
-
需要能控制继承来的成员的访问权限,而不是都为 public。
-
需要继承非静态和非常量字段。
在很多情况下,接口优先于抽象类,因为接口没有抽象类严格的类层次结构要求,可以灵活地为一个类添加行为。并且从 Java 8 开始,接口也可以有默认的方法实现,使得修改接口的成本也变的很低。
-
[
深入理解 abstract class 和 interface
](
https://www.ibm.com/developerworks/cn/java/l-javainterface-abstract/
)
...
...
@@ -499,8 +526,8 @@ System.out.println(InterfaceExample.x);
## super
-
访问父类的构造函数:可以使用 super() 函数访问父类的构造函数,从而完成一些初始化的工作。
-
访问父类的成员:如果子类
覆盖
了父类的中某个方法的实现,可以通过使用 super 关键字来引用父类的方法实现。
-
访问父类的构造函数:可以使用 super() 函数访问父类的构造函数,从而
委托父类
完成一些初始化的工作。
-
访问父类的成员:如果子类
重写
了父类的中某个方法的实现,可以通过使用 super 关键字来引用父类的方法实现。
```
java
public
class
SuperExample
{
...
...
@@ -549,7 +576,7 @@ SuperExtendExample.func()
## 重写与重载
-
重写(Override)存在于继承体系中,指子类实现了一个与父类在方法声明上完全相同的一个方法
,
子类的返回值类型要等于或者小于父类的返回值;
-
重写(Override)存在于继承体系中,指子类实现了一个与父类在方法声明上完全相同的一个方法
。
子类的返回值类型要等于或者小于父类的返回值;
-
重载(Overload)存在于同一个类中,指一个方法与已经存在的方法名称上相同,但是参数类型、个数、顺序至少有一个不同。应该注意的是,返回值不同,其它都相同不算是重载。
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录