1.java概述

1.Java 剔除了 C++ 中许多很少使用、难以理解、易混淆的特性，在目前看来，这些特性带来的麻烦远远多于其带来的好处。
2.Java 有一个丰富的例程库，用于处理像 HTTP 和 FIT 之类的 TCP/IP 协议。Java 应用
程序能够通过 URL 打开和访问网络上的对象，其便捷程度就好像访问本地文件一样。
3.Java 和 C++ 最大的不同在于 Java 采用的指针模型可以消除重写内存
和损坏数据的可能性。
4.Java 编译器能够检测许多在其他语言中仅在运行时才能够检测出来的问题。
5.Java 适用于网络 / 分布式环境。为了达到这个目标，在安全方面投入了很大精力。使用 Java 可以构建防病毒、防篡改的系统。从一开始，Java 就设计成能够防范各种攻击，其中包括：运行时堆栈溢出。如蠕虫和病毒常用的攻击手段。破坏自己的进程空间之外的内存。未经授权读写文件。
6.解释虚拟机指令肯定会比全速运行机器指令慢很多。然而，虚拟机有一个选项，可以将执行最频繁的字节码序列翻译成机器码，这一过程被称为即时编译。
7.与 C 和 C++ 不同，Java 规范中没有“ 依赖具体实现” 的地方，基本教据类型的大小以及有关运算都做了明确的说明。（例如，Java 中的 int 永远为 32 位的整数，而在 C/C++ 中， int 可能是 16 位整数、 32 位整数，也可能是编译器提供商指定的其他大小）。
8.Java 成功地推出后不久，微软就发布了一个叫做 J++ 的产品，它与 Java 有几乎相同的编程语言以及虚拟机，现在，微软不再支持 J++, 取而代之的是另一种名为 C# 的语言。C# 与 Java 有很多相似之处，然而使用的却是完全不同的虚拟机。
9.JavaScript 和Java 几乎没有任何关系。

2.java程序设计

