JAVA SE知识点总结java第一阶段1

知识点总结

1.Java的三大平台：JavaSE（J2SE）、JavaEE、JavaME

2.Java如何配置环境变量：安装---->右键我的电脑---->高级---->环境变量---->path=C:\Program Files\Java\jdk1.7.0\bin

3.Java的三步走：编写源代码（.java）---->编译成字节码(.class)---->运行

4.Java的优势：跨平台以及安全

5.主程序入口：main方法 public static void main(String[]args){程序体}

a) 一个类中只能有一个主程序入口

b) 主程序入口也叫主线程（起始线程）

c) 一般在一个工程中只有一个main

6.变量的三要素：类型名称(变量名)=值;

7.类型可分为2大类：原始数据类型+引用数据类型

8.原始数据类型有8个：boolean、byte、short、int、long、char、double和float

a) boolean 只有两个值：true、false

b) char 存放一个字符，也可以使用ask码表示

c) double和float之间的区别：一个是单精度,一个是双精度，在Java中小数默认为double 例如：float a=9.9;错误需要使用一个标志 float b=9.9f;

9.变量的命名规则：第一位：字母/$/_ 非第一位：字母/$/_/数字，不能使用java中的关键字和保留字

10.变量的命名规范：首字母小写，尽量使用名词

11.变量之间的自动类型转换：

a) 类型之间兼容

b) 由小类型转换到大类型

c) int----->float----->double

12.变量之间的强制类型转换：

a) float---->int int b=(int)9.9f;

b) double---->float float b=(float)9.9d;

c) double---->int int b=(int)9.9d;

d) float、double、int---->String

i. 只需要+“”就好；例如 String b=9+“”；

ii. String.valueOf(待转换内容);

e) String类型转换成int、double、float

i. String---->int Integer.parseInt(待转换内容)

ii. String---->double Double.parseDouble(待转换内容)

iii. String---->float Float.parseFloat(待转换内容)

iv. String---->char charAt(int a);

v. 注意事项：前3中必须保证 String的内容正确，最后一个必须保证a的值在String长度范围内

13.原始数据类型的封装类：

a) int---->Integer

b) double---->Double

c) float---->Float

14.Java中的分支结构

a) if(条件){程序体}

b) if(条件){程序体1}else{程序体2}

c) if(条件){程序体1}else if(条件){程序体2}.....else{程序体n}

d) switch case结构

int a=9;

switch(a){

case 1:

程序体;

Break;

case 2:

程序体;

break;

case 3:

程序体;

break;

...

default:

程序体;

break;

}

e) 注意事项：

i. 条件可以有多个，但是最终的值只能为true或者false

ii. Switch--case结构小括号中只能为整型或者char类型的变量 case后边只能跟整型或者char类型的常量

iii. 多重if结构和switch结构都处理多分支，区别在于switch结构只能处理等值情形，而多重if可以处理区间的情形

iv. switch结构中break不要省略，如果省略，那么程序流程将继续执行下去，例如：

int a =1;

switch(a){

case 1:

System.out.print(“a”);

case 2:

System.out.print(“b”);

case 3:

System.out.print(“c”);

}

如果没有break，那么将输出a,b,c

15.Java 中的运算符

a) 赋值运算符 = 作用是将=右边的值赋予=左边的

b) 算术运算符 + - * / %

c) 比较运算符 > < >= <= == != 通过比较运算符得到的是一个boolean类型的值

d) 逻辑运算符 && || ! 通过逻辑运算符链接的为条件最终将得到一个boolean值

16.Java中的循环结构

a) while结构

i. 语法：while(条件){操作}

ii. 流程图：

iii. 特点：先判断，在执行

b) do-while结构

i. 语法：do{操作}while(条件);

ii. 流程图：

iii. 特点：先执行，在判断

c) for结构

i. 语法：for(初始化;条件;改变（迭代）){操作}

ii. 流程图：同while

iii. 特点：for循环需要知道循环次数

d) 注意事项：

i. 循环结构2要素：操作和条件，拿到类似题时，先找出条件，然后罗列出需要遍历的内容

ii. while和do-while循环时，注意更改条件，防止死循环

