Java学习重点Word文档格式.docx

Java学习重点Word文档格式.docx

《Java学习重点Word文档格式.docx》由会员分享，可在线阅读，更多相关《Java学习重点Word文档格式.docx（35页珍藏版）》请在冰豆网上搜索。

java虚拟机（JVM）

编译器解释器

应用程序层

Java应用程序

Java平台层

Java虚拟机

操作系统层

UNIX

WINDOWS

RTOS

硬件层

SPARC

X86

MIPSPPC

二、面向对象的特征

面向对象的三个原则

封装性

封装的基本单元是类（class），类是一个抽象的逻辑结构，而类的对象是一个真实的物理实体；

类的目的是封装复杂性，在类内部存在隐藏实现复杂性机制；

封装（encapsulation）的两个好处：

模块化：

可以独立于其他对象的源代码进行编写和维护，可以很容易的将对象在系统中传递；

隐藏信息：

其他对象可以通过本对象的一个公共接口进行通信而不影响其他对象；

继承性

继承是一个对象获得另一个对象的属性的过程，继承机制是一个对象成为一个更具通用类的一个特定实例成为可能，避免了代码的重复编写；

多态性

（重载overload，方法名相同、参数的个数不同、参数的类型不同、返回的类型不同和覆盖override）；

多态性就是“一种接口，多种方法”，可以为一组相关的动作设计一个通用的接口，其实类的函数的重载就是一种多态的体现；

引入抽象编程的思想；

类的封装就是一种抽象思想

三、Java关键字

1、类访问修饰符

说明

类的修饰符只有public和default两个；

public修饰类时表示任何包的其它类都可以访问该类；

访问修饰符为default时只有在同一个包里的类才能访问它，其他包里的都不行；

类的构造函数（构造器）不能用final、abstract、synchronized、native、static等关键字进行修饰；

2、成员访问修饰符（public、protected、default、private）

规则说明

java的成员访问修饰符有4种：

public、private、protected、default

publicstatic==staticpublic；

类的成员访问修饰符的详细描述如下：

（√表示允许访问，×

表示不能访问）

visibility

public

protected

default

private

访问同一个类

√

访问同一个package中不同的类

×

访问在不同package中的父类（superclass）

访问不同的package中不同的类

综合上表，访问修饰符的访问权限为：

public>

protected>

default>

3、final关键字

修饰范围

类

final类不能被继承，final类的性能会有所提升如：

publicfinalclassA{…}

publicclassBextendsA{…}//错误，A被final类不能作为B的基类

方法

final成员不能被重写（overriding）；

类的成员变量

final变量不能被修改值，如：

publicfinalclassA{

staticfinalinta=10；

a=11；

//错误，不能被修改

staticfinalintb;

//此处是非法的，必须是如staticfinalintb=9；

}

方法中的变量

可以在声明时不赋值，但是在使用之前必须赋值，一旦赋值就不能被修改；