1.根据 Java语言规范， main 方法必须声明为 public。
2.System.out 还有一个 print 方法，它在输出之后不换行。例如， System.out.print
“( Hello”）打印“ Hello” 之后不换行。
3.在 Java 中，/* / 注释不能嵌套 „ 也就是说，不能简单地把代码用 / 和 */ 括起来
作为注释，因为这段代码本身可能也包含一个 */ 。
4.Java 是 -种强类型语言。这就意味着必须为每一个变量声明一种类型: 在 Java 中，共有 8
种基本类型 , 其中有 4 种整型、2 种浮点类型、 1 种用于表示 Unicode 编码的字符
单元的字符类型 char 和 1 种用于表示真值的 boolean 类型。
5.Java 没有任何无符号（unsigned) 形式的 int、 long、 short 或 byte 类型。
6.可以使用十六进制表示浮点数值。例如，0.125=2^{-3} 可以表示成 0x1.0p-3。在十六
进制表示法中，使用 p 表示指数，而不是 e。注意，尾数采用十六进制，指数采用十进
制。指数的基数是 2，而不是 10。
7.常量 Double.POSITIVE_INFINITY、Double.NEGATIVE_INFINITY 和 Double.NaN
( 以及相应的 Float 类型的常量）分别表示这三个特殊的值(正无穷大，负无穷大，NaN，但在实际应用中很少遇到。特别要说明的是，不能检测一个特定值是否等于 Double.NaN，然而，可以使用Double.isNaN 方法。
8.char 类型的值可以表示为十六进制值，其范围从 \u0000 到 \Uffff。
9.所有转义序列都可以出现在加引号的字符字面量或字符串中。例如，’\02122’ 或 "Hello\n”。转
义序列 \u还可以出现在加引号的字符常量或字符串之外（而其他所有转义序列不可以）。例
如：public static void main(String\u005B\ u005D args) 就完全符合语法规则， \u005B 和 \u005D 是 [ 和 ] 的编码。
10.Unicode 转义序列会在解析代码之前得到处理。例如，"\u0022+\u0022” 并不是一个由引号（U+0022) 包围加号构成的字符串。实际上， \u0022 会在解析之前转换为 "，所以说这是一个空串。
11.更隐秘地，一定要当心注释中的 \u。注释 // \u00A0 is a newline 会产生一个语法错误，因为读程序时 \u00A0 会替换为一个换行符。类似地，下面这个注释：
// Look inside c:\users
也会产生一个语法错误，因为 \u 后面并未跟着 4 个十六进制数。
12.在 1991 年发布了 Unicode 1.0, 当时仅占用 65 536 个代码值中不到一半的部分。在设计 Java 时决定采用 16 位的 Unicode 字符集，这样会比使用 8 位字符集的程序设计语言有很大的改进。十分遗憾，经过一段时间，不可避免的事情发生了。Unicode 字符超过了 65 536 个，其主要原因是增加了大量的汉语、日语和韩语中的表意文字。现在， 16 位的 char 类型已经不能满足描述所有 Unicode 字符的需要了。
13.UTF-16 编码采用不同长度的编码表示所有 Unicode 码点。在基本的多语言级别中，每个字符用 16 位表示，通常被称为代码单元（code unit) ; 而辅助字符采用一对连续的代码单元进行编码。、
14.在 Java 中，char 类型描述了 UTF-16 编码中的一个代码单元。强烈建议不要在程序中使用 char 类型，除非确实需要处理 UTF-16 代码单元。最好将字符串作为抽象数据类型处理。
15.变量名必须是一个以字母开头并由字母或数字构成的序列。需要注意，与大多数程序设计语言相比，Java 中“ 字母” 和“ 数字” 的范围更大。字母包括 ’A’ ~ ’Z’、 ’a’~ ’z’、‘_’，‘$’或在某种语言中表示字母的任何 Unicode 字符。
16.变量名中所有的字符都是有意义的，并且大小写敏感。变量名的长度基本上没有限制。
17.如果想要知道哪些 Unicode 字符属于 Java 中的“ 字母”，可以使用 Character 类的isJavaldentifierStart 和 isJavaldentifierPart 方法来检查。
18.尽管 $ 是一个合法的 Java 字符，但不要在你自己的代码中使用这个字符。它只用
在 Java 编译器或其他工具生成的名字中。
19. const 是 Java 保留的关键字，但目前并没有使用。在 Java 中，必须使用 final定义常量。
20. 需要注意，整数被 0 除将会产生一个异常，而浮点数被 0 除将会得到无穷大或 NaN 结果。
21. 操作数转换为同一种类型，然后再进行计算。

如果两个操作数中有一个是 double 类型，另一个操作数就会转换为 double 类型。
否则，如果其中一个操作数是 float 类型，另一个操作数将会转换为 float 类型。
否则，如果其中一个操作数是 long 类型，另一个操作数将会转换为 long 类型。
否则，两个操作数都将被转换为 int 类型。
6 个实心箭头，表示无信息丢失的转换；有 3 个虚箭头，表示可能有精度损失的转换。

22.如果试图将一个数值从一种类型强制转换为另一种类型，而又超出了目标类型的表示范围，结果就会截断成一个完全不同的值。例如，（byte) 300 的实际值为 44。
23.如果 x 是一个 int, 则以下语句x += 3.5 是合法的，它将把 x 设置为（int)(x + 3.5)。
24.应用在布尔值上时，& 和丨运算符也会得到一个布尔值。这些运算符与 &&和| |运
算符很类似，不过 & 和丨运算符不采用“ 短路” 方式来求值。
25.>>> 运算符会用 0 填充高位，这与>>不同，它会用符号位填充高位。不存在 <<<运算符。
26.如果虚拟机始终将相同的字符串共享，就可以使用运算符检测是否相等。但实际上只有字符串常量是共享的，而+ 或 substring 等操作产生的结果并不是共享的。因此，千万不要使甩运算符测试字符串的相等性，以免在程序中出现糟糕的 bug。
27.java中的String类型的length()方法实际上返回的是代码单元的数量，而不是码点(字符)的数量。
28.在 C++ 中，可以在嵌套的块中重定义一个变量。在内层定义的变量会覆盖在外层定义的变量。这样，有可能会导致程序设计错误，因此在 Java 中不允许这样做。
29.对于switch语句，case 标签可以是：

类型为 char、byte、 short 或 int 的常量表达式
枚举常量
从 Java SE 7 开始， case 标签还可以是字符串字面量

30.当在 switch 语句中使用枚举常量时，不必在每个标签中指明枚举名，可以由 switch 的表
达式值确定。例如：