iii. for循环;不能省略，其他内容可以省略，但是会形成死循环

iv. 在循环运行过程中，我们可以使用continue和break来终止循环

1. continue结束当次循环，继续执行下次循环

2. break结束循环。

17.数组的定义和使用

a) 概念：一组相同数据类型元素的集合，数组的长度是固定的，当定义好后，不能改变

b) 语法：

i. 声明：数据类型数组名[]; //声明时没有分配空间。

ii. 分配空间：数组名=new 数据类型[长度]; //分配空间就是定义这个数组的容量是多少

iii. 赋值：数组名[下标]=值; //推荐使用循环来赋值

c) 常用实例：

i. int []a;

ii. int []b=new int[10];

iii. int []c={1,2,3,2,5,6};

iv. int []d=new int[]{6,4,3,6,4,1};

v. a=new int[5];

vi. a[3]=6;

d) 注意事项：

i. 数组长度固定，在分配空间时，格子中都会赋予默认值

ii. 数组从0开始，到数组长度-1结束

iii. 数组是存放到堆中的

18.类和对象

a) 类是对象的抽象，而对象是类的具体实例

b) 在一个java文件中只能有一个公开的类(class),我们希望一个.java文件只能有一个class

c) Java中类名必须和文件名相同

d) 类名首字母大写名词

e) 通过new关键字可以产生一个对象

f) 语法：类名对象名=new 类名();

g) 例如有一个A这个类 A a=new A(); 产生了一个a的对象

h) 对象的特征：属性和动作

i. 属性：描述对象

ii. 方法：对象的功能

19.方法

a) 语法：作用域返回类型名字(参数列表){程序体}

b) 名字：首字母小写，动词

c) 返回类型：

i. 无返回类型：void

ii. 有返回类型：那么必须在程序体的最后一行 return,例如：public int getA(){

int i=9;

return i;

}

d) 参数列表：分为形参和实参，其中形参代表定义，而实参是实实在在提供的值

20.常用类:

a) String:这是一个不可变的字符串

i. 如何产生String的对象

1. String a=”值”;

2. String a=new String(“值”);

ii. 获取字符串长度：public int length(); 例如int m=a.length()得到字符串的长度，一个整型

iii. 比较字符串值：public boolean equals(String n);

iv. 通过索引获取字符：public char charAt(int index);

v. 查找字符串中是否含有此字符或字符串,并且返回位置

1. public int indexOf(int ch);

2. public int indexOf(String s);

3. 例如：String m=”这里是中国！”;int a=m.indexOf(‘是’);得到‘是’在“这里是中国”里的位置2。

vi. 查找字符串中某一个区间的字符串是什么：

1. public String substring(int begin);

2. public String substring(int begin,int end);

3. 例如：String m=”这里是中国！”;String k=m.substring(1,3);得到“里是”;

vii. 余下方法查找API即可

b) StringBuffer:

i. 他是一个可变的字符串

ii. StringBuffer sb=new StringBuffer(“值”);

iii. append：追加方法。public StringBuffer append(String a);这个方法不会产生新的内存空间，在大量更改字符串情形下，推荐使用。（类似的2个方式 concat() +）

c) Date:

i. 这是一个日期类

ii. 通过Date d=new Date();得到当前系统时间

iii. Date是在java.util下

d) SimpleDateFormat:

i. 这是一个格式化类

ii. 它隶属于java.text

iii. SimpleDateFormat sdf=new SimpleDateFormat(“格式化类型”);

iv. sdf.format(时间); 按照格式化类型去格式 “时间”

v. yyyy 代表年

vi. MM 代表月

vii. dd 代表天

viii. HH 和 hh 代表时（一个是24小时进制，一个是12小时进制）

ix. mm 代表分钟

x. ss 代表秒

xi. EEE 代表星期

xii. a 代表上下午

xiii. 可以在格式化类型中去书写汉字和符号将他们隔开

第二篇：Java SE知识点记录

开课注意事项/入学致词

使用NetMeeting

开始-运行-conf

重新启动/登陆别人机器

查看自己IP

网上邻居-属性-TCP/IP-属性

命令行-ipconfig