publicstaticvoidmethod（）{

Finalinta;

System.out.println（a）;

//错误，必须改为：

a=10；

final修饰的对象表示它所修饰的对象所分配的内存地址不可变；

final和abstract不能同时使用，如publicfinalabstractclassA{}是不允许的；

因为final是使类A不能被继承而abstract是要类A在其子类中实现它的方法；

4、abstract关键字

1、被修饰的类为抽象类，不能被实例化（生成对象）只能作为其他类的基类（父类）

2、abstract不能修饰类的构造函数（构造器）；

3、类下面的方法可以不都被修饰为abstract，没有被修饰的方法则需要实现该方法；

类的方法

修饰方法时，它的类也必须被修饰为abstract

其它

abstract不能与final同时使用；

5、static关键字

如果一个类的成员被声明为static，则该成员实际上是一个全局变量，static关键字的使用规则如下：

在java中只有接口、最外层的类和staticInnerClass可以定义static变量或方法；

Static变量和方法属于它的类，它的类的所有对象都可以访问到它；

但是任何一个类的对象对static变量进行修改都直接影响到所有对象；

它们只能访问static修饰的类的成员变量和方法

它们不能以任何方式引用this或super；

6、override关键字

7、synchronized关键字

synchronized只能用在方法的声明的前面，而变量不能用该关键字；

四、变量（variablesstatement）

1、变量声明

变量名称的命名规则：

（1）java只允许英文字母以及”$”以及”_”两个非英文字母作为变量或类名的首字母；

（2）变量以小写字母开头，以后的每个单词首字母大写；

其它的普通变量除了第一个单词首字母小写外其他的都大写；

（3）类名的每个单词的首字母都大写；

（4）java约定_只用在常量声明的单词之间分隔单词;

规则1

int99year=99是非法的，而int_99year=99是允许的

规则2

intmyInt=99;

规则3

ClassMyClass{}

规则4

intMAX_VALUE=99

当变量声明为null时表示该变量没有初始化即没有分配内存空间；

八进制数的声明

intfive=05；

intnine=011；

十六进制的声明

inta=0x9；

intfifteen=0xF；

intsixteen=0x10；

在java中除了接口、外部类和staticInnerClass可以定义static变量或方法；

2、变量作用范围

变量声明的位置直接决定了变量的作用范围，它共有4种作用范围：

声明范围

它是一个类的成员（static修饰，所有类的变量即是所有对象公有的一个变量，它的更改将影响到所有的类的对象）或者一个对象的成员（非静态变量,属于类的对象的变量），它在类内，但是是在任何方法和构造函数之外；

局部变量

主要是在类的方法或者一个代码块中，只在所在的方法或代码块中起作用；

方法的参数

是方法或者构造器中的正式自变量，用于向方法或者构造器传递值，作用范围是它所在方法或则构造器内；

异常处理器参数

与参数类似，它是异常处理器的自变量;

五、接口（Interface）

接口可以继承接口，用关键字extends（扩充、继承）

普通类可以实现多个接口，用关键字implements（实现），用“，”分隔

接口中的定义中不能加private和protected，其default值是public；

接口中可以定义静态的变量，格式为：

publicstaticfinaltypevariableName;

实现类必须实现接口中的所有方法；

六、构造函数（构造器，constructor）

构造函数的作用：

在生成类的对象时，为对象分配一个（封闭）的内存空间；

构造函数必须与类名一致；

构造函数可以重载；

不管父类有无构造器，子类在实例化时都会调用父类的构造器，所以当父类中声明了带参数的构造器时，子类必须在构造器的第一行指定调用父类的哪个构造器；

构造器不返回任何类型，可以是个空方法，也可以给类的变量赋值；

在类的继承中，子类会默认调用父类中的构造器，可能出现的情况有：

publicclassA{

publicA（inti）{

…

可以将类B中加个构造器：

publicclassBextendsA{

publicB（inti）{super（i）}

publicstaticvoidmain（String[]args）{

Bb=newB

（1）;

或者在A类中加个没有参数和方法体的构造函数：

publicA（）{}

publicA（inti）{…}

Bb=newB（）;

6

例子：

privateinta；

publicA（）{}//默认的构造函数可以不写

a=i；

}//一旦建立了自己的构造函数，则java默认构造函数则将不再使用了。

七、程序控制语句

1、循环控制语句

Java中共有while、dowhile、for三种循环语句。

类型

while

inta=0,b=10;

while（a<

b）{

a++//当a等于b时即跳出循环；

dowhile

规则：

先执行后判断，至少要执行一次，如：

do{

}while（a<

b）；

for

规则根据条件执行；

for（inta=0;

a<

10;

i++）{

…//当a=10时自动跳出循环；

上个for循环语句等价于：

）{

…//当a=10时自动跳出循环；

a++;

}甚至可以：

inta=0;

for（;

2、switch等跳转语句

Java中共有break、continue、return三种跳转语句，其中：

跳转类型

break

①switch语句中的跳转；

②用来跳出循环语句；

for（inti=0;

i<

100;

if（i==50&

&

j==49）

break;

//直接跳出循环语句

else

System.out.println（i）;

③可以作为一种的先进的goto语句来使用；

continue

continue;

//直接跳转到控制语句控制体中i++

}在循环体语句中可以用continue语句使程序只执行满足循环体条件的表达式；

return

直接结束并跳出方法，或者返回方法定义的数据类型；

3、New运算符

理解new运算符是在运行期间为对象分配内存的是很重要的。

请记住下面的话：

当一个对象引用赋值给另一个对象引用时，仅仅只是对引用的一个拷贝（即只是将2个对象都指向同一片内存。

）

如下面的代码：

publicclassBox{

publicintlength;

publicintheight;

publicBox（intl,inth）{

this.length=l;

this.height=h;

publicclassB{

Boxb1=newBox（10,20）；

Boxb2=b1；

System.out.println（b1.length+”-“+b1.height）;

System.out.println（b2.length+”-“+b2.height）;

b1.length=20;

b1.height=30;

System.out.println（b1.length+”-“+b1.height）;

结果：

10-20

10-20

20-30

这是因为：

在上面的代码中，先是为b1分配了内存空间，然后在b2=b1时，将b2的指针也指向了b1所指向的内存空间，所以无论b1怎么变，b2都跟b1完全一致；

4、++操作符

分类

优先级

在同一个运算表达式中，A++的优先级高于++A

A++

B=A++表示B=A；

A=A+1；

++A

B=++A表示B=A=A+1；

八、内部类（InnerClass）

定义：

innerclass是class的另一种类的成员；

内部类可以实现（implement）接口或者继承（extends）其它的类；

静态内部类（又叫嵌套类）

类似与类中的static成员方法，在调用该类时不需要声明，可以直接调用；

成员内部类

类似与类中的非static成员方法，在调用该类时需要实例化它的外部类，然后通过该实例在实例化该内部类

本地内部类（localInnerClass）

类似于类的方法中的局部变量；

匿名类（AnonymousInnerClass）

一种特殊的localInnerClass；

总之，这4种内部类类似于普通类中的静态成员、非静态成员、方法中的局部变量

1、静态内部类（staticInnerClass）

Staticinnerclass可以访问它的外部类的所有的静态成员变量和方法；

而它的外部类可以访问它的所有成员和方法（无论用什么修饰符）；

Staticinnerclass访问它的外部类的非static变量时只能通过它的外部类的对象实例去访问；

Staticinnerclass中只能有静态成员变量和方法；

Staticinnerclass的名字不能跟它的外部类相同；

publicclassMyOuter{

publicstaticintins;

publicintmyins;

publicstaticclassMyInner{

inti=ins;

intx=myins;

//不能这样访问外部类的非静态成员，必须通过它的实例来访问；

inty=newMyOuter（）.myins;

//这样访问myins是正确的；

publicvoidfood（）{…}

在编译之后不仅要生成一个MyOuter.class还将生成一个MyOuter$MyInner.class；

2、成员内部类（MemberInnerClass）

它类似与普通类中的非静态成员变量，但又具有类的特性，调用它需要对它实例化；

它可以访问public,package,protected,andprivate修饰的任何方法和成员变量；

MemberInnerClass不能有static变量和方法；

MemberInnerClass对象只能通过它的外部类的实例对象来进行访问，如例子；

MemberInnerClass的名字不能跟它的外部类的名字相同；

innerclass的声明：

A．在outerclass内部访问：

MyInnerin=newMyInner（）;

B．在outerclass的外部访问：

Myouter.MyInnerin=newMyouter（）.newMyInner（）;

或者Myouterout=newMyouter（）;

Myouter.MyInnerin=out.newMyInner（）;

MemberInnerClass例子：

publicclassOuter{

PublicclassInner{}

publicclassTest{

Outerot=newOuter（）;

Innerinn=newInner（）;

//这样是错误的，不能这样直接初始化

Outer.Innerinn=ot.newInner（）;

//这样才是正确的

3、本地内部类（LocalInnerClass）

LocalInnerClass是定义在类的方法中或者方法的某个代码块中的一种类；

类似于类的方法中的变量，不能被public,protected,private,orstatic修饰；

名字不能跟外部类的名字相同；

不能有static成员或方法；

只能访问它所在方法中的final变量；

4、匿名内部类AnonymousInnerClasses

AnonymousInnerClasses可以说是一个没有类名的LocalInnerClass，由于没有名字所以不需要为它定义构造器；

匿名内部类只能访问final修饰的本地变量；

它总是要继承一个类或实现一个接口（2取其1），但不需使用extends或者implement关键字；

例子

publicvoidprint（）{

System.out.println（“printingA”）;

Aa=newA（）{

//覆盖A类中的print（）

System.out.println（“printingB”）;

};

//声明一个匿名类，并将它的对象赋值给它的父类A的对象a，

a.print（）;

Aa=newA（）;

b.print（）

}结果是：

printingA

printingB

九、String和StringBuffer类

String类与StringBuffer类的区别：

a、String类是一个final类，一旦生成对象便不可改变它的值，如果改变这个对象则相当于生成了一个新的对象（将该对象指向了一个新的内存）

b、StringBuffer类则可以创建和操作动态字符串，系统可以自动地为对象扩展内存以容纳新增的文本；

StringBuffer中的length（）和capacity（）方法的区别：

1）length方法返回字符串或字符串缓冲区中包含的字符数；

2）capacity方法返回分配给字符串缓冲区的空间量（capacity（）=length（）+16）；

String类中的equals方法与==是不一样的，equals方法表示两个比较的字符串中的字符是否一致，而==则表示操作符的两边的字符串变量所指的地址是否相同；

1）StringA=”a”+”b”+”c”;

2）StringBufferB=newStringBuffer（“a”）;

B.append（“b”）.append（“c”）;

上面的两个语句最后都是返回的字符串”abc”,但是1）共创建了5个字符对象（a,b,ab,c,abc）,而2）中只创建了3个，节省了内存空间，效率更高；

importjava.util.*;

classStringTest{

publicStringhello="

Hello"

;

publicStringhel="

Hel"

publicStringlo="

lo"

classMyTest{

publicMyTest（）{}

StringTestst=newStringTest（）;

Stringstr1="

Stringstr2="

Stringstr3="

Stringstr4="

+"

Stringstr5=str2+str3;

Stringstr6=st.hel+st.lo;

System.out.println（str1==str4）;

System.o