java基础知识点.docx

java基础知识点.docx

《java基础知识点.docx》由会员分享，可在线阅读，更多相关《java基础知识点.docx（43页珍藏版）》请在冰豆网上搜索。

java基础知识点

Java知识点要求

一、概念方面：

1、掌握JVM、JRE、JDK三个概念及其三者之间的关系。

JVM（JavaVirtualMachine）：

Java虚拟机，从结构上看它与实例的计算机相似，其作用是使得一台实

际的计算机能够运行java字节码程序。

Java字节码是java原程序编译以后的程序，它不能被计算

机直接执行，但可以被所有的java虚拟机执行。

原程序—（编译）—java字节码程序—（java虚拟机运行）—程序

JRE（JavaRuntimeEnviroment）：

Java运行环境的缩写。

它基本上就和Java虚拟机是同一个概念。

一个Java运行环境包括实际计算机、适配器、Java虚拟机、Java基本软件和Java应用程序接口。

JDK：

（JavaDevelopmentKit）：

Java开发包、开发工具、是Java应用程序的程序开发环境。

JDK包含的基本组件包括：

javac–编译器，将源程序转成字节码

jar–打包工具，将相关的类文件打包成一个文件

javadoc–文档生成器，从源码注释中提取文档

jdb–debugger，查错工具

联系：

一般说来，在谈论一个具体的产品的时候，可以说“JRE”，而说到理论中的一个模型的时候，我们常用的是“Java虚拟机”。

要使用Java程序，JRE是必不可少的环境。

JVM是Java运行环境的核心。

2、类与对象的定义及其之间的关系

（1）类：

同种对象的集合与抽象

类结构：

基类：

所有Java的类都派生自Object；

Java的类可组织在包（package）中；

Java提供的标准类库分布在一系列的包中，如java.lang，java.util，等（参见P.117）；

编程的过程就是继承基类或标准类而创建、定义特殊子类的过程

③类属性说明：

friendly（默认访问）：

修饰符的类属性可以被定义同一包package中的任何类访问。

这是默认的。

private（私有成员）：

只能在同一个类中定义的方法中使用，这种方式通常是安全的。

public（公共成员）：

可以被文件中的任何类方法所访问。

由于public属性不受限制，很容易使类的对象被修改，因此建议类属性尽量不要使用public修饰符。

protected（受保护成员）：

修饰的类的属性可以被子类自由访问。

final（最终的）：

修饰的类的属性是不可改变

（2）对象是变量和相关的方法的集合，其中变量表明对象的状态属性，方法表明对象所具有的行为。

对象一般都有两个特征：

状态（state）和行为（behavior）。

①使用构造方法构造对象的格式如下：

类名对象名=new该类构造方法；

可以通过不同个数或类型的参数分别调用不同的构造方法。

例如：

Circlecircle1=newCircle（）;

Circlecircle2=newCircle（5）;

②当构造一个类的对象时,JVM主要完成以下3件事情：

为对象分配内存空间；

初始化对象属性的值，初始值可以是默认值，或者属性按指定的参数值初始化；

调用对象的构造方法。

（3）联系：

类（Class）是现实世界某些对象的共同特征（属性和操作）的表示，对象（Object）是类的实例。

3、interface的定义、作用、使用方法。

（接口中的方法都是抽象方法，变量都是static、public、final的类型。

）

（1）接口的定义：

[修饰符]interface接口名[extends父接口名1，父接口名2，父接口名3，……]

{

[publicstaticfinal]属性数据类型属性名1=值；

……；

返回值类型方法名（形参表）[throw异常名列表]；

……；

}

例：

publicinterfaceProduct{

staticfinalStringMAKER=”MyCorp”;

staticfinalStringPHONE=”555-123-4567”;

publicintgetPrice（intid）;}

（2）实现一个接口的步骤如下：

首先在类说明里用implements关键字说明该类将要实现的一个或多个接口，

然后在类体里面完成该接口里所有方法的代码，