命令提示符简单使用

dir

环境变量设置

我的电脑-属性-高级-环境变量

用户变量-系统变量的区别

Path

用分号隔开，应用程序的路径，执行一个命令时，首先找当前路径，然后找用户Path，最后找系统Path

程序员的设置

详细信息显示文件

不要隐藏文件扩展名

显示所有文件

地址栏显示完整路径

标题栏显示完整路径

显示详细列表

应用到所有文件夹

如何从老师机器上拿文件

ftp://192.168.0.1

JDK安装

JDK JRE的概念 J2SDK

HelloWorld

作业：

阅读avi下面的视频

弄明白classpath的含义

要踏实，要敢于调试错误，要敢于使用软件

第一章

Java的运行过程

java-class-ClassLoader(lazy load)-校验器(verifier)-解释器(interpreter) 核心机制：

JVM (Compile Once, Run Anywhere) 分层的思想

Garbage Collector (GC) 不能精确控制

一般的设计方法是每隔一段时间执行一次

怎么样确定哪块内存是垃圾

没有引用指向的独对象

不能不回收，也不能回收两次

classpath

path是操作系统用的

classpath是JVM用来寻找类用的环境变量

.路径代表当前路径

java class

首先必须定义类

类里面

成员变量

方法

语句

类

××××作业：程序格式的视频

HelloWorld

one public class in a java file

zero or many non-public class in a java file

public class name = file name

Error

Compile Time Error

Runtime Error

对待错误的态度

1：仔细阅读

2：思考来龙去脉

3：动手调试解决

System.out.println 删掉一段修改一段从简单到复杂的调试 4：google

5：BBS

6：teacher

第二章

标识符

见名知义，规则不用记

关键字

常量

变量

局部变量（方法内部声明，包括形参）、成员变量（方法外，类内部） boolean true false

char Unicode编码（utf-16，两个字节一个字符）二进制/十进制/16进制的转换整型 byte short int(默认) long

浮点型 float double(default) 不精确银行一般用BigDecimal

内存分区

code - 存放代码

data - 静态变量字符串常量

stack - 局部变量

heap - new 出来的东西

基础数据类型转换

boolean 不转

默认转换

byte short char 不转，运算时自动转int，可以直接用数赋值，不超范围即可 int - long - float - double

强制转换

前面加(类型名)，小心应用，会导致精度缺失

运算符

+ - * / %

++ -- （在前，在后）

关系运算 > < >= <= == !=

逻辑运算 & | ! ^ && || （逻辑与短路的区别）

位运算

& 两者都是1，结果1

| 有一个为1，结果1

~ 取反

^ 相异为1

>> 右移，左边补充符号位，相当于 /2

<< 左移，右边补零，相当于 *2

>>> 无符号右移，左边补零

赋值 =

扩展 += -= ....

字符串连接 + 两侧数一个为String时，另外一个自动转为String

表达式结果类型优先级（不用记）

三目 x ? y : z

if 语句

只有一句话要执行的时候，可以省略{} 不推荐省略

不要写成if (..) ;

for(..;..;..) 三个表达式都可以省略

while ..

do while () ; 后面有分号

break

continue

计算1! + 2! + ... + 10!

计算1..100前五个可以被3整除的数

计算101..200内的质数

switch语句

小心case穿透的问题，使用break语句

方法调用的过程

1：分配形参的空间分配临时返回值空间（如果有的话） 2：把实参值copy给形参

3：方法开始执行

4：执行完毕后，释放局部变量的空间

内存从main方法开始分析

递归

内存中的分析方法

递归中参数的确定比较重要

Fab数列的问题（递归、非递归）

程序思路的完成

多读

多动手写程序！！！

程序的格式要好

要鲁棒

对输入进行判断

全面考虑各种情况

记录下一步程序的执行地址 4

第三章

面向对象的三个特征

1：封装

2：继承

3：多态

类

某一类事物的共同特征的抽象（静态和动态属性）

对象

某个类的具体实例

拥有自己的静态属性值，所作操作都是针对于自身的属性

面向过程

第一步第二步 ...

面向对象

有哪些类，哪些属性，哪些方法，哪些关系