31. 与C++ 不同， Java 没有提供运算符重载功能。程序员无法重定义 + 和 * 运算符，使其应用于 BigInteger类的 add 和 multiply 运算。 Java 语言的设计者确实为字符串的连接重载了 + 运算符，但没有重载其他的运算符，也没有给 Java 程序员在自己的类中重载运算符的机会。
32. 使用静态的 valueOf 方法可以将普通的数值转换为大数值。遗憾的是，不能使用人们熟悉的算术运算符（如：+ 和 *) 处理大数值。而需要使用大数值类中的 add 和 multiply 方法。
33. for each 循环语句不能自动处理二维数组的每一个元素。它是按照行，也就是一维数组处理的。要想访问二维教组 a 的所有元素，需要使用两个嵌套的循环。
34. 要想快速地打印一个二维数组的数据元素列表，可以调用：
System.out.println(Arrays.deepToString(a)) ;
35.Java 实际上没有多维数组，只有一维数组。多维数组被解释为“数组的数组”。

3.对象与类

1.封装（ encapsulation , 有时称为数据隐藏）是与对象有关的一个重要概念。从形式上看，封装不过是将数据和行为组合在一个包中，并对对象的使用者隐藏了数据的实现方式。
2.实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域。程序仅通过对象的方法与对象数据进行交互。封装给对象赋予了“ 黑盒” 特征，这是提高重用性和可靠性的关键。这意味着一个类可以全面地改变存储数据的方式，只要仍旧使用同样的方法操作数据，其他对象就不会知道或介意所发生的变化。
3.在类之间，最常用的关系有依赖关系，聚合关系和继承关系。如果一个类的方法操纵另一个类的对象，我们就说一个类依赖于另一个类，应该尽可能地将相互依赖的类减至最少，如果类 A 不知道 B 的存在，它就不会关心 B的任何改变（这意味着 B 的改变不会导致 A 产生任何 bug )，用软件工程的术语来说，就是让类之间的耦合度最小；聚合关系意味着类 A 的对象包含类 B 的对象；继承就比较熟悉了。
4.并不是所有的类都具有面向对象特征。例如，Math 类。在程序中，可以使用 Math 类的方法，如 Math.random, 并只需要知道方法名和参数（如果有的话，) 而不必了解它的具体实现过程。这正是
封装的关键所在，当然所有类都是这样。但遗憾的是， Math 类只封装了功能，它不需要也不必隐藏数据。由于没有数据，因此也不必担心生成对象以及初始化实例域。
5.一个对象变量并没有实际包含一个对象，而仅仅引用一个对象。
6.文件名必须与 public 类的名字相匹配。在一个源文件中，只能有一个公有类，但可以有任意数目的非公有类。
7.构造器总是伴随着 new 操作符的执行被调用，而不能对一个已经存在的对象调用构造器来达到重新设置实例域的目的。
8.在 Java 中，所有的方法都必须在类的内部定义，但并不表示它们是内联方法。是否将某个方法设置为内联方法是 Java 虚拟机的任务。即时编译器会监视调用那些简洁、经常被调用、没有被重载以及可优化的方法。
9.一个方法可以访问所属类的所有对象的私有数据。

public class Person implements Cloneable {private String name;public Person(String name) {this.name = name;}public void method(Person p) {p.name = "haha";}public String getName() {return name;}
}

public class Test {public static void main(String[] args) throws CloneNotSupportedException {Person p = new Person("a");Person pp = new Person("b");p.method(pp); // 调用p对象的method方法。可以访问pp对象的私有变量。System.out.println(pp.getName());  // haha}
}

10.有时，可能希望将一个计算代码划分成若干个独立的辅助方法。通常，这些辅助方法不应该成为公有接口的一部分，这是由于它们往往与当前的实现机制非常紧密，或者需要一个特别的协议以及一个特别的调用次序。最好将这样的方法设计为 private 的。对于私有方法，如果改用其他方法实现相应的操作，则不必保留原有的方法。如果数据的表达方式发生了变化，这个方法可能会变得难以实现，或者不再需要。然而，只要方法是私有的，类的设计者就可以确信：它不会被外部的其他类操作调用，可以将其删去。如果方法是公有的，就不能将其删去，因为其他的代码很可能依赖它。
11.可以将实例域定义为 final。构建对象时必须初始化这样的域。也就是说，必须确保在每一个构造器执行之后，这个域的值被设置，并且在后面的操作中，不能够再对它进行修改。
12.System.out是一个经常使用的静态常量。
13.如果查看一下 System 类，就会发现有一个 setOut 方法，它可以将 System.out 设置为不同的流。那么为什么这个方法可以修改 final 变量的值呢？原因在于， setOut 方法是一个本地方法，并不是用 Java 语言实现的。本地方法可以绕过 Java 语言的存取控制机制。这是一种特殊的方法，在自己编写程序时，不应该这样处理。
14.两种使用静态方法的情况：1.方法不需要访问对象状态，其所需参数都是通过显式参数提供（例如： Math.pow ) 2.一个方法只需要访问类的静态域。
15.main 方法不对任何对象进行操作。事实上，在启动程序时还没有任何一个对象。静态的main 方法将执行并创建程序所需要的对象。
16.Java 程序设计语言总是采用按值调用。也就是说，方法得到的是所有参数值的一个拷贝，特别是，方法不能修改传递给它的任何参数变量的内容。
17.在 Java 中， this 引用等价于 C++ 的 this 指针。但是，在 C++ 中，一个构造器不能调用另一个构造器 ,，在 C++ 中，必须将抽取出的公共初始化代码编写成一个独立的方法。
18.Java 还有第三种初始化机制，称为初始化块（initializationblock)。在一个类的声明中，可以包含多个代码块。只要构造类的对象，这些块就会被执行。
19.由于初始化数据域有多种途径，所以列出构造过程的所有路径可能相当混乱。下面是调用构造器的具体处理步骤：

所有数据域被初始化为默认值（0、false 或 null。)
按照在类声明中出现的次序，依次执行所有域初始化语句和初始化块。
如果构造器第一行调用了第二个构造器，则执行第二个构造器主体。
执行这个构造器的主体。
20.在 JDK 6 之前，都可以用 Java 编写一个没有 main 方法的“ Hello,World” 程序：

public class Hello
{static
{System.out.println("Hel1o, World");
}
}

当用 java Hello 调用这个类时，就会加栽这个类，静态初始化块将会打印“ Hello,World" ，在此之后，会显示一个消息指出 main 未定义。从 Java SE 7 以后，java 程序首先会检查是否有一个 main 方法。
21.有些面向对象的程序设计语言，特别是 C++, 有显式的析构器方法，其中放置一些当对象不再使用时需要执行的清理代码。在析构器中，最常见的操作是回收分配给对象的存储空间。由于 Java 有自动的垃圾回收器，不需要人工回收内存，所以 Java 不支持析构器。
22.需要注意的是，只能使用星号（*) 导入一个包，而不能使用 import java.* 或import java.*.* 导入以 java 为前缀的所有包。
23.import 语句不仅可以导人类，还增加了导人静态方法和静态域的功能。例如，如果在源文件的顶部，添加一条指令：import static java.lang.System.*;就可以使用 System 类的静态方法和静态域，而不必加类名前缀
24.如果没有在源文件中放置 package 语句，这个源文件中的类就被放置在一个默认包( defaulf package ) 中。默认包是一个没有名字的包。
25.编译器在编译源文件的时候不检查目录结构。例如，假定有一个源文件开头有下列语句：package com.myconpany;即使这个源文件没有在子目录 com/mycompany 下，也可以进行编译。如果它不依赖
于其他包，就不会出现编译错误。但是，最终的程序将无法运行，除非先将所有类文件移到正确的位置上。如果包与目录不匹配，虚拟机就找不到类。
26.JAR 文件使用 ZIP 格式组织文件和子目录。可以使用所有 ZIP 实用程序查看内部的 rt.jar 以及其他的 JAR 文件。
27.java虚拟机和编译器定位文件的方式不一样，编译器更加复杂一些，这个以后再说吧，看得云里雾里的。
28.对于文档注释，类注释必须放在 import 语句之后，类定义之前。

4 继承

1.在 Java 中，所有的继承都是公有继承，而没有 C++ 中的私有继承和保护继承 .
2.有些人认为 super 与 this 引用是类似的概念，实际上，这样比较并不太恰当。这是因为 super 不是一个对象的引用，不能将 super 赋给另一个对象变量，它只是一个指示编译器调用超类方法的特殊关键字。
3.使用super 调用构造器的语句必须是子类构造器的第一条语句。如果子类的构造器没有显式地调用超类的构造器，则将自动地调用超类默认（没有参数 )的构造器。如果超类没有不带参数的构造器，并且在子类的构造器中又没有显式地调用超类的其他构造器，则 Java 编译器将报告错误。
4.一个对象变量（例如，变量 e ) 可以指示多种实际类型的现象被称为多态（polymorphism)。在运行时能够自动地选择调用哪个方法的现象称为动态绑定（ dynamic binding。)
5.在 Java 中，不需要将方法声明为虚拟方法。动态绑定是默认的处理方式。如果不希望让一个方法具有虚拟特征，可以将它标记为 final。
6.Java 不支持多继承。
7.在 Java 中，子类数组的引用可以转换成超类数组的引用，而不需要采用强制类型转换。然而这样有可能会发生错误，为了确保不发生错误，所有数组都要牢记创建它们的元素类型，并负责监督仅将类型兼容的引用存储到数组中。
8.在覆盖一个方法的时候，子类方法不能低于超类方法的可见性。
9.如果将一个类声明为 final，只有其中的方法自动地成为 final,而不包括域。
10.String 类也是 final 类，这意味着不允许任何人定义 String 的子类。
11.在 Java 中，只有基本类型（ primitive types) 不是对象，例如，数值、字符和布尔类型的值都不是对象。所有的数组类型，不管是对象数组还是基本类型的数组都扩展了 Object 类。
12.由于 hashCode 方法定义在 Object 类中，因此每个对象都有一个默认的散列码，其值为对象的存储地址。
13.Equals 与 hashCode 的定义必须一致：如果 x.equals(y) 返回 true, 那么 x.hashCode( ) 就必须与 y.hashCode( ) 具有相同的值。
14.只要对象与一个字符串通过操作符“ +” 连接起来，Java 编译就会自动地调用 toString方法，以便获得这个对象的字符串描述。
15.在 Java 中允许在运行时确定数组的大小。
16.数组列表的容量与数组的大小有一个非常重要的区别。如果为数组分配 100 个元素的存储空间，数组就有 100 个空位置可以使用。而容量为 100 个元素的数组列表只是拥有保存 100 个元素的潜力（实际上，重新分配空间的话，将会超过100 ), 但是在最初，甚至完成初始化构造之后，数组列表根本就不含有任何元素。
17.一旦能够确认数组列表的大小不再发生变化，就可以调用 trimToSize 方法。这个方法将存储区域的大小调整为当前元素数量所需要的存储空间数目。垃圾回收器将回收多余的存储空间。一旦整理了数组列表的大小，添加新元素就需要花时间再次移动存储块，所以应该在确认不会添加任何元素时，再调用 trimToSize。
18.对象包装器类用 final修饰 , 因此不能定义它们的子类。
19.自动装箱规范要求 boolean、byte、char 127，介于-128 ~ 127之间的 short 和int 被包装到固定的对象中。
20.装箱和拆箱是编译器认可的，而不是虚拟机。编译器在生成类的字节码时，插人必要的方法调用。虚拟机只是执行这些字节码。
21.包装器类不可以用来实现修改数值参数的方法。
22.能够分析类能力的程序称为反射（reflective )。反射是一种功能强大且复杂的机制。使用它的主要人员是工具构造者，而不是应用程序员。
23.在程序运行期间，Java 运行时系统始终为所有的对象维护一个被称为运行时的类型标识。这个信息跟踪着每个对象所属的类。虚拟机利用运行时类型信息选择相应的方法执行。然而，可以通过专门的 Java 类访问这些信息。保存这些信息的类被称为 Class。
24.一个 Class 对象实际上表示的是一个类型，而这个类型未必一定是一种类。例如，int 不是类，但 int.class 是一个 Class 类型的对象。
25.Class 类实际上是一个泛型类。例如， Employee.class 的类型是 Class<Employee>。没有说明这个问题的原因是：它将已经抽象的概念更加复杂化了。在大多数实际问题中，可以忽略类型参数，而使用原始的 Class 类。
26.虚拟机为每个类型管理一个 Class 对象。因此，可以利用==运算符实现两个类对象比较的操作。
27.还有一个很有用的方法 newlnstance( )，可以用来动态地创建一个类的实例例如e.getClass().newlnstance();创建了一个与 e 具有相同类类型的实例。 newlnstance 方法调用默认的构造器（没有参数的构造器）初始化新创建的对象。如果这个类没有默认的构造器，就会抛出一个异常。
28.Class类中的 getFields、 getMethods 和 getConstructors 方法将分别返回类提供的public 域、方法和构造器数组，其中包括超类的公有成员。Class 类的 getDeclareFields、getDeclareMethods 和 getDeclaredConstructors 方法将分别返回类中声明的全部域、方法和构造器，其中包括私有和受保护成员，但不包括超类的成员。
29.反射机制的默认行为受限于 Java 的访问控制。然而，如果一个 Java 程序没有受到安全管理器的控制，就可以覆盖访问控制。为了达到这个目的，需要调用 Field、 Method 或Constructor 对象的 setAccessible 方法。
30.setAccessible 方法是 AccessibleObject 类中的一个方法，它是 Field、 Method 和 Constructor类的公共超类。这个特性是为调试、持久存储和相似机制提供的。
31.将一个 Employee[ ]临时地转换成 Object[ ] 数组，然后再把它转换回来是可以的，但从一开始就是 Object[]的数组却永远不能转换成 Employee[]数组。
32.invoke 的参数和返回值必须是 Object 类型的。这就意味着必须进行多次的类型转换。