最后才能使用这些被实现了的方法。

（3）实现接口的类的声明形式如下：

[类修饰符]class类名[extends父类名][implements接口名列表]

例：

下面是一个Shoe类实现Product接口的例子

publicclassShoeimplementsProduct{

publicintgetPrice（intid）{

if（id==1）return（5）;

elsereturn（10）;}

publicStringgetMaker（）{

return（MAKER）;

}}

（4）接口具有多重继承的特点，即一个接口可以有多个父接口。

应用继承性，可以把已经开发好的接口的代码扩展成更大的子接口。

例如：

interfaceProductlikeextendsProduct{

publicStringgetPhone（）；}

接口和抽象类的不同：

我认为，抽象类和接口的区别在于使用动机。

使用抽象类是为了代码的复用，而使用接口的动机是为了实现多态性。

接口只包含常量和方法的定义，而没有方法的实现。

接口中的常量只能用public和static修饰，如果不声明，则默认为publicstatic；接口中的方法都是抽象方法，只能被public修饰，如果不声明，则默认为publicabstract。

与类继承不同，一个接口可以继承多个父接口，而且允许没有父接口。

4、package的定义、作用，带包的类的运行方法，有包时classpath的配置内容。

（1）包（package）是一组相关的类和接口的集合，相当于其他语言中的库函数。

Java的每个类都包容在相应的某个包中。

（2）创建包的格式为：

packagepackageName1[.packageName2[.packageName3…]]；

例如：

packagepkg1；

?

packagepkg2.pkg3；

（3）两种引用方法：

一种方法是使用类的全限定名称来访问；实际类的名字应该是包名加点号运算符加类名。

例如，用全限定名称使用类pkg3。

pkg2.pkg3PKG=newpkg2.pkg3（）;

另一种方法是用import语句引入包，然后使用。

格式如下：

importpackage1[.package2…].（classname|*）；

例如下面的语句体现了两种引用形式：

?

importjava.io.*；

?

importjava.util.Date；

（4）带包的类的运行方法

Java报名.类名；

例如Javapkg2.pkg3.test;

（5）有包时classpath的配置内容

例如包放在c：

下面几类放在c：

/pkg2/pkg3

则classpath应为c：

5、构造方法的定义、作用、语法格式，构造方法的继承规则。

（1）构造方法是用来初始化新创建的对象的一种特殊的方法。

构造方法说明：

[构造方法修饰符]类名（[形参列表]）[throws异常列表]

{构造方法体}

构造方法举例：

classPoint{

intx,y;

Point（）{

x=0;y=0;}

Point（intx,inty）

{this.x=x;this.y=y;}}

（2）构造方法有以下特点：

构造方法名与类名相同；

构造方法无任何返回值和返回类型；

构造方法不能直接通过方法名引用，必须使用运算符new调用；

每个类可以有零个或多个构造方法。

构造方法的说明中只能带public，protected和private等表示访问权限的修饰符。

在构造方法的实现中，也可以进行方法重载。

一个类可以有任意数目的构造方法，不同的构造方法根据参数的不同决定要初始化的新对象状态。

6、抽象类的特点，内部方法的定义，抽象类的作用及使用方法；

【抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。

】

抽象方法只需声明，而不需要实现。

含有抽象方法的类必须被声明为抽象类，抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类还是抽象类。

一、抽象类：

（概念）

抽象类是特殊的类，只是不能被实例化；除此以外，具有类的其他特性；重要的是抽象类可以包括抽象方法，这是普通类所不能的。

抽象方法只能声明于抽象类中，且不包含任何实现，派生类必须覆盖它们。

另外，抽象类可以派生自一个抽象类，可以覆盖基类的抽象方法也可以不覆盖，如果不覆盖，则其派生类必须覆盖它们。

二、接口：

（概念）

接口是引用类型的，类似于类，更和抽象类有所相似，以至于很多人对抽象类和接口的区别比较模糊。

另外，接口有如下特性：

