CoreJava总结复习Word格式.docx

CoreJava总结复习Word格式.docx

《CoreJava总结复习Word格式.docx》由会员分享，可在线阅读，更多相关《CoreJava总结复习Word格式.docx（90页珍藏版）》请在冰豆网上搜索。

7.3.4.关系运算符：

instanceof7-17

7.4.静态变量，方法和类7-18

7.5.Singleton模式7-19

7.6.final关键字7-20

7.6.1.final变量不能被改变;

7-20

7.6.2.final方法不能被改写;

7-21

7.6.3.final类不能被继承;

7.7.抽象类7-21

7.8.接口7-22

7.9.Object类7-23

7.10.封装类7-24

7.11.内部类7-25

7.11.1.内部类的分类7-25

7.11.2.成员内部类7-25

7.11.3.局部内部类7-26

7.11.4.静态内部类7-26

7.11.5.匿名内部类7-27

7.12.集合7-28

7.12.1.集合接口类层次7-28

7.12.2.集合类层次7-28

7.12.3.五个最常用的集合类之间的区别和联系7-29

7.12.4.比较7-31

7.13.反射7-32

8.七·

异常8-32

8.1.异常的基本概念8-32

8.2.捕获异常8-32

8.3.处理异常8-33

8.4.捕捉多个异常8-33

8.5.finally声明8-33

8.6.异常调用栈8-33

8.7.异常层次8-33

8.8.一些未检查的异常8-34

8.9.写你自己的异常8-34

8.10.抛出你自己的异常8-34

9.八·

图形用户接口9-35

10.九·

AWT（AbstractWindowToolkit）事件模型10-35

11.十·

TheAWTComponentLibrary11-35

12.十一·

JFC（JavaFoundationClasses）12-35

13.十二·

Applets13-35

14.十三·

线程Thread14-35

14.1.线程原理14-35

14.2.线程实现的两种形式14-35

14.3.线程的生命周期14-36

14.4.Thread的方法14-37

14.5.共享数据的并发处理14-37

14.6.使用互斥锁的注意事项14-38

15.十四·

标准I/O流与文件15-39

15.1.I/O流基础15-39

15.2.流的分类15-39

15.3.对文件的操作15-39

15.4.处理跨平台性15-40

15.5.I/O输入输出15-40

16.十五·

网络编程16-43

16.1.网络基础知识16-43

16.2.TCPSocket16-45

16.2.1.建立TCP服务器端16-45

16.2.2.建立TCP客户端16-45

16.3.建立URL连接16-45

16.4.UDPsocket16-46

16.4.1.建立UDP服务器16-46

16.4.2.建立UDP客户端16-46

1.前言

1.1.JAVA特点

1）简单（Java语法是C++语法的一个“纯净”版本）；

2）可移植性（一次编译到处运行）

3）面向对象

4）分布式（Java把打开套接字连接等繁琐的网络任务变得非常容易）

5）健壮性（Java编译器会检查出很多其他语言在运行时刻才显示出来的错误；

Java采用的指针模型可以消除重写内存和数据崩溃的可能）

6）多线程（多线程编程的简单性是Java成为流行的服务器端开发语言的主要原因之一）

7）安全（用Java可以构建防病毒和防篡改的系统）

9）动态（Java可随意增加新的方法以及实例变量，而客户端却不需做任何的更改）

10）体系结构中立（字节码与计算机体系结构无关，只要存在运行时系统，可在多种处理器上执行）

1.2.运行原理

先编译*.java文件――――>

*.class文件

运行*.class――加载――>

JVM（JAVA虚拟机）

1.3.JAVA目录

JRE―――――――运行环境

SRC――――――－类库

BIN―――――――应用程序

基础知识

2.1.配置环境

LINUX系统（修改环境配置文件）

1打开shell

2vi.bash_profile

3JAVA_HOME=JAVA目录路径

4PATH=$JAVA_HOME/bin:

其他路径

5CLASSPATH=.

6exportJAVA_HOMECLASSPATH

Windows系统

我的电脑属性―――>