并非对立于面向过程，是对面向过程的补充和包装

不同问题域中对于同样事物的抽象角度是不一样的

类（对象）之间的关系

依赖

关联

继承（慎用）

聚合（聚集、组合）

实现

多态（polymophism, dynamic bind, late bind, runtime bind)

java中用class定义一个类

成员变量会被默认进行初始化

Java中用到类的时候，需要这个类class文件，JDK所提供的class文件位于%JAVA_HOME%/jre/lib/xxx.jar (rt.jar)

应该经常的写一些测试用的小程序（掌握特定知识点，比方说成员变量默认值）

用new来定一个新的对象

引用的概念（一小块内存指向一大块内存）

类是静态的概念，代码区

对象是new出来的，位于堆内存，类的每个成员变量在不同的对象中都有不同的值（除了静态变量）而方法只有一份，执行的时候才占用内存。

方法是针对于具体的对象进行调用的。

方法里面的成员变量在执行过程中就是该对象的成员变量的值。

因此，不同的对象调用同一个方法执行的过程或结果可能会不一样。

构造方法

和类同名

没有返回值不能写void（很容易出错，要小心）

如果没有则自动添加

如果有就不再自动添加

格式的问题

ClassLoader的运行机制：

1：find class using classpath

2：lazy load

内存的分析（重点）TestBirthdate TestCircle

*作业: 分析TestCircle的执行过程（视频中有讲）

设计所关注的东西：

1：架构

2：模块微架构

3：类之间的设计模式

4：类本身的结构

5：类的属性、类的方法

6：属性的modifier

7：方法名字、参数、返回值

方法如何封装

TestPoint

1:考虑方法名（站在主语角度上去考虑）（第三人称contains）（主动式优于被动式） 2:考虑方法的参数（站在方法角度，方法执行需要事先知道哪些内容）

3:考虑方法的返回值（站在调用者的角度，调完方法之后，我应该得到什么结果，面向对象的思维）

4：可以提供多个方法，但是代码应该只写一份

Point类中

public boolean containedBy(Circle c) {

return c.containts(this);

}

方法的重载（同一个类里面的方法）

1：为什么要有重载舒服

2：方法名字相同参数不一样类型个数

3：不混淆

4：构造方法可以重载

this

要调一个方法（动态）需要一个对象

this一般出现在方法内部

对哪个对象调用这个方法， this指的就是谁

对当前对象的引用，由运行期间决定

this可以当作返回值来运用(Leaf TestThis)

this可以用来区分局部变量和成员变量

static

static成员变量不属于单独的某个对象，被所有对象共享，类名. 或者对象名. 都可以访问

static方法属于整个类，不对某个具体对象调用

static方法不能调用非static变量（非static方法）

main方法必须得是static的

通过类名或引用调用static成员（成员变量或成员方法）

程序执行的过程

java Cat

1: find the Cat.class (classpath)

2: load the Cat.class

3: verify

4: allocate static member

(data segment)

解决类重名

要把类放到包里

第一句话加package xxx.xxx.yyy;

包名一般公司域名倒过来

要想用这个类，写全名

Java com.bjsxt.java145.Cat

ClassLoader找这个类的时候是在classpath路径下面找package对应的目录（不然得打开class，效率太低）

编译好的class文件必须位于和包的层次一样的目录中

顶层包所在路径必须位于classpath里

包名约定俗成的小写

不提倡使用裸体类

set classpath=%classpath%;D:\share\01_J2SE\java\chapter_3\testpackage\

只对当前窗口有效

显示环境变量

echo %classpath%

一个类如果想使用放在包里面的类

1：如果这两个类位于同一个包

直接使用

2：不位于

1：使用类的全名 2：精确引入（推荐）3：引入所有* (不推荐）

编译时找不到另外的类（JDK5.0)

（做试验的时候小心，别的同名的类可能会引起麻烦）

（源文件可能也会引起麻烦，最好把源文件放到非classpath文件夹）(错误的类文件xx.java)

（错误的类文件，xx.class，这个class文件没有位于和package名一致的路径中，或者有这样的的一个class文件没有位于其中，查询你得classpath路径，看看这个class文件有没有位于正确的路径中）