接口除了可以包含方法之外，还可以包含属性、索引器、事件，而且这些成员都被定义为公有的。

除此之外，不能包含任何其他的成员，例如：

常量、域、构造函数、析构函数、静态成员。

一个类可以直接继承多个接口，但只能直接继承一个类（包括抽象类）。

抽象类和接口的相似处:

1、不能实例化；

2、包含未实现的方法声明；

3、派生类必须实现未实现的方法，抽象类是抽象方法，接口则是所有成员（不仅是方法包括其他成员）；

抽象类和接口的不同之处:

1一个类可以有多个接口只能有继承一个父类

2抽象类可以有构造方法，接口中不能有构造方法。

3抽象类中可以有普通成员变量，接口中没有普通成员变量

4接口里边全部方法都必须是abstract的,抽象类的可以有实现了的方法

5抽象类中的抽象方法的访问类型可以是public，protected但接口中的抽象方法只能是public类型的，并且默认即为publicabstract类型

6抽象类中可以包含静.,态方法，接口中不能包含静态方法（被abstract修饰的方法不能被static修饰）

7抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是publicstaticfinal类型，并且默认即为publicstaticfinal类型

7、继承的使用、作用，java单根继承的特点。

【普通类继承抽象类必须实现父类的所有抽象方法，但抽象类继承抽象类，可以不实现父类的抽象方法。

】

（1）继承是由已有的类创建新类，通过继承，程序可以在扩展现有类的基础上声明新类。

Java不支持多重继承，只支持单重继承。

Java要求每一个类都有父类，当没有显式定义父类时，系统默认为Java.lang.object类时该类的父类。

（2）子类不能继承父类中访问权限为private的成员变量和方法。

子类可以继承父类中访问权限设定为public,protected,default的成员变量和方法，但不能访问权限为private的成员变量和方法。

子类可以重写父类的方法，及命名与父类同名的成员变量。

（3）继承的一般形式为：

[修饰符]class子类名extends父类名

{类体；}

8、组合的作用，组合与继承的区别及使用方法。

在新类里简单地创建原有类的对象。

我们把这种方法叫作“组合”，因为新类由现有类的对象合并而成。

我们只是简单地重复利用代码的功能。

组合也就是一个类的对象是另外一个类的成员，一般的程序都有组合的意味，只不过是基本数据类型是成员变量，下面请看具体的例子

classHead

{

Head（）{

System.out.println（"head"）;}}

classBody

{

Body（）{

System.out.println（"body"）;}}

classPerson（）

{

Headh=null;

Bodyb=null;

Person（）//人是由头和身体组成的,Head和Body的对象是Person的一部分

{h=newHead（）;

b=newBody（）;

}}

组合关系和继承关系相比，前者的最主要优势是不会破坏封装，当类A与类C之间为组合关系时，类C封装实现，仅向类A提供接口；而当类A与类C之间为继承关系时，类C会向类A暴露部分实现细节。

在软件开发阶段，组合关系虽然不会比继承关系减少编码量，但是到了软件维护阶段，由于组合关系使系统具有较好的松耦合性，因此使得系统更加容易维护。

9、静态变量、静态方法的特点。

（1）使用修饰符static在类内，方法外定义的变量称为类变量，又称静态变量。

类变量的作用域是以类为单位的。

对于同一个类内的任何对象，它们拥有相同的类变量。

类变量可通过类名直接访问，无需先生成一个实例对象，也可以通过实例对象访问类变量。

（2）访问static类属性变量，格式如下：

类名.static类属性名

例如，访问StaticPoint的static类属性x，格式如下：

StaticPoint.x

（3）对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。

10、对象变量、对象方法的特点，

（1）null：

表示空，用于指代空对象，即这个类不存在相应的对象

this:

表示当前对象

super：

表示直接父对象

（2）Pointp1=null；//没有构造相应的对象

Super的使用有三种情况：

访问父类被隐藏的成员变量，如：

super.variable;

调用父类中被重写的方法，如：