环境变量

设置环境变量：

JAVA_HOME=路径

PATH=%PATH%;

c:

\j2sdk1.4.2_05\bin;

CLASSPATH=.;

2.2.Java中基本概念

1）源文件

在最顶层只包括一个public类型的类/接口，文件名与类/接口名同并以.java作为文件后缀。

2）包（package,在源文件中thisidentify只能放在第一行，且最多只能是一行）

一个将类和接口组织在一块的实体，在文件系统中以目录/文件夹型式呈现。

定义，关键字和类型

3.1.注释的三种形式

//单行注释

/*一或多行注释*/

/**文档注释*/

”、“{}”、“”

Java语句以分号分隔；

Java代码块包含在大括号内；

忽略空格。

3.3.标识符

1）用以命名类、方法和变量、以及包；

遵守JAVA的命名规范

类以每个单词都以大写字母开头。

方法和变量第一个字母不大写，其他依旧

2）以字符、“_”或“$”开头；

3）无长度限制。

3.4.数据类型

1）整型

byte1B8位-128到127

short2B16位-2^15到2^15-1

int4B32位-2^31到2^31-1

long8B64位-2^63到2^63-1

2）浮点类型

float4B32位

double8B64位

3）字符类型

char2B16位

4）布尔型

booleanfalse/true

注：

1）char是无符号的16位整数,字面值必须用单引号括起来；

‘a’

2）String是类，非原始数据类型；

3）长整型数字有一个后缀为“L”或“l”，八进制前缀为“0”，十六进制前缀为“0x”；

4）黙认浮点类型为double；

5）float数据类型有一个后缀为“f”或“F”,Double数据类型后可跟后缀“D”或“d“

3.5.命名规则

1）类/接口名首字母大写；

2）方法、变量名第一个字母小写，其余首字母大写；

3）常量名称全部大写；

4）包名全部小写。

表达式和控制流

4.1.变量和作用域

1）局部变量

定义在方法内部，其作用域为所在代码块，也称为临时变量、栈变量。

存在于栈中。

2）实例变量

定义在类内部方法之外，其作用域为整个类。

如未定义初值，系统会自动为其赋黙认值。

存在于堆中

默认数值

类型黙认值

byte0

short0

int0

long0L

float0.0f

double0.0d

char'

\u0000'

空格

booleanfalse

*Allreferencetypesnull

4.2.操作符

System.out.println（3/2）按整型计算得1

1）>

>

前面是零补零，前面是一补一;

2）>

无符号右移;

和>

对于负数不一样

正数：

等于除以X的2次方

负数：

正数的结果＋1

3）&

&

短路与，前面为假，表达式为假，后面不须计算；

4）||短路或，前面为真，表达式为真，后面不计算；

例：

if（a<

3&

（b=a）==0）b赋值

（b=a）==0）b不赋值

4.3.数字类型之间的转换

1）byte——→short——→int——→long

2）char——→int---→float

3）float——→double

4）long---→float

5）long---→double

6）int——→double

1）实箭头表示无信息损失的转换，虚箭头表示转换可能引起损失；

2）int和float同为32位，但float要有几位表示幂的位数，在精度位数上要比int要小，所以有可能会有损失。

long转为double同理；

3）char和short同为16位，但char属无符号数，其范围为0~2^16,short的范围为-2^15~2^15-1,所以char和short不能相互转换；

4）byte、short、char属child型，在计算时会自动转为int型，然后转为更大范围类型（long、short、double）。

4.4.强制类型转换

1）语法：

圆括号中给出要转换的目标类型，随后是待转换的变量名。

例：

doublcx=9.997;

intnx=（int）x;

2）如果试图强制转换的类型超出了目标类型的范围，结果是一个被截取的不同的数值;

3）不能在布尔值和任何数字类型间强制类型转换，如确要转换，可使用条件表达式，例：

b?

1:

0。

4.5.转换的二种类型

1）赋值

doublea=1.0f

int=‘j’;

2）方法调用

doubleconverValue（intvalue）{

returnvalue;

}