（位于包中的类使用裸体类的时候也会有麻烦）

找不到类或者包

classpath所指定的路径（尽量设置用户的classpath)

要把顶层包所在的路径设置为classpath

jar包当成目录看待

set classpath=%classpath%;xxxx/xxxx/xxx/xx.jar

执行一个类的时候要写全名

同一个包里面的类直接使用

设置classpath的时候一般把"."放在最前面

classpath

编译的时候要找

运行的时候也找

java.lang包中类不需引入，直接使用，rt.jar默认位于classpath中

*作业：写程序验证access modifiers

权限控制：

修饰成员变量

private default/package protected public

修饰class（非inner class)

public default/package两种

你写的程序里面public private protected default

private 50%

public 30-40

protected 5-10

剩下的

extends实现继承机制

java中只允许单继承，但现实世界有多继承的现象存在

C++中允许多继承，但在多个父类对象中存在重名成员变量时非常麻烦

java用interface实现多继承，避免了C++的麻烦

子类对象中包含父类对象（或者父类对象的引用）

子类可以重写父类的方法

访问权限不能更严格

最好去copy

错误最好提前发现（养成良好编程习惯避免错误，格式/Annotation等）

Annotation之一：@Override

重写应该写@Override

super关键字

子类对象中对于父类对象的引用

理解内存模型

继承中的构造方法

子类构造的时候先构造父类

怎么调用 - super + ()

Super调用必须放在第一行

没有调用父类构造则系统自动找

没有找到() 会出错

this()指的是调用自己的另外一个构造方法，这时候不需要调用父类构造方法理解内存模型

***作业: 构造Teacher类，继承Person类

***作业: Student Person的构造过程的视频

Object

查阅JavaDocs文档

学会运用API文档（Application Programming Interface）

碰到新的类要大概浏览一遍

finallize

垃圾回收之前

一般用在JNI（java native interface）的时候，回收其他语言制造的垃圾 equals

提供了一个自己进行"相同逻辑定义"的机会，就是让你重写的

String s = new String("aaa");

这句话中有多少个对象？

hashCode

这个对象内存中的索引值

instanceof

toString()

hashCode

就是让你重写

hashCode

通过hashCode值，可以直接确定对象位置

clone()

deep-copy

网络传输对象的时候

light-copy

getClass

Class类的含义，

站在ClassLoader的角度，每一个Load到内存的代码可以看作一个Class类的对象（内存中生成一个对象用来描述class类）

反射

对象转型

父类引用指向子类对象

只能访问父类中可以访问的成员

可以强制转换为子类引用

instanceof

a instanceof XX 含义：

a所指向的对象是不是XX类的对象，或者是XX子类的对象多态的必要条件(polymophism dynamic binding, late bind, runtime bind) 要有继承

要有重写

要有父类引用指向子类对象

多态大大增加系统的可扩展性(extensibility)

面试多态

举例说明

画图说明

Game/Test.java

面向对象的写法

1：考虑哪些类，哪些对象

2：考虑封装

3：考虑继承

4：考虑多态

*作业：多态的原理（视频，虚函数表）

final

final的变量不能被改变

final的方法不能被重写

final的类不能被继承

abstract method and class

abstract method不需要写实现

含有abstract method的类必须声明为abstact class

Abstract class can’t be instantiated

如果你不想重写父类中的抽象方法，把你自己声明为abstract 抽象类就是用来被继承的

抽象方法就是用来被重写的

interface

为了实现多继承的语法

变量全部都是public static final

方法全都是public abstract的

和实现类之间存在多态性

类可以继承类，接口可以相互继承，类和接口之间写implements Valuable.java

interface和抽象类的区别

i里面的变量是public static final , ac 中什么样的都可以 ac 中的方法可以有实现， i中只能是抽象的

面相对象的设计原则

信息的隐藏和封装

增加而不是修改

慎用继承（父类子类的耦合度太强）

接口最小原则（demeter法则）

高内聚，低耦合

能暴露的最少就暴露最少，两个人的关系越简单越好 11

第四章：异常处理

错误：

编译期间 javac

运行期间 java

Exception