super.Method（[paramlist]）;

调用父类的构造函数，如：

super（[paramlist]）;

关键字this来指明当前对象的成员变量或当前对象的方法。

classThreeColor{

inth,s,b;

ThreeColor（inth,ints,intb）{

this.h=h;

this.s=s;

this.b=b;}}

（3）对象方法的特点：

只能被对象调用（可能是我也拿不准）

（4）与静态变量、静态方法的区别：

静态变量类似于全局变量，存在于类内，对象变量存在于对象内，只有创建出了对象后，该变量才存在，每个对象有自己的成员变量，不影响其他对象的变量值，但静态变量不一样，每个对象和类都是使用的同一个静态变量。

11、变量类型定义语法，特别注意float、double、char、String类型的定义

（1）变量的定义包括变量名、变量类型和作用域几个部分。

注意以下几点：

变量名必须是一个合法的标识符。

变量名应具有一定的含义，以增加程序的可读性。

变量类型可以为前面所说的任意一种数据类型。

声明一个变量的同时也就指明了变量的作用域，变量的作用域指明可访问该变量的一段代码。

按作用域来分，变量可以有下面几种：

局部变量、类变量、方法参数、例外处理参数。

（2）变量声明：

先声明，后使用

变量声明格式：

数据类型变量名1[,变量名2];

例如：

inta，b;//这是声明

变量赋值格式：

变量名1=值1；

例如：

a=45；//这是赋值

声明和赋值同时：

数据类型变量名1[=值1][,变量名2[=值]…];

例：

floatf=2.5,g=5.8;

（2）整型变量:

inta=45;

浮点型变量：

floatf=5.78f；//声明一个float时，必须加上后缀“f”或“F”

//声明double、long的时候，可以加后缀，也可以不加

字符型变量:

charc1='a';

Srtingname1=newString（"李白"）;

布尔型变量:

booleanb=false;

12、数组的定义方法，数组的创建，如何得到数组的长度

【数组也是对象，即是引用型变量，数组没有初始化时不能使用内容的元素。

数组元素的下表从0开始，到长度-1为止。

】

（1）数组是一种最简单的引用数据类型；数组是一个对象

（2）数组的创建一般需要以下步骤：

①数组的声明：

数组声明格式如下：

数据类型数组名[]；或者数据类型[]数组名；

例如：

intArray[]；或者intArray1[],Array2[]；

②数组的初始化

A：

静态初始化

一维数组静态初始化的形式如下：

格式：

类型标识符数组名[]={初值表};

例如：

intscore[]={65,79,85,60};

B：

动态初始化

a：

对于基本类型的数组，若数组已经声明，则动态初始化的格式如下：

数组名=new数组元素类型[数组长度]；

例：

intscore[]；score=newint[8]；

对于基本类型的数组，若数组没有声明，则可在数组声明的同时用new运算符为数组分配内存空间。

声明格式如下：

数据类型数组名[]=new数组元素类型[数组长度]；

如intscore[]；score=newint[8]；等价于：

intscore[]=newint[8];

b：

对于引用类型的数组，除了对整个数组分配内存空间外，还需对每个数组元素分配内存空间。

首先为数组分配空间：

数组名=new类型[数组长度]；

为每个数组元素分配空间：

数组名[数组长度-1]=new类型（参数列表）；

例：

StringsArray[]；

sArray=newString[3]；

sArray[0]=newString（“how”）；

sArray[1]=newString（“are”）；

sArray[2]=newString（“you”）；

（3）二维数组

①二维数组的声明格式：

数据类型数组名[][];或数据类型[][]数组名;

例如：

inta[][];

②二维数组的初始化

赋初值初始化数组intArray[][]={{1,2,3},{4,5,6}}；

用new初始化

直接为每一维分配空间如：

inta[][];a=newint[3][4];或者inta[][]=newint[3][4];

分别为每一维分配存储空间，但须从高维开始

例如：

Strings[][]=newString[2][];

