SXT笔记1
64.
这些是抽象类
InputStream 【Stream以byte（字节）传送】【1Byte】
OutputStream
Reader【Reader/Writer以char（字符）传送】【2Byte】『一个汉字，也是2Byte』
Writer
InputStream:
OutputStream:
对于OutputStream，先flush，再close。
Reader：
Writer：
63.
节点流：
节点流可以从一个特定的数据源（节点）读写数据（如文件、内存）。
处理流：
管子外面在套了一层，外面的这层叫处理流。
处理流是连接在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。
62.
第八章
流： 读写数据的。
分类：
- 按数据流的方向不同可以分为输入流和输出流
- 按处理数据单位不同可以分为字节流和字符流
- 按功能不同可以分为节点流和处理流
61.
auto boxing/unboxing & generic
同时使用：
- Integer之类基本数据类型 直接写数字就成了。而且取出来时 直接用。
- 泛型，取出来时 不用加强制转换了 。
60.
自己总结：
图、类java.util.Collections 、三个知识点（for、Generic、Auto-boxing/unboxing）、六个接口：
Collection、Set、List、Map接口里的方法（在实现类里都有实现）。
Iterator接口：
- Collection所有的实现类里面，有个iterator方法。
- 通过这个方法，返回一个实现了Iterator接口的对象。
- 通过这个对象，可以调用Iterator接口里面的方法，就可以对Collection里面的对象进行遍历。
- 『方法内具体是如何实现，及这个返回的对象具体是什么不用管。只要知道 实现了Iterator接口的对象，那就可以当作Iterator对象来使用【此处多态】』
java.lang.Comparable接口：
- List对象，要排序(调用java.util.Collections.sort())，那么，对象中 元素的类 得实现Comparable接口。（重写compareTo方法）
- 记得，是用List的实现类来存储对象的时候，才有『调用Collections.sort() & 元素的类实现Comparable接口』。Set啦，貌似不能调用Collections的方法。
- 例如：
- List l1 = new LinkedList();
l1.add(new Name("Tom", "Lee"));
l1.add(new Name("Jack", "M"));
l1.add(new Name("Steven", "X"));
l1.add(new Name("Lucy", "M"));
System.out.println(l1);
Collections.sort(l1);
System.out.println(l1); - 那么，Name这个类必须实现Comparable [java.lang Interface Comparable ]接口。
59.
泛型(Generic)：
/sxt/Container/BasicGeneric.java
用到集合（Collection Map）的时候，尽量使用泛型。
什么时候可以用？
- API文档中，类后面跟着<>的就能用。没有的不要用。
起因：
- jdk1.4以前类型不明确
- 装入集合的类型都被当作Object对待，从而失去自己的实际类型。
- 从集合中取出时往往需要转型，效率低，容易产生错误。
解决办法：
- 在定义集合的时候同时定义集合中对象的类型
- 在定义Collection的时候指定
- 同时也在循环的时候用Iterator指定
好处：
- 增强程序的可读性和稳定性
- 装的时候是String，拿出来还是String，不用强制转换了。
58.
Auto-boxing/unboxing：
Map接口存对象的时候，key value必须都是对象。太麻烦。
简单的方法jdk1.5之后：
- Map m1 = new HashMap();
Map m2 = new TreeMap();
m1.put("one", 1);//把 1 自动打包成对象
m1.put("two", 2);
m1.put("three", 3);
m2.put("A", 1);
m2.put("B", 2);
可以这样写，jdk1.5帮着Auto-boxing/unboxing，很方便。
- 自动打包成对象
- 自动解包成基本类型
57.
Map接口：
存储（key + value）一对儿。
实现类：HashMap和TreeMap。（二叉树，顶层元素只有两个子元素）
key不能重复（指equals，但这里比较的是HashCode，equals太慢）（所以重写equals方法，记得一块重写hashCode方法）
56.
如何选择数据结构：
ArrayList 读 快 改 慢 (底层是数组实现的)
LinkedList 改 快 读 慢 (链表，指针连在一起)
HashSet 两者之间
Hashtable已经很少用了。效率低。
55.
List接口：有序，可重复
【Eset(int index, E element) 虽然是set方法，但是它有返回值。其返回值是 被替换的那个元素。】
【逆序，LinkedList效率更高。LinkedList把指针调个头就行了。ArrayList需要copy。】
java.util.Collections封装了常用的List的方法
要用Collections.sort();来给 使用LinkedList类对象存储的元素 排序，需要满足： 元素的类实现了java.lang.Comparable接口。(implements+重写)
Comparable接口中只有一个方法 int compareTo(T o)
- 返回 0 表示 this == obj
- 返回正数 表示 this > obj
- 返回负数 表示 this < obj
54.
Set接口：
实现Set接口的类，其中的存放的 数据对象 没有顺序且不可以重复。
sr.retainAll(s2);//交集//sr变成 sr和s2的交集
su.addAll(s2); //合集//合集后su变成 su跟s2的合集
53.
增强的for循环。【方便遍历Array 或 Collection 】【语法简便】
- 数组：不能方便的访问下标值
- 集合：与使用Iterator相比，不能方便的删除集合中的元素。 【内部也是调用Iterator】
除了简单遍历并读出其中的内容外，不建议使用增强for循环。
52.
- ArrayList底层是数组（从名字上看出来，是拿array来存东西）
- LinkedList底层链表来实现的（）
两种类的底层遍历方法是不同的（ArrayList可以挨排跳着找，LinkedList得一个个的挨着找），所以Collection接口里 无法写出一个 统一的遍历方法 来。
- 所以就有了Iterator接口。（以遍历）
- 每一种容器（ArrayList、LinkedList、各种Set）都有自己的实现方法。（实现方法不用管，返回值都是(统一的) 实现了Iterator接口的对象{父类引用指向子类对象}。）（这个对象是什么也不用管，反正用它可以调用Iterator的三个方法，可以遍历了。）
- 遍历时，删除元素只能用Iterator接口提供的remove方法。不能调用Collection的remove方法。【在Iterator循环内部执行了锁定】
52.
Iterator接口（统一的遍历Collection里面所有元素的方法）：
所有实现了Collection接口的容器类 都有一个iterator方法 用以返回一个 实现了Iterator接口的对象。
【多态】【继承(Iterator接口)、重写(实现接口，当然要重写)、父类引用指向子类对象(返回的对象是 当作Iterator接口 来用的)】
Iterator对象称作 迭代器，用以方便的实现对容器内元素的 遍历 操作。
Iterator接口定义了如下方法：
- boolean hasNext(); //判断游标右边是否有元素。
- Object next(); //返回游标右边的元素，并将游标移动到下一个位置。(1.4是Object)【任何东西都能是Object，所有返回值是Object。父类引用指向子类对象】
- void remove(); //删除游标左边的元素，在执行完next之后，该操作只能执行一次。
这三个方法，遍历（从容器里，挨个拿出来）【Iterator就是那个游标，只在第一个元素的左边】
51.
equals：
容器类对象在调用remove、contains等方法时需要比较对象是否相等，一般会调用equals方法。
但是，当这个对象用在Map接口里头 作为 “键”(类似 字典的索引) 使用的时候，会调用hashCode方法。（效率更高）(而不是调对象？)
所以，要是重写equals方法时，一定记得重写hashCode方法。
【两个对象equals的话，他们的hashCode相等。】
通过hashCode可以找到它在内存里的地址(不是绝对的物理地址)。非常适合做索引。
往Map里存东西的时候，是key+value的，可以用hashCode做索引。
Object类(所有对象的父类)的equals方法是怎么实现的？
就是比较两个对象是否一样(地址是否一样)。(就是 “==”)
50.
Collection接口：
继承了Collection接口，实现其中所有的方法。
- contains equals某个内部元素，就叫包含。
- containsALL(Collection c) 是不是包含另外一个集合里的所有元素。
- add(Object element)
- addALL(Collection c) 添加 集合。
- remove(Object element)
- removeALL(Collection c) 删除。
- retainALL(Collection c) 求交集。
- Object[] toArray(); 把里面装的对象 转换成数组。
Collection c = new ArrayList(); //可以放入不同类型的对象。 父类引用指向子类对象。 不满意ArrayList时，可以转换成其他。就方便了。
System.out.println(c); //内部的实现： 调用c的toString方法，打印出"[" "]" 。 然后依次调用c内存储的对象的toString方法。
/**
improt java.util.*;
public class Test {
public static void main(String[] args) {
Collection c = new ArrayList();//可以放入不同类型的对象
c.add("Hello");
c.add(Name("f1","l1"));
c.add(new Integer(100));
System.out.println(c.size());
System.out.println(c);//内部的实现： 调用c的toString方法，打印出"[" "]" 。 然后依次调用c内存储的对象的toString方法。
}
}
**/
49.
容器的概念：
装其他各种各样对象的东西。(容器，放对象)
数组是容器 。
Collection函数库跟数组最大的不同在于，数组有容量大小的限制，而Collection函数库没有这样的限制
J2SDK提供的容器API位于java.util包内。
容器API类图如下：
Collection接口 【一个一个的装】 定义了存取一组对象的方法，其子接口Set和List分别定义了存储方式。
- Set中的数据对象 没有顺序且不可以重复。
- List中的数据对象 有顺序且可以重复。【重复：两个对象相互 equals 】
Map接口 【一对一对的装】 定义了存储 “键(key) —— 值(value) 映射对”的方法。（key + value）（key = value）『key，value。重复时以第二次写的为准，也就是说，重新给key赋值了』
【实际上是用容器接口的实现类来存东西的】
48.
第七章：容器【重要】
1136
一个图，一个类，三个知识点，六个接口。
- 容器的概念
- 容器API
- Collection接口
- Iterator接口
- 增强的for循环
- Set接口
- List接口 和 Comparable接口
- Collections类
- Map接口
- 自动打包/解包
- 泛型
47.
第六章：常见类：
- 基础类型包装类
- Math 【用的不多，常用的是random方法】
- File 【代表的是文件名或者目录名，是个名】【递归】
- 枚举类型
养成查找API文档的习惯。【API】---【金庸小说】
46.
枚举类型。（作为一个类 封装的）
使用enum关键字就可以定义java.lang.Enum的类型，名字叫MyColor(像是定义了一个类，而不是定义了一个变量)，拿着这个类型MyColor再去定义变量。
public enum MyColor { red, green, blue};
拿这种类型来定义新变量的话，只能取这三个值中之一。(这三个值好比是类里面的静态变量)
MyColor m = MyColor.red;
/**
*使用int关键字 就可以定义int型的数
*使用 类 就可以定义 引用型
**/
45.
java.lang.Math类(用的较少)(写游戏？)（图形学？）（web app时基本用不上）
java.io.File类 代表(路径名或者文件名) new出来的File对象是 内存里的，不是磁盘上的。
44.
基本数据类型包装类
1.基本数据类型是分配在栈空间，如果想放到堆空间的话，用包装类包装一下；
2.【int】Integer.intValue()返回这个包装类的作为int型的值
【long】Integer.longValue()返回这个包装类的作为long型的值
【static int】Integer.parseInteger(String s, <int radix>)把字符串转换成 int型的数
【static Integer】Integer.valueOf(String s, <int radix>)转换成int型包装类
【static String】Integer.toBinaryString(int i)返回i的二进制表示，以字符串的形式
【static String】 toHexString(int i)十六进制
【static String】 toOctalString(int i)八进制
43.
StringBuffer类
1.内存中可变大小。
2.想删其中某个字符，直接删，内存区域大小可以改变。【如果是String类型的话，方法是：把要删的字符，之前之后的都截出来，然后再拼接。】
3.append方法、insert方法、delete方法
4.其他的基本同String类。
42.
public static String valueOf(Object obj) {}
这个方法是传入一个object对象，调用这个对象的toString方法，返回之。
传入的是任何对象，返回的是任何对象的toString方法的返回值。【『继承』任何对象都是Object类的子类。以父之名访问，『父类引用指向子类对象』。子类重写了Object父类的toString方法。】【因为三个条件存在，故 多态。而在执行时，动态绑定，所以返回的是所传入对象的toString】
41.
常见类：
java.lang.String代表不可变的字符串。『内存中不可改变』『想改变，copy这块内存到另一块区域』
java.lang.StringBuffer代表可变的字符串。缓冲区『想改变时，在内存中可变』
String(byte[] bytes)【GB2312的编码转换成GBK的编码】
40.
数组的copy：
循环法； System.arraycopy(Object source, int srcPosition, Object destination, int destinationPosition, int length)；
39.
二维数组：数组的数组
四维数组：3D图形转换
38.
基础数据类型的包装类。
用这个包装类包装基础数据类型的数据，就可以放到堆空间里了。
用这个包装类也可以把String字符串转换成(这个包装类)相应的数据类型。
37.
异常处理：（程序执行期，出现的错误）
- 一个图『throwable--> error + exception（runtime exception & checked exception）』；
- error是处理不了。runtime exception是经常遇见的，可以不用catch，及时处理掉。除了runtime exception的其他exception都需要处理。
- 五个关键字（try、catch、throws、throw、finally）
- 先逮小的，再逮大的。
-
子类重写方法，需要抛出与原方法抛出的类型一致或不抛出异常。（或者抛出的虽然多，但是原方法抛出异常的子类）
A。观察名字和行号最重要。程序是调出来的。
B。try {可能出异常的方法} catch (异常对象) {处理的方法}
C。finally通常用于进行资源的清除工作，如关闭打开的文件，删除临时文件
D。throws异常的时候，如果抛出了两个，而且两个是父子类关系，那最好也都写上。(别人知道你抛两种异常，catch住了会做不同的处理)【良好的编程习惯】
E。main方法也可以抛异常。【相当坏的习惯】(简单的写法throws Exception。)（main方法抛出的异常，交给了Java运行时系统了，Java 运行时会把异常的堆栈信息打印出来）
36.
第三章总结：
35.
接口(一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现)
接口和实现类之间也存在多态性。【继承、重写、父类声明指向子类对象-->多态】
()里的可以不写。默认是()这样的。
(public static final) int a;
(public abstract) method() {}
implements
接口：内存里，只能看到这个对象实例的部分方法；
34.
抽象类：abstract修饰的类【不能new实例对象】【抽象类必须被继承，抽象方法必须重写(子类不重写时，也须声明成抽象类。方法为抽象方法。重写的任务可以交给子类的子类)】
抽象方法：abstract修饰的方法【含有抽象方法的类必须是抽象类】
【抽象方法只需声明，不需实现。】
33.
多态（dynamic binding）（late binding）
【 执行期间 】【扩展性达到极致。动态绑定，指针在执行时】
1.动态绑定是指“在执行期间(动起来的时候)”判断所引用对象的实际类型，根据其实际的类型调用相应的方法。
2.多态存在的三个必要条件：继承、重写、父类引用指向子类对象。【满足这三个条件，当你调父类中被重写的方法时，实际中new的是哪个子类对象，就调用哪个子类对象的方法】
（方法----->code segment）
32.
对象转型(casting)
1.父类的引用(或者接口的引用)可以"指向"其子类对象；【方法中要求传父类对象，实际传的时候传的是子类对象。然后在方法中强制转换】【实现的不错的扩展性】
2.一个父类的引用不可以访问其子类对象新增加的成员(属性和方法).
3.可以使用 引用变量 instanceof 类名 来判断 该引用型变量 所“指向”的对象实例 是否属于该类或该类的子类。【看对象实例是什么】
4.『1.』称作 向上转型(upcasting)，反之称为向下转型(downcasting).
31.
final
final的变量不可改变它的值。
final的方法不可被重写。
final的类不能被继承。
30.
classpath里面，"."一定写到前面。
Java再去找class时，是按照classpath里面的路径去找的。[用了eclipse就没有这个问题了]
29.
hashcode
根据哈希编码可以找到 内存中的 某个对象。
28.
toString()
推荐重写之。
== 比较的是 【地址】
equals() 比较 【x.equals(y);当x和y是同一个对象的引用用时返回true】
可根据需要重写equals方法。
27.
所有的类都是继承自Object类。
反射机制
26.
继承中的构造方法：
A。子类的构造的过程中必须调用其父类的构造方法(无论如何，都会先调一次父类的构造方法，不论写不写super，不写的话系统会自动给加上，写的话可以选择调用父类的哪个constructor)
B。子类可以在自己的构造方法中使用super(argument_list)调用其父类的构造方法
a。用this调用自己的constructor
b。this，super必须写在第一行
C。无论如何，都会先调一次父类的构造方法，不论写不写super。不写的话系统会自动给加上super()，即默认调用父类无参的constructor。写的话可以选择调用父类的哪个constructor不写super，。【不写constructor也一样】easy
D。无论如何，都会先调一次父类的构造方法，不论写不写super。不写super，父类中有没有无参的constructor，编译出错(因为默认调用父类无参的constructor呀，现在没有，当然出错)。【不写constructor也一样】easy
25.
super:
用来引用父类的成分。
24.
要重写方法时要去copy(避免重写override失败)（难查）
23.
继承和权限：
extends以继承
继承后，子类就拥有了父类所有的方法和变量（不管你用不用）
（private也继承了，只是拥有了，但是没有使用权）
（(default)同一个包里）
（protected扩展到子类，子类在不同的包里也行）
（public 其他包里的类都可以访问）
权限：
22.
A。j2sdk主要包(jdk):
java.lang包含Java语言的核心类如String,System etc
java.awt（abstract window toolkits）的多个类
java.applet【较少用了现在】
java.net包含执行与网络相关的操作的类
java.io能提供多种输入/输出功能的类
java.util 一些实用工具，如定义系统特性、使用与日期日历相关的函数
B。在使用时除了java.lang，别的都要引入。
C。打成jar包。在顶层包的父目录，jar -cvf *.jar *.*
D。怎么让别人用jar包。设置到classpath里面就行了，如D:\java\test.jar;
21.
package:
A.如果要把一个类放在包里面，请在第一句话写package。编译出来的类必须位于正确的目录下面。（和包的层次完全一致）
B.如果想要在另外一个类里面用刚才包里面的类，必须把包里面类的名字写全。(package)【简单的方法就是import了，import这个类。或者*,注意*不包括子目录哦】【该类源代码可能影响，找到 类】
C.必须让class文件的最上层包的父目录位于classpath下，然后都能用了。或者打成jar包，把jar包放到classpath里。【从父目录开始找最顶层的包，然后找找找】
D.执行一个类，也得写全包名。【写到classpath里】【用了eclipse就方便了】
E.不同的项目设置不同的classpath。【eclipse】
20.
类名.变量 : 这个变量一定是静态的。非静态的一定要先new一个对象出来。
System.out（out一定是静态的，不解释）
没有指针，Java叫引用。
19.
static:
A.【static，字符串常量，都是分配在data segment区域中。】
B.用static声明的成员变量为 静态成员变量。对于该类的所有对象来说，static成员变量只有一份，在data segment里。(所有类的成员共享)不new对象，也有一份在data segment里。非静态的，每new一个对象，单独一份。
C.static变量的访问方法：对象引用/类名+“.”+变量名。（只有一份哦，访问的是同一块内存）(改了，别的对象实例再用时会影响哦)
18.
this:是个引用，指向自身对象。
就近声明的原则，确定变量是哪个？
this一般出现在方法里，当这个方法还没有被调用的时候，this指的是谁并不知道。
实际当中，当new一个方法出来，this指的就是当前这个方法。
对哪个对象调用这个方法，this指的就是谁(那个对象)。
17.
方法重载(Overload)：
方法名相同(参数类型不同或者个数不同)
16.
内存解析
方法调用时，值传递(Java中只有值传递)
return后面，是一个公式时，公式计算完成，其值也会在内存中分配一块空间。不过等到此行命令执行完成，把值返回后也就消失了。
15.
引用类型：除了基本数据类型之外的（四类八种之外的）。。。引用类型占用两块内存。。。字符串(特殊的类)也是。只不过可以像数据类型那样使用罢了。【要new】
基本数据类型：四类八种
14.
分析时：找名词。
13.面向对象：
设计思想：
Step1.问题中有哪些个类、哪些个对象；
Step2.这些类和对象，分别应该具有哪些属性和方法；
Step3.类和类之间应该有什么关系。
合适的方法出现在合适的类里面
类之间的几种关系：
比较弱的关系：关联
继承关系：xxx是一种xxx；
聚合关系： 聚集(子类之间关系比较松散)
组合(子类之间关系密不可分)
实现关系：接口
多态(与实现关系相关)
12.
复习总结第二章
11.
形参：事先定义好的参数类型
实参：实际传递的数值；
10.
if 后面千万别按个 ; ，出错，还查不出来。
9.
do{} while;
8.
x?y:z
先算x，若true，取y。
7.
表达式：最后能算出一个值来的东西；其类型是 最后算出来的数据类型。
6.
当进行打印的时候，无论任何类型，都自动转换成字符串进行打印。连接打印时也是。
System.out.println("String" + c);
5.
实数常量(如1.2)，默认为double型；
整数常量(如123)，默认为int型；
(运算时，二话不说，先转换。小到大)
int型强制转换到byte，可以转。砍掉3个字节。
double型却不可强制转float，因为它们在计算机内部是模拟表示的，砍不掉。
float可以强制转换成long型，把小数部分砍掉。
4.
float 7位精度；double 15位精度；
3.
Java对于浮点数的literal默认double型。声明float型常量，后面必须加f。如float f = 12.3f;
Java对于整数的literal默认为int型。声明long型常量，后面必须加L 。如long = 88888888888L; //必须加，否则会出错。
2.
8位(01010101)=1字节
1.
布尔Boolean型，只有俩值；true false(不能用非0和0)
字符' 字符串"
出了大括号，就没人认识在大括号里声明的变量了
0.
++(写右边的话，先做其他运算，再自增)
浙公网安备 33010602011771号