不报异常，但是结果不对，时而对时而不对

解决问题：

1：仔细的读错误信息

2：分析错误的环节

3：System.out.println

Debug

去掉一部分、调试一部分

4：google

bbs

teacher

注意观察错误的名字和行号

观察错误产生的自己所定义的第一个方法，一般来说是错误产生的根源一个图：Throwable - Error Exception - RuntimeException 非Runtime Exception 五个关键字：

try

catch

顺序：先小后大（先子类后父类）

不要用catch父类的方式来替代catch每一个子类（不利于程序的精确控制） finally

throw

throws

如果不想处理方法的异常，throws

方法

printStackTrace

打印出错的堆栈信息

注意观察最根上的错误(自己代码中的) //也可以去阅读Java src // src.zip 调试异常（适用所有语言）

打印

删一段，改一段

自定义异常

从Exception或者从RuntimeException继承

继承和异常(重写)

抛出和原来一样的

不抛异常

抛出异常的子异常

（为社么不能抛更大的异常－多态对其有限制）

同时抛RuntimeException

面试题：请写出几种你经常遇见的异常类的名字，希望你记住的异常

NullPointerException

第五章数组：

数组是引用类型（要了解它的内存模型）

简单排序与二分法搜索（学习分析程序的方法）

作业：记住各种搜索算法的时间复杂度

面试题：

扔二球决定塔高

作业：生小牛的问题

永远的作业：

逻辑思维能力的锻炼（java数据结构与算法）

TestArgs

命令行参数

学会查询API文档

学会将程序写的健壮

作业解答：

对象的排序TestDateSort.java

Comparable接口，帮助我们算法重用

*思考：如果显然比较的策略灵活改变，应该进行什么样的封装生小牛的问题

*作业：

数3退1

数组的全排列

正则表达式的视频

思考题：

1. 数组的全排列

2. 八皇后问题

3. 生小牛的问题

4. 扔二球决定塔高

5. 数3退1

6. 192.38 翻译成大写一百九十二元三角八分

第六章：

遇见新类的时候，要大概的浏览API文档，对于一些方法心存影像

String类，记住一些常用的方法（不可变的字符序列）（内部用数组存储） StringBuffer StringBuilder区别（可变字符序列）（内部用链表存储） StringBuffer线程安全（同步），效率低

StringBuilder不是线程安全（非同步），效率高

写递归：

1：考虑其中的一个过程，制定递归方法

2：递归方法的参数往往是不断的变化

3：找出算法中不断重复的语句封装称为递归方法

基础数据类型包装类

常用方法

Math

递归问题

递归方法

往往带有参数

不断变化

某一个实参会结束递归

Enum

定义一个类型的同时定义这个类型的变量的取值

比原来使用interface的方法更专业

public static final int L = 1;

第七章

一个图：

Collection

Set ：无序不可重复

List ：有序可以重复

Map

成对存储

Collection c = new ArrayList() 父类引用指向子类对象的写法的好处

面向抽象而不是面向具体

自由的替换具体实现而不需要修改其它内容

Hash容器和equals 方法hashCode方法的关系

找某一个容器中的特定对象

首先找hashCode，然后算equals

Iterator接口替代了Enumeration接口

i.remove()是遍历过程中应该调用的方法

23中设计模式中的一种，专门用于容器类，实现统一的遍历

Iterator代替了Enumeration

ArrayList 替代了 Vector (synchronization)

*面试题：Vector ArrayList LinkedList区别和特点

增强的For循环

有缺陷，不建议使用

遍历集合的时候仍然调用的是Iterator

Collections

封装了对于List的常见操作（排序、搜索等）

Arrays

封装了对于数组的常见操作（排序、搜索等）

Comparable接口

要想让自己写的类的对象支持大小的比较（支持排序），必须实现这个接口Comparator

Strategy模式

*作业：用策略模式封装商场打折信息

*模式已经学习了两种Iterator Strategy

自动打包-解包

泛型

第七章总结

1236

一个图

数据结构 array 链表哈希表树两个类

Collections

Arrays

三个知识点

Enhanced For

Generic

Auto-boxing / unboxing 六个接口