s[0]=newString[2];

s[1]=newString[2];

s[0][0]=newString（“Glad”）;

s[0][1]=newString（“to”）;

s[1][0]=newString（“meet”）;

s[1][1]=newString（“you”）;

③二维数组的引用对二维数组中每个元素，引用方式为：

数组名[下标1][下标2]

（4）注意事项：

下标1和下标2都是从0开始，最大值等于每一维的长度减1。

数组使用之前要确定大小，可以在程序中根据需要指定其大小（如用表达式计算出大小）。

一旦生成数组，大小不可改变。

java不支持变长数组。

数组的属性—length代表数组元素的个数

数组是一个对象,length为数组的成员变量,调用它可查看数组长度

Java数组作为一种对象类型，可以作为方法的参数，传递的是指向数组的引用。

越界例外：

用下标变量访问数组元素（0~N-1），越界时系统会产生例外：

ArrayIndexOutOfBoundsException例外。

（5）复制数组：

Java语言为拷贝数组提供了一个特殊的通用方法arraycopy（），它是System类的一个静态成员方法，其使用格式如下：

System.arraycopy（from,fromIndex,to,toIndex,count）;

13、多态的定义、使用方法，抽象类、接口及继承时如何体现多态的使用

（1）用同一个名字调用实现不同操作的方法

方式1：

不同的类之间的同名方法如：

中国人/日本人/美国人说话

方式2：

参数不同的同名方法使用方便，且降低了维护和编程量

（2）

14、字符串的多种定义方法，各种定义方法的区别。

字符串类常用的方法（见附录）如何使用，各自的作用。

（1）字符串常量：

String类字符串变量：

StringBuffer类

这两个类的共同特点是都不能再派生子类，即它们都不能被其他类继承,因为他们都是final类。

例如：

Strings=”Wearestudent.”

（2）创建String类对象

①publicString（）：

该构造函数用于创建一个空的字符串常量。

②publicString（Stringvalue）：

该构造函数用于根据一个已经存在的字符串常量来创建一个新的字符串常量，该字符串的内容和已经存在的字符串常量一致

③publicString（charvalue[]）：

该构造函数用于根据一个已经存在的字符数组来创建一个新的字符串常量。

④publicString（StringBufferbuffer）：

该构造函数用于根据一个已经存在的StringBuffer对象来创建一个新的字符串常量。

（3）String类的常用方法

①求字符串的长度

publicintlength（）：

返回字符串的长度，这里的长度指的是字符串中Unicode字符的数目。

例：

Strings=”Wearestudents.”;s.length（）;

②求字符串中某一位置的字符

publiccharcharAt（intindex）：

该方法返回index位置的字符。

例：

Strings=”Wearestudents.”;s.charAt（4）;

③字符串的复制

publicvoidgetChars（intsrcBegin,intsrcEnd,char[]dst,intdstBegin）方法：

该方法的作用是把字符串中的字符复制到一个字符数组中。

其中形参srcBegin和srcEnd表示被复制字符的开始位和结束位；dst是目标字符数组名，dstBegin是目标字符数组的开始位。

例：

chardst[]={‘W’,’e’,’l’,’c’,’o’,’m’,’e’,’!

’};

Strings=’Thisisabook’;s.getChars（0,3,dst[],4）;

④字符串的修改字符串中字符大小写的转换

A：

publicStringtoLowerCase（）：

该方法将字符串中所有字符转换成小写，并返回转换后的新串。

Strings=”Howoldareyou?

”;

Strings1=s.toLowerCase（）;

B：

publicStringtoUpperCase（）：

该方法将字符串中所有字符转换成大写，并返回转换后的新串。

Strings=”Howoldareyou?

”;

Strings1=s.toUpperCase（）;

⑤字符串中多余空格的去除

publicStringtrim（）：

该方法只是去掉开头和结尾的空格，并返回得到的新字符串。

⑥字符串中字符的替换

A：

publicStringreplace（charoldChar,charnewChar）：

该方