3）数值计算转换-9.232e20+1;

4.6.控制流

if（）

if（）….else

if（）…..elseif（）….else

switch（）{

casevariable:

……..

default:

…………

注解：

switch（）内数据类型为child类型byteshortchar自动转换为int

case块中不加break时顺序执行下面的语句。

4.7.循环语句

for（inti=0;

i<

n;

i++）{}

while（）{}

do{}while（）;

-----------加分号

例子：

loop:

i++）{

for（intj=0;

j<

m;

j++）{

if（3==j）{

breakloop;

//---------------loop为标签只能用在循环语句中，循环//嵌套中用于跳到外层循环

}

辨析：

intx,a=6,b=7;

x=a+++b++;

//----------a=7,b=8,x=13

intx=6;

x=~x;

//----------------6的二进制0110取反得11001再转成补码（取反加一）10111＝－7

数组

5.1.声明数组

1）一组相同类型（可以是类）数据的集合;

2）一个数组是一个对象;

3）声明一个数组没有创建一个对象;

4）数组能以下列形式声明：

int[]i或inti[]

Car[]c或Carc[]

*C++中只能Carc[]

*JAVA中推荐用Car[]c;

5.2.创建数组

1）创建基本数据类型数组int[]i=newint[2];

2）创建引用数据类型数组Car[]c=newCar[100];

3）数组创建后有初始值。

数字类型为0布尔类型为false引用类型为null

5.3.初始化数组

1）初始化、创建、和声明分开

int[]i;

i=newint[2];

i[0]=0;

i[1]=1;

2）初始化、创建、和声明在同一时间

int[]i={0,1};

Car[]c={newCar（）,newCar（）};

5.4.多维数组

1）有效

int[][]i1=newint[2][3];

int[][]i2=newint[2][];

i2[0]=newint[2],i2[1]=newint[3];

*C++中int[][]=newint[][3];

有效

2）无效

int[][]i1=newint[][3];

3）数组长度------------数组的属性length

int[]i=newint[5];

intlen=i.length;

//len=5;

Student[][]st=newStudent[4][6];

len=st.length;

//len=4;

len=st[0].length;

//len=6;

请问以下哪段代码哪个可正确执行？

（a,c）

1.achar[]i={'

a'

'

b'

};

i=newchar[]{'

c'

bchar[]i={'

i={'

cchar[]i=newchar[2];

dchar[]i=newchar[2];

5.5.数组拷贝

System.arrayCopy（Object 

src,int 

srcPos,Object 

dest,int 

destPos,int 

length）;

拷贝一个数组到另一个数组。

对象和类

6.1.面向对象与面向过程

面向对象：

EverythingisanObject

为什么面向对象？

符合我们看待客观世界的思维方式

各司其职各尽所能

可重用性

可移植性

可插入性

可扩展性

弱耦合性

面向过程：

先有算法，后有数据结构

先有数据结构，后有算法

定义类

定义属性：

实例变量

定义方法：

声明实现

Overload：

方法名相同，参数表不同

编译器根据参数，选择一个方法，允许自动类型提升，就近匹配原则

定义构造方法：

1.分配空间2.初始化属性3.调用某一个构造方法

ClassNamecn=newClassName（）;

对象变量：

引用、句柄存储的是对象的地址（栈空间）

参数传递：

简单类型参数：

值传递对象类型参数：

地址传递

this:

当前对象

调用本类其他的构造方法，必须放在构造方法的第一行

封装：

该隐藏的隐藏，该公开的公开

属性：

隐藏private

方法：

该公开的公开public

方法声明：

可以公开

方法实现：

不可以公开实现细节的改变对架构的影响最小化

6.2.对象的概念

什么是对象：

EVERYTHINGISOBJECT（万物皆对象）

所有的事物都有两个方面：

1．有什么（属性）：

用来描述对象。

2．能够做什么（方法）：

告诉外界对象有那些功能。

后者以前者为基础。

*一个对象的属性也可以是一个的对象。

这是一种对象的关联（associate）

publicclassStudent{

privateStringname;

---------对象

privateintage;

---------------基本类型

privategender;

publicvoidstudy（）{}---------方法

6.3.成员变量和局部变量

1．实例变量：

定义在类中但在任何方法之外。

（New出来的均有初值）

实例变量中对象默认值为null。

实例变量的作用域在本类中完全有效，当被其他的类调用的时候也可能有效。

2．局部变量：

定义在方法之中的变量。

局部变量要先赋值，再进行运算，而实例变量均已经赋初值。

这是局部变量和实例变量的一大区别。

局部变量不允许范围内定义两个同名变量。

实例变量和局部变量允许命名冲突，但在局部变量的作用域内局部变量优先，访问实例变量是使用this.variableName。

对于引用型类型变量

Carcart=newCar（）;

变量cart存在在栈中，而cart对象实际存在在堆中。

如果没有引用

NewCart（）;

垃圾回收会很快回收这个匿名对象。

简单的垃圾收集器原理

每个对象都包含了一个引用计数器，GarbageCollection运行时检查对象的这个计数器，垃圾收集器会在整个对象列表中移动巡视，一旦它发现其中一个引用计数成为0，就释放它占据的存储空间。

6.4.成员方法

方法定义

1）格式<

modifiers>

<

return_type>

name>

（[argument_list>

]）[throws<

exception>

]{<

block>

}

例如：

publicStringgetName（）{returnname;

}

2）当没有返回值时，返回类型必须被定义为void。

3）构造方法没有返回类型。

4）返回类型必须与方法相邻，其他修饰符号可以调换位置。

参数传递

Java语言总是使用传值调用。

这意味着方法得到的只是所有参数值的拷贝。

因此，方法不能修改传递给它的任何参数变量的内容。

对于对象类型的参数传递的也是该对象的引用值，方法中并不能改变对象变量，但能通过该变量调用对象的方法或修改对象的成员。

***方法与函数的区别，方法的内容是和对象的属性紧密相连的，函数只为了解决一个功能。

6.5.This关键字

1）this是个隐式参数，代表被构造的对象;

publieclassPerson{

privateStringname;

publicvoidsetName（Stringname）{

this.name=name;

-------------this.name为成员变量

2）如果构造器的第一个语句具有形式this（...），那么这个构造器将调用同一类中的其他构造器。

3）在构造器中this（）必须放在方法的第一行。

*Super关键字也是个隐形参数，代表被构造对象的父类。

同样也必须在构造方法的第一行

6.6.访问控制符

权限高

public全部可见

protected本类可见，同包可见，子类可见

default本类可见，同包可见

private本类可见

权限低

6.7.构造方法

构造方法是在生成对象的过程中调用的方法，但构造方法并不能创建对象。

其特点为：

1．构造方法没有返回值。

2．构造方法的方法名与类名相同。

格式为：

publicClassName（）{}

构造方法也可以是其他的限制符――privateprotecteddefaultprivate一般用在singleton模式中。

在一个对象的生成周期中构造方法只用一次，一旦这个对象生成，那么这个构造方法失效。

*接口不能创建实例，因为没有构造方法

可以构造多个构造方法，但多个构造方法的参数表一定不同，参数顺序不同即属于不同的构造方法：

-----------------------构造方法的重载

publicstudent（stringname,inta）{

publicstudent（inta,stringname）{

为两个不同的构造方法。

如果我们未给系统提供一个构造方法，那么系统会自动提供一个为空的构造方法。

如果我们提供了有参的构造方法，那么系统不会再提供无参的构造方法了。

这样当被子类继承时，如果子类构造方法不人为调用父类的有参构造方法就会出现异常。

6.8.数据和方法的隐藏―――封装

publicclassPerson{

----------------------数据的隐藏

publicStringgetName（）{-------------------方法尽量公开

returnname;

publicintgetAge（）{

returnage;

有些方法也需要隐藏起来，比如：

ClassSingleton{

PrivateSingleton（）{

……

PublicstaticSingletongetInstance（）{

…..

If（…..）{

Singleton=newSingleton（）;

}