Collection

Set

List

Map

Comparable

Comparator（Strategy） Iterator

设计模式之一

第八章：

输入流、输出流

字节流、字符流

节点流、处理流

Reader Writer InputStream OutputStream 抽象类抽象类和接口的区别

*缓存是解决效率问题的首要方案（用空间换时间）树状内容

Hibernate

TestFileReader

try catch finally的运用

字体的显示，字库的作用

缓冲输出流close之前要flush

bufferedReader.readLine方法好用

TestTransForm1.java

编码集合

TestTransForm2.java

阻塞

nio

非阻塞（异步编程模型）

TestDataStream.java

DataStream 和 ByteArrayStream的典型应用（UDP打包）先写进去的先读出来

TestPrintStream1

重定向输出（重新指定System.out的流向）

TestPrintStream3

日志文件（Log4J）

TestObjectIO

transient

Serializable

Externalizable

自己控制序列化(Serialize)的过程

serialVersionUID

面试题：

请写出几个标记性接口的名字和它们的作用

java.io.Serializable

java.lang.Cloneable

java.util.RandomAccess

第八章总结：

输入流、输出流

字节流、字符流

节点流、处理流

InputStream/OutputStream

Reader/Writer

FileInputStream / FileOutputStream

FileReader / FileWriter

BufferedInputStream / BufferedOutputStream

BufferedReader / BufferedWriter

ByteArrayInputStream / ByteArrayOutputStream

InputStreamReader / OutputStreamWriter

DataInputStream / DataOutputStream

PrintStream / PrintWriter

ObjectInputStream / ObjectOutputStream

第九章

进程的概念（静态）

线程的概念（动态）

线程创建和启动的两种方式

Implements runnable //(recommended)

Extends Thread

线程的状态

创建 / 就绪 / 运行 / 阻塞 / 中止

线程控制方法

Isalive

Set get priority

Start

Stop

正确地结束一个线程（run方法正常结束）

Join

Sleep

getName

Yield

sychronized

dead lock

TestDeadLock.java（记住）

live lock

producer consumer

ProducerConsumer.java（记住）

wait notify notifyAll

//为什么是while 而不是if 来检查有没有满

面试题：

class A {

synchronized m1();

m2();

synchronized m3();

}

针对同一个A a对象

1:a.m1执行的过程中，a.m3能不能执行(如果m1在wait，m3就能执行) 2:a.m1执行的过程中，a.m2能不能执行

面试题：

wait和sleep有什么区别

调用wait必须锁定对象

wait的时候释放锁

sleep不需要锁定，如果锁定，睡觉的时候抱着锁

第十章：

TCP/IP四层模型

分层思想

IP地址、子网掩码

TCP/UDP的特点

端口的概念

用于区分不同的网络应用程序（占用不同端口） Socket编程的概念（插座）

典型的TCPSocket程序

BindException

*作业：talkserver talkclient步话机程序

典型的UDP程序

TestUDPServer

TestUDPClient

第十一章

一个图

Component – Container

Window Panel Frame Dialog

Frame Panel类的常用方法

Frame直接new vs extends Frame(Recommended) 布局管理器

FlowLayout – Panel默认

BorderLayout – Frame默认

GridLayout

事件模型基础

事件源对象

事件

事件的处理程序 / 实现了某个事件处理接口的类 Button ActionEvent

TextField常用方法与事件处理

监听器类的书写方法(重点)

传参数

内部类

非常方便的访问包装类的成员变量和方法持有对方引用

Window事件：

匿名类：类比较短，很少改变

*作业:自己用四种方法写出TFMath的程序

graphics和paint方法（典型的图形机理）

repaint – update – paint

MyMouseAdapter.java - 课下自己写出来鼠标事件

Adapter的概念

window事件

匿名类

代码不能太长

代码不能经常的变动

设计模式

Strategy

comparator

Observer(Listener)

ActionListener

Adapter

MouseAdapter 适配器

转换接口

Iterator

Eclipse初步：

IDE (Integrated Development Environment) 22

相关推荐

JAVA SE知识点总结java第一阶段1

知识点总结

第二篇：Java SE知识点记录

专栏推荐