[Java] Learning_Notes for J2SE
Java Learning --others : 数组模拟链表 - 马士兵教的
--------------------------------
Java
主讲教师 ： 马士兵
课程内容
* Java 基础
* 语法基础
* OO
* Exception
* Array
* 基础类 - 常用类
* I / O Stream
* Collection / Generic
* Thread
* TCP / UDP
* GUI
* Meta Data
* Regular Expression
Java 体系
* JDK初步
* 其他方向的基础
* Java Web编程
* 针对Web程序
* J2EE
* 企业级应用
* J2ME
* 移动设备
* 移动增值
* SP运营商
教学方法
* 巨无霸式的教学
* 理论
* 举例
* 理论回顾
* 练习
* 讲解
* 注重结合工程实践
* 注重传授自学能力
能力的三个层次 {
* 知识
* 学习前人的知识
* 解决问题的方法
* 灵活运用学到的知识
* 解决问题的思路
* 创造解决问题的方法
}
学习方法 {
* 学习本讲义
* 完成习题
* 运用自学的能力
* 读
* 写
* 查
* 背
}
预备知识 {
* 英语
* 计算机基本操作
}
其他
* 企业与学校之间的区别
* 时限
* 实用为主
* 浩瀚知识的分类
* 实际开发中经常使用的(牢牢掌握)
* 不经常使用用时就能查得到的(了解)
* 八辈子用不着一回的(运用自己的能力去查)
总结
* 乐观的努力
* 眼光要高远
* 脚步要踏实
错误的做法(教师)
* 讲得多，练得少
* 只灌输知识点，没有串联
* 不培养自学能力
* 给答案不给思路
* 项目太简单
* 项目太复杂
* 项目太少
* 注重授课技巧，不注重基本功
* 重管理技巧，轻开发技巧
* 知识太陈旧
错误的做法 (学生)
* 只看不练
* 只听不练
* 钻到细节中拔不出来(初学者)
* 修正 ： 明确目标，心无旁骛
学校 ： 集中所有精力，教授实用知识
* 对计算机心存敬畏
* 不敢动(装卸软件, 安装系统)
* 不敢调试bug
尚学堂 手把手教程
--------------------------------
J2SE 之 JAVA概述
想学习J2ME, JSP / Servlet, J2EE 吗? * 请打好基础 - J2SE
* 内容
* 计算机语言的历史以及Java语言的历史地位
* Java 自身的发展史
* Java体系
* Java的特点
* Java的运行机制
* Java运行环境的安装与配置
* 第一个程序HelloWorld
* 内容
* JAVA概述
* JAVA语言基础
* 面向对象编程
* JAVA异常处理机制
* 数组
* JAVA常用类
* JAVA容器类
* JAVA流技术
* JAVA多线程机制
* JAVA网络编程
* GUI编程
* 计算机语言发展史及Java的历史地位
* 第一代语言
* 打孔机 -- 纯机器语言
* 第二代语言
* 汇编
* 第三代语言
* C, Pascal, Fortran 面向过程的语言
* C++面向过程/面向对象
* Java跨平台的纯面向对象的语言
* .NET跨平台的语言
计算机语言朝着人类易于理解的方向发展
* Java发展史与java体系
* 95年， Sun发布JDK1.0
* 98年，JDL1.2, 更名为Java2
* 后续JDK 1.3, 1.4
* 目前JDK 1.5, 更名为Java5.0
* 我们使用5.0， 1.6， 1.7
j2se --> {
1, java web {
* j2ee 95% 以上
* 移动增值
}
2, j2me
}
* Java语言的特点
* 一种面向对象的语言
* 一种平台无关的语言, 提供程序运行的解释环境
* 一种健壮的语言, 吸收了C/C++语言的优点， 但去掉了其影响程序健壮性的部
分(如: 指针， 内存的申请与释放等)。
* Java程序运行机制及运行过程
* Java两种核心机制:
* Java 虚拟机 (JVM)
* 垃圾收集机制(Garbage collection)
* 核心机制之Java虚拟机 {
* java虚拟机可以理解成一个以字节码为机器指令的CPU
* 对于不同的运行平台, 有不同的虚拟机
* Java虚拟机机制屏蔽了底层运行平台的差别, 实现了"一次编译, 随处运行"。
-- Jvm for Unix
*.java -编译-> *.class -执行-> JVM- -- Jvm for Windos
-- Jvm for otherPlatform
Java -- 解释性的语言
C/C++ -- 编译型的语言
}
* 核心机制之垃圾收集 {
* 不再使用的内存空间应回收 - 垃圾回收
* 在 C/C++ 等语言中, 由程序员负责回收无用内存
* Java语言消除了程序员回收无用内存空间的责任; 它提供一种系统级线程跟踪存
储空间的分配情况。并在JVM的空闲时, 检查并释放那些可被释放的存储器空间。
* 垃圾收集在Java程序运行过程中自动进行, 程序员无法精确控制和干预。
* J2SDK & JRE
- Software Development Kit (软件开发包)
- Java Runtime Environment
开发需要 JDK
用户只需 JRE
* Java开发环境的下载 安装 配置
* 配置 Java开发环境步骤 (WindowsXP)
* 下载 并安装最新版本的J2SDK
* 设置 Windows环境变量。
* 选择 合适的文本编辑器或使用集成开发环境
-------------------------------
* 下载 http://java.sun.com
* 安装
* 配置 path & classpath
* path : windows系统执行命令时要搜寻的路径
* classpath : java在编译和运行时要找的class所在的路径
* 验证 HelloWorld.java
* java 运行 java 程序
* javac 编译 java 程序
. 代表当前路径
* Java Application初步
* Java源文件以“java”为扩展名。源文件的基本组成部分是类 (class), 如本例中的 HelloWorld 类
* 一个源文件中最多只能有一个public类. 其它类的个数不限，如果源文件 文件包含一个public类，
它必需按该类名命名
* Java 应用程序的入口是 main() 方法
* Java语言严格区分大小写
* Java方法有一条条语句构成, 每个语句以分号结束
* Java语言有三种注释方式: { // 单行注释， /* 多行注释 */
/**
* 用于多行注释，并且可以被doc工具解析
*/
}
* 总结第一个程序 {
* 构建程序自己的环境
* 运用copy
* 掌握 path 和 classpath
* 熟悉常见的错误
* 熟悉java程序简单规则
* 熟悉java程序的编译与运行
}
* UltraEdit遗留问题
补充 {
* 先谈学习方法
* 你怎么去了解一台发动机?
* 你怎么去了解一座高山? 怎么去了解你的校园？
* 你怎么去画一树寒梅
* 先学脉络，再学细节，这是规律，请务必尊重学习规律。
* 养成自动学习的习惯
* 学技术 google 谷老师非常好，不姓 百
* 建议你的 JDK 装在不带空格的目录里面！
path
* 操作系统用 path 的路径来找执行程序
* javac/java 找不到路径的解决方式
* 用户变量 / 系统变量
* FAQ:
* 系统装了多个版本的JDK
* ping 找不到路径
* 命令收集 : {
cd \
notepad
echo %path%
set path=d:\java\java-app\jdk1.5\bin;%path%
java -verbose HelloWorld
}
* 做任何事情 {
听别人意见的时候, 先做自己的努力
* classpath {
* javac/java 用来查找类
* “.” 代表当前路径
* jar文件 = 路径(文件夹)
* FAQ:
* 2 projects, 用同一个类的不同版本
* 总结
* 抓住脉络，要事为先
* 主动学习, 培养能力
* 动手动手，动手动手
* Next:
* OO 思维
* 要求：
* 了解面向对象的概念
* 类，对象，属性，方法
* 预习第三章
* 下载eclipse
* 时间：
* http://www.bjsxt.com
* 常见Java 开发环境
* 编辑器
* UltraEdit
* EditPlus
* 集成开发环境 (IDE):
* JBuilder (http://www.borland.com)
* Eclipse (http://www.eclipse.org)
* Sun One Studio (http://java.sun.com)
* WSAD (http://www.ibm.com)
* 内容
* 标识符
* 关键字
* Java 基本数据类型
* 运算符
* 表达式和语句
* 分支
* 循环
* 方法
* 变量的作用域
* 递归调用
变量名称
* 在方法体内 声明的变量 叫做 局部变量
* 在方法体外, 类体内声明的变量叫做 成员变量
* 成员变量 {
* 成员变量可以是Java语言中任何一种数据类型(包括基本类型和引用类型)
* 在定义成员变量时可以对其初始化,如果不对其初始化
* 成员变量的作用范围为整个类体
}
Java数据类型的划分 {
-- 整数类型 (byte, short, int, long)
-- 数值型 --
| -- 浮点类型 (float, double)
--基本数据类型 -- 字符型 (char)
| |
| -- 布尔型 (boolean)
数据类型 --
| -- 类 (class)
| |
--引用数据类型 -- 接口 (interface)
|
-- 数组 (array)
Java 中定义了4类8种基本数据类型
boolean 类型只允许取值 true / false , 不可以用 0 或 非0 替代。
char java 字符采用 Unicode 编码 (全球语言统一编码), 每个字符占两个字节
}
J2SE 之 面向对象编程
* 编程语言的发展
* 面向过程的设计思想
* 面向对象的设计思想
* 对象和类的概念
* 类之间的关系
* 对象和引用
* Java 类的定义
* 构造函数
* 对象的创建和使用
* this 关键字
* static 关键字
* package 和 import 语句
* 访问控制
* 类的继承
* 方法的重写
* final 关键字
* Object类
* 对象转型
* 多态
* 抽象类
* 接口
---------
类 (对象) 之间的关系 {
1, 关联关系 -- 学院 - 研究生 - 教授
2, 继承关系 -- 运动员 { 游泳运动员，球类运动员， 射击运动员 }
3, 聚合关系 -- 聚集 - 球队{队长，队员} 组合 - 人-{ 头， 身体， 四肢 }
4, 实现关系 --
}
* 对象是Java程序的核心, 在Java中万事万物皆 “对象”
* 对象可以看成是静态属性 (成员变量) 和 动态属性(方法) 的封装体
* 类是用来创建同一类型的对象的 “模板”, 在一个类中定义了该类对象所应具有的成员变量以及方法
----------------------------------------------------------
我们的语言 -> 成员变量 = 属性 方法 = 函数
----------------------------------------------------------
为什么用对象？
* 面向对象的编程 -- 一组对象互相配合通过沟通完成特定功能
* 汇编是对机器语言的抽象
* 面向过程的语言是对汇编的抽象
* 对象更加符合对于现实问题的抽象
* 对象都有对外服务的接口
* 通过继承可以复用
* 对象隐藏内部服务的实现
* 通过聚合可以复用
* 面向对象更加容易使我们达到这些年苦苦追求的境界
* Reusable, Extensibility
* 组件 -- 比对象更高层次上的抽象 (二进制级别)
* EJB, Web Service, CORBA, COM ...
* 命名规则 {
* 类名首字母大写
* 变量名和方法名的首字母小写
* 运用驼峰标识
}
* 对象的创建和使用 {
* 必须使用 new 关键字创建对象
* 使用对象引用
* 同一类的每个对象共享该类的方法
* 非静态方法是针对每个对象进行调用
}
* this 关键字 {
* 在类的方法定义中使用的 this 关键字代表使用该方法的对象的引用
* 在必须指出当前使用方法的对象是谁时要使用this
* 有时使用this可以处理方法中成员变量和参数重名的情况。
* this可以看作是一个变量，它的值是当前对象的引用
}
* static 关键字 {
* 在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用时被初始化。
* 用 static 声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法
中不可访问非static成员。
* 静态方法不再是针对于某个对象调用, 所以不能访问非静态成员。
* 可以通过对象引用或类名访问静态成员。
}
* package / import
* J2SDK 中主要的包介绍
* java.lang - 包含一些 java 语言的核心类
* java,awt - 包含了构成抽象窗口工具集 (abstract window tookit) 的多个类
* java.applet-包含applet运行所需的一些类
* java.net - 包含执行与网络相关的操作的类
* java.io - 包含能提供多种输入/输出功能的类
* java.util - 包含一些实用工具类.
* 类的继承与权限控制
* 方法的重写
* super 关键字
* Object类
* Object类是所有Java类的根基类
* toString方法
* Object类中定义有 public String toString() 方法，其返回值是 String 类型, 描述当前对象的有关信息
* 在进行 String 与其他类型数据的连接操作时 (如：
System.out.println("info" + person), 将自动调用该对象类的 tiString() 方法
* 可以根据需要在用户自定义类型中重写 toString() 方法
* equals 方法
* Object 类中定义有：
* public boolean equals(Object obj) 方法
* 提供对象是否 “相等” 的逻辑
* Object的 equals 方法定义为：x.equals(y) 当 x 和 y 是同一对象的应用
时返回 true 否则返回 false
* J2SDk 提供的一些类，如 String, Date等，重写了 Object 的 equals 方法，调用
这些类的 equals 方法, x.equals(y), 当 x 和 y 所引用的对象是同一类对象且
属性内容相等时 (并不一定是相同对象), 返回 true 否则返回 false.
* 可以根据需要在用户自定义类型中重写 equals 方法。
* 对象转型
* 动态绑定 和 多态
* 抽象类
* Final 关键字
* 接口 - 特殊的抽象类 {
只包含常量和方法的定义
* 第六章 常用类 {
* 字符串相关类 (String, StringBuffer)
* 基本数据类型包装类
* Math类
* File类
* 枚举类
* String 类
* java.lang.String 类代表 不可变 的字符序列
* StringBuffer 类
* java.lang.StringBuffer 代表可变的字符序列
* 基本数据类型包装类
* 包装类(如：Integer, Double)
* java.lang.Integer
* Math 类
java.lang.Math
* File 类
java.lang.File
* 补充 java.lang.Enum
总结
* String
* 正则表达式
* 包装类
* Math, File, 枚举
ile类
* 枚举类
* String 类
* java.lang.String 类代表 不可变 的字符序列
* StringBuffer 类
* java.lang.StringBuffer 代表可变的字符序列
* 基本数据类型包装类
* 包装类(如：Integer, Double)
* java.lang.Integer
* Math 类
java.lang.Math
* File 类
java.lang.File
* 补充 java.lang.Enum
总结
* String
* 正则表达式
* 包装类
* Math, File, 枚举
}
第七章 容器 {
* 容器的概念
* 容器API
* Collection 接口
* Iterator 接口
* 增强的 for 循环
* Set 接口
* List接口 和 Comparable接口
* Collections 类
* Map 接口
* 自动打包 / 解包
* 泛型 (JDK1.5新增)
-----
* J2SDk 所提供的容器位于 java.util 包内。
* 容器API的类图如下图所示：
<<interface>>
Collection
<<interface>>
<<interface>> <<interface>> ^
Set List |
^ ^ |
| _______|______ |
HashSet LinkedList ArrayList HashMap
* Collection 接口 -- 定义了存取一组对象的方法, 其子接口 Set 和 List 分别定
义了存储方式。
* Set 中的数据对象没有顺序且不可以重复。
* List中的数据对象有顺序且可以重复
* Map 接口定义了存储 “键 (key) -- 值 (value) 映射"对"的方法。
Collection 方法举例
* 容器类对象在调用 remove, contains 等方法时需要比较对象是否相等
这会涉及到对象类型的 equals 方法和 hashCode 方法，对于自定义的
类型，需要要重写 equals 和 hashCode 方法以实现自定义的对象相等
规则。
* 注意 ： 相等的对象应该具有相等的 hashcodes
* ---
第二遍学习java**************************
*** 第一，二章 配置, 基础 *** 手中无剑， 心中有剑
分析设计这个东西 : (1) 有哪些类
(2) 类的属性和方法
(3) 类与类之间的关系
一个源文件只能有一个 public class
*******************************************************************************
const(C++) = final(JAVA) 变量本质 <-> 一小格
第二章 就、java 数据类型
java里所有的数字都是有符号的。
byte 1 int 4
short 2 long 8
java语言的数据类型在任何操作系统所占用的大小一样。
十六进制 0x12 或者 OX12
java 整数默认为int, 声明long类型，后面加 l / L.
Java 常量 整型常量，字符常量，字符串常量...
格式 ： (1) 要让别人看得清楚 (2) 要让别人看得舒服
浮点类型 ： {
float 4
double 8
十进制 ： 3.14 314.0 .314
科学记数法 ： 3.14e2 3.14E2 100E-2
float 放入 double 中会出错， int 放入 long 中不会出错.解释麻烦。
float精度7位，double精度15位
}
* boolean 类型不可以转换为其他数据类型
* 整形，字符型，浮点型的数据在混合运算中相互转换，转换时遵循原则 ：
(1) 容量小的类型自动转换为容量大的数据类型
* byte, short, char -> int -> long -> float -> double
* byte, short, char 之间不会互相转换，它们三者在计算的时候，首先会转为int
(2) 容量大的要转换为容量小的，要加强制转换，但可能造成精度降低和溢出。
(3) 有多种数据类型的数据混合运算时，系统首先全转为容量最大的那个类型，然后再进行计算。
(4) 实数常量默认为 double, 整数常量默认为 int
可以将 int 赋值给 short 等变量，但是不要超过范围。
(6) 运算符 {
*1 字符串连接符 '+' 也是算术加法。
*2 "+" 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串再连接。
*3 当进行打印时，无论任何类型，都自动转为字符串进行打印 System.out.println(c);
}
(7) if / else分支, switch, ...while, for, do {} while
*1 switch () {
case xx :
...default :
} 小心case穿透，多个case可以合并，default可以省略，java中的switch只能探测int类型。
第二章总结 ： (1)* 标识符 (2)* 关键字 (3)* 基本数据类型 (4)* 运算符 (5)* 表达式和语句
(6)* 分支 (7)* 循环 (8)* 方法 (9)* 变量的作用域 (10)* 递归调用
*******************************************************************************************
***** —————————————————— ****
**** 第五章 - 数组 ****
**** —————————————————— ****
* 四维空间
int[] a, int a[];
内存分析 - 知道了内存你就明白了一切！
本来无一物 ： 何处装数组。
* 动态初始化
* 静态初始化 int a[] = {3, 9, 8}; 内部过程屏蔽掉啦！
ipconfig
ipconfig -all 这里 -all 就是命令行参数。
基础类型一般分配在栈上面！包装类，用于把基础类型包装成对象，则分配在堆上了。
例如 类 Double, Integer
约瑟夫环 - 面向过程 和 面向对象 写法
另一个比较精巧的算法 ： 用数组来模拟链表
算法和逻辑思维能力不是一朝一夕能完成的。
排序算法紧跟着的是 - 搜索算法
-------------------------------
你这里是通过对象square1调用的方法getsquare()
public static void main(String[] args){
getsquare(); //这里会出错
}
是的。其实main函数可以简单认为跟本类没什么关系，只是调用本类的
其它静态方法时不用写类名而已。所以，要调用其它非静态方法，都要
先实例化，就像别的类来调用一样。
-------- 我有些懂啦！ 但还是不太懂，我能理解啦！ (个人理解)--------
二维数组 ： 可以看成以数组为元素的数组
* 数组的拷贝 {
}
大公司剥削人剥削得最厉害！
明白内存你就明白了一切！。。。
总结 {
* 数组内存的布局
* 常见算法
}
}
***** —————————————————— ****
**** 第六章 - 常用类 ****
**** —————————————————— ****
本章内容 {
* 字符串相关类 (String, StringBuffer)
* 基本数据类型包装类
* Math类
* File类
* 枚举类
* java.lang.String 类代表不可变的字符序列
String s1 = "helo";
String s3 = "hello";
s1 == s3 true
字符串常量 - data seg 区
data segment 编译器有优化
如果是 new s1 == s3 false
s1.equals(s3) true
字符串你可以看成是一个字符数组！
String 类常用方法 {
* 静态重载方法 public static String valueOf(...)
* public String[] spllit(String regex)
}
String.valueOf(Object obj); 多态的存在
toString
java.lang.StringBuffer 代表可变的字符序列
* 基本数据类型包装类
基本数据 ： 栈 -> 包装 --> 堆上面
* 包装类 {
* 写程序要循序渐进方法
}
* Math 类 { java.lang.Math 其中方法的参数和返回值类型都为 double }
* File 类 { java.io.File 类代表系统文件名 (路径和文件名)
File 类的常见构造方法 ：
* public File(String pathname)
以 pathname 为路径创建 File 对象, 如果 pathname 是相对路径，则默认的当前路径在系统属性 user.dir 中存储
* public File(String parent, String child)
* File 的静态属性 String separator 存储了当前系统的路径分隔符。
原型 ： public static final String separator 但是事实上无论在哪 你写 / 都没有问题
注意 \ 在 java 里面是转义字符
}
* Enum - java.lang.Enum 枚举类型 {
1, 只能够取特定值中的一个
2, 使用 enum 关键字
3, 是 java.lang.Enum
4, 举例 ： TestEnum.java
}
总结~~~ API 和 金庸的书差不多！
***** —————————————————— ****
**** 第七章 - 容 器 ****
**** —————————————————— ****
第七章 容器 {
* 容器的概念 - 数组是么， 当然是！
* 容器API
* Collection 接口
* Iterator 接口
* 增强的 for 循环
* Set 接口
* List接口 和 Comparable接口
* Collections 类
* Map 接口
* 自动打包 / 解包
* 泛型 (JDK1.5新增)
-----
* J2SDk 所提供的容器位于 java.util 包内。
* 容器API的类图如下图所示：
--------------------------------------------------
1136 1136 1136 -- 一个图, 一个类, 三个知识点，六个接口
<<interface>>
Collection
/ \ <<interface>>
<<interface>> <<interface>> ^
Set List |
^ ^ |
| _______|______ |
HashSet LinkedList ArrayList HashMap
1136 1136 1136 一个图, 一个类, 三个知识点，六个接口
* Collection 接口 -- 定义了存取一组对象的方法, 其子接口 Set 和 List 分别定义了存储方式。
* Set 中的数据对象没有顺序且不可以重复。
* List 中的数据对象有顺序且可以重复
* Map 接口定义了存储 “键 (key) -- 值 (value) 映射"对"的方法。
Collection 方法举例
* 容器类对象在调用 remove, contains 等方法时需要比较对象是否相等
这会涉及到对象类型的 equals 方法和 hashCode 方法，对于自定义的
类型，需要要重写 equals 和 hashCode 方法以实现自定义的对象相等规则。
* 注意 ： 相等的对象应该具有相等的 hashcodes
ArrayList 底层是一个数组
哈哈： 装入的是对象，因为对象在堆上，栈里面的内容随时可能被清空！
hashCode 能直接定位到那个对象
toyreb
Iterator - 接口最小化原则
我这大管家在做操作的时候 ： 连主人做任何的操作都不让操作啦！因为 iterater 执行了锁定，谁也不让谁看！
JDK 1.5 增强的 for 循环
Set {
HashSet, TreeSet 一个以 hash 表实现， 一个以 树 结构实现
}
List {
Object set(int index, Object element)
int indexof(Object o);
int lastIndexof(Object o);
}
*** 一个类 {
Collections -- java.util.Collections 提供了一些静态方法实现了基于List容器的一些常用算法
例如 {
void sort(List)
...
}
LinkedList -- 逆序的时候效率较 ArrayList 高！
对于 特定的 对象怎么确定谁大谁小。 {
对象间可以比较大小
通过 接口 只能看见对象的一点】
Comparable 接口 -- 所有可以实现排序的类 都实现了 Comparable 接口
}
public int compareTo(Object obj)
泛型规定 - 只能传 “猫”
vector / hashtable 以前遗留下来的。效率特别低
Map 接口 {
Map 接口的实现类有 HashMap 和 TreeMap 等。 {hashmap 用 hash表来实现， TreeMap 用二叉树来实现-红黑}
Map 类中存储的键 - 值对通过键来标识，所以键值不能重复。{
不能重复 ： 是equals()
equals() 太慢， 所以我们用 hashCode() 来比较
}
}
JDK 1.5 之后 {
可以自动打包和解包
# - Auto-boxing / unboxing
* 在合适的时机自动打包 , 解包
* 自动将基础类型转化为对象
* 自动将对象转换为基础类型
* TestMap2.java
}
示例练习 {
TestArgsWords.java
}
JDK 1.5 泛型
* 起因 ：
* JDK 1.4 以前类型不明确
* 装入集合类型都被当作 Object 对待, 从而失去自己的实际类型。
* 从集合中取出时往往需要转型, 效率低, 容易产生错误。
* 解决办法 ：
* 在定义集合的时候同时定义集合中对象的类型
* 示例 ： BasicGeneric.java
* 可以在定义 Collection 的时候指定
* 也可以在循环时用 Iterator 指定
* 好处 ：
* 增强程序的可读性和稳定性
什么时候可以指定自己的类型 ： 你看 API， 他跟你就可以跟
* 总结 {
1136
* 一个图
* 一个类
* Collections
* 三个知识点
* For
* Generic
* Auto-boxing / unboxing
* 六个接口 {
1, Collection {
2, Set,
3, List
}
4, Map
5, Iterator
6, Comparable
}
***** —————————————————— ****
**** 第八章 - 流 ****
**** —————————————————— ****
能帮助你建立文件，不能帮你建目录
读到内存区 -
* 转换流 {
中文 windos 编码 JBK
当前系统默认的 编码是 JBK
IOS8859_1 包含的所有西欧语言 --> 后来才推出 UniCode (国际标准化组织为了包含全球)
JBK JB2312 JB18030 东方人自己的编码 - 国标码 - 就是汉字，你可以认为
日文，韩文 都有自己的编码 - 台湾有自己的 大五码
拉丁1， 2， 3， 4， 5. 6. 7. 8. 9 都同意啦！包括俄罗斯， 但是中文还不行 ---- > UniCode
FileOutputStream() 构造方法自己去查
* System.in {
System 类 -- in 是 InputStream 类型
public static final InputStream in 抽象类 类型， 又是父类引用指向子类对象
InputStreamReader isr = new InputStreamReader(System.in);
System.in -> 管道直接堆到黑窗口上
BufferedReader br = new BufferedReader(isr);
wait()
运行后 ： 等待在那 - 阻塞式的方法 很多
readLine() 有点特殊
其实是 System.in 比较特殊 -- 标准输入 - 等待着标准输入 {
你不输入 - 我可不就等着么，当然这个也叫做同步方法。
你不输入，我就不能干别的
同步式的
}
* 数据流 {
请你把 long 类型的数， 写到 --> 文件里面去
readUTF()
UTF8 比较省空间
}
* 打印流 {
System.out
out - public static final PrintStream
默认在我们的黑窗口输出
语言代表人的思维 - 能够促进人的思维
log4J 著名的日志开发包
}
* Object 流 {
把整个 Object 全部写入硬盘被
在 VC 上叫做系列化
存盘点。
挨着排的序列化
再一点一点读出来
Serializable 接口 --- 标记性的接口
transient int k = 15;
相当于这个 k 是透明的。在序列化的时候不给于考虑，读的时候读默认值。
* Serializable 接口
* Externalizable 接口 extends Serializable
}
}
