Java 二次学习-笔记整理

***** ———————————————————————— ****
****   第一，二章 配置, 基础   ****
****  ———————————————————————— ****
* 广告 ：
手中无剑， 心中有剑 {
分析设计 ：
这个东西有 哪些类
类的 属性和方法
类与类之间的关系
-- 然后再实现
}
***** —————————————————— ****
****   第三章 面向对象   ****
****  —————————————————— ****
1) {
定义类 - 对象
定义方法 - 调用
}
2) {
static 知道了内存，你就知道了一切！
局部变量分配在栈内存
成员变量分配在堆内存
static 变量为类对象的共享的变量 在数据区
字符串常量在 数据区

非静态变量 专属于某一个对象
静态方法不再是针对某一个对象进行调用, 所以不能访问非静态成员。
}

3) {
* package / import

package 包名起名字方法 ： 公司域名倒过来！

* 必须保证该类 class 文件位于正确的目录下。
* 必须class文件的最上层包的父目录位于classpath下。
* 执行一个类需要写全包名。

rt.jar
* J2SDK 中主要的包介绍
* java.lang - 包含一些 java 语言的核心类， 如 : String, Math, Integer, System, Thread.
* java,awt  - 包含了构成抽象窗口工具集 (abstract window tookit) 的多个类
* java.applet-包含applet运行所需的一些类
* java.net  - 包含执行与网络相关的操作的类
* java.io   - 包含能提供多种输入/输出功能的类
* java.util - 包含一些实用工具类.

把自己的文件打成 jar文件方法 {
jar -cvf test.jar *.*
}
怎么样把 jar 包 放在classpath下面，别人好能用。 {
设置 classpath 到并包括那个 jar 文件
}

* 类的继承与权限控制 {
分析内存 - 子类对象包含一个父类对象。。。

访问控制 {
* 修饰符      类内部     同一包内      子类     任何地方
* private      Yes
* default      Yes         Yes
* protected    Yes         Yes         Yes
* public       Yes         Yes         Yes         Yes
}
}
* 方法的重写 {
重写方法不能使用比被重写方法更严格的访问权限 -- 其实这和多态有关
}
* super 关键字

* 继承中的构造方法 {
如果调用 super 必须写在构造方法的第一行
如果没调用，系统自动调用 super(), 如果没调，父类中又没写参数为空这个构造方法则出错。
}
* Object 类 {
instanceof 是一个操作符
TestEQ 非常重要！
equals方法 J2SDK 提供的一些类 如 String , Date 重写了Object 的 equals() 方法。
}
* 对象转型 casting {
* 一个基类的引用类型变量可以指向 “其子类的对象”。
* 一个基类的引用不可以访问其子类新增加的成员
* 可以使用 引用 变量 instanceof 类名 来判断该引用型变量所"指向"的对象是否属于该类或该类的子类。
* upcasting / downcasting
内存分析 - 明白了内存你就明白了一切！
可扩展性比较好。。。
}
* 动态绑定, 池绑定, 多态 {
动态绑定的机制 是 实际类型 new 的是！
深一点 -- 是对象内部有一个指针。。。。。。
动态绑定的机制是 ： 实际类型，还是引用类型。是调用实际类型，不是引用类型。
实际地址才会绑定到那个方法上。 方法在  code segment
只有在运行期间(不是在编译期间)，运行出对象来，才能判断调用哪一个。。。。
带来的莫大好处 。。。 是可扩展性达到了非常非常的极致好！
——————————————————————————————————————————————————————————————————————————————————————
这是面向对象核心中的核心。核心中的核心。！ 面试 ： 举例子 并且内存分析之间你小子来吧！
——————————————————————————————————————————————————————————————————————————————————————
多态小总结 ： {
1, 要有继承
2, 要有重写
3, 父类引用指向子类对象
}
"雷电那个游戏"
* 抽象类
* final 关键字
* final 类，方法，变量
例如： public final class String
public final class Math
* 接口 -- 一种特殊的抽象类 {
* 其中的变量全部都是 public static final int id = 1; 避免 C++ 中的问题
方法全部都是抽象方法
* 每个接口暴漏了我们这个对象的一部分方法。

* java.lang - Comparable 我看就像 cmp 一样！(个人认为)
Interface Comparable<T> 可以扩展
* 接口与接口之间也可以相互继承
类与接口只能 是 实现关系

有一个有意思的问题！ 回忆，马老师怎么说的啦！
忠孝两难全！鱼和熊掌不可兼得！
}
* 总结 {
* 内存分析贯穿始终！
}
}
***** —————————————————— ****
****   第四章 异常处理   ****
****  —————————————————— **** {
听说过 IIS 缓冲区溢出漏洞问题吧！
C++ 要交5个月。 java 教 3个月！
C++ 比 java 难 60%

* Java 异常是 Java 提供的用于处理程序中错误的一种机制。
java.lang....Exceptions
写程序有问题要有友好界面
医生开单子 {
1, 鼻腔内感觉异常
2, 体温持续升高
3, 分泌乳白色液体
直接说感冒不就得了么？
}
e.printStackTrace(); 非常好！给程序员读。堆栈信息都打印出来！

java.lang.Throwable { 开车在上山走，
1, Error         山爆发 JVM 出问题。
2, Exception {   你可以处理的 -- 刹车坏啦！修好再走。。。
1, ...
2, RuntimeException  (经常出，不用逮) 压路面上的小石子
}
一个 try 可以跟多个catch
所以 { 一个茶壶可以跟多个茶碗，一个男人可以三妻四妾。}
try {
// 可能抛出异常的语句
语句一；
语句二；
} catch(someEx e) {
语句；
}
catch() {
语句
}
finally {
}
一 ： 打开
二 ： 关闭
finally : 一般进行资源的清除工作。。。！

我处理不了的事情 ： 我交给上一级部门去处理！
当时 catch 到 Ex 的时候，你至少要做出一种处理。要不那是危险的编程习惯！
main() 抛出 就是交给 java 运行时系统啦！ 它会把堆栈信息打出来！

一个图 ： 五个关键字 {
try, catch, finally, throw, throws
}
一点问题 {
先逮大的，后逮小的，报错。
}
使用自定义异常

程序中可以使用 throw - 方法后 throws
如果throw抛出异常之后,方法就结束啦！

注意 ： 重写方法需要抛出与原方法所抛出异常类型一致异常或不抛出异常。

* 总结 ：{
* 一个图
* 五个关键字
* 先逮小的，再逮大的。
* 异常与重写的关系
}
***** —————————————————— ****
****   第五章  -  数组   ****
****  —————————————————— ****
* 四维空间
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
}
}