5 接口、lambda 表达式与内部类

1.接口中的所有方法自动地属于 public。因此，在接口中声明方法时，不必提供关键字public。

6 并发

1.当线程的 run 方法执行方法体中最后一条语句后，并经由执行 return 语句返冋时，或者出现了在方法中没有捕获的异常时，线程将终止。
2.没有可以强制线程终止的方法。然而， interrupt 方法可以用来请求终止线程。
3.

java核心技术卷1基础知识整理相关推荐

Java核心技术卷1 基础知识
网站更多书籍点击进入>> CiCi岛下载电子版仅供预览及学习交流使用,下载后请24小时内删除,支持正版,喜欢的请购买正版书籍电子书下载(皮皮云盘-点击"普通下载" ...
Java核心技术卷I基础知识3.6.6　码点与代码单元
3.6.6 码点与代码单元 Java字符串由char值序列组成.从3.3.3节"char类型"已经看到,char数据类型是一个采用UTF-16编码表示Unicode码点的代码单元. ...
《Java核心技术:卷I 基础知识》第1章 Java 程序设计概述阅读与重点标记
第 1 章 Java 程序设计概述 1996年 Java 第一次发布就引起了人们的极大兴趣.关注 Java 的人士不仅限于计算机出版界,还有诸如<纽约时报><华盛顿邮报>< ...
Java核心技术卷I基础知识1.2.7　可移植性
1.2.7 可移植性与C和C++不同,Java规范中没有"依赖具体实现"的地方.基本数据类型的大小以及有关运算都做了明确的说明. 例如,Java中的int永远为32位的整数,而在 ...
Java核心技术卷1 基础知识学习笔记——第三章 java的基本程序设计结构
1. 一个正整数除以0的结果为正无穷大,0/0或者负数的平方根的结果为NaN(不是一个数字): if(x==Double.NaN)//is never true,所有非数值的值都认为是不同的 if(D ...
【Java】第六章接口、lambda 表达式与内部类 Java核心技术卷1基础知识原书第10版读书笔记
第六章接口.lambda表达式与内部类 6. 接口.lambda 表达式与内部类 6.1 接口 6.1.1 接口概念 6.1.2 接口的特性 6.1.3 接口与抽象类 6.1.4 静态方法 6.1. ...
【java】第一阶段基础知识整理
JAVA基础----终弄清java核心技术卷1中的int fourthBitFromRight = (n 0b1000 ) / 0b1000；是怎么回事了。。。
一个关于位与运算的问题对于<JAVA核心技术卷1>(第11版) page43 第三章 3.5.8一节中有个描述如下: 如果n是一个整数变量,而二进制表示的n从右边数第四位1,则 int ...
赠送大家最喜欢的Java书籍，《Java核心技术.卷I 和卷II》
文末送书福利,记得看完~ 导读:学习Java的经典名著非常多,这本书是你一定不能错过的:由凯.霍斯特曼写的<Core Java>,中文版名为<Java核心技术>.这本书几乎出现 ...
python常用变量名_python基础知识整理
Python Python开发 Python语言 python基础知识整理序言:本文简单介绍python基础知识的一些重要知识点,用于总结复习,每个知识点的具体用法会在后面的博客中一一补充程序: 一 ...

java核心技术卷1基础知识整理