Java基础知识点答案.docx
《Java基础知识点答案.docx》由会员分享，可在线阅读，更多相关《Java基础知识点答案.docx（21页珍藏版）》请在冰豆网上搜索。
Java基础知识点答案
1、classpath的设置及作用：
设置为setclasspath=“绝对路径”。
作用是指定Java类的执行路径。
是用来寻找class文件的。
2、path的设置及作用：
是内部命令。
在编译Java的时候需要用到javac命令在执行java的时候要用到java命令，这两个命令不时windows自带的命令，所以我们使用的时候要设置好环境变量，这样就可以在任何目录下使用了。
3、JAVA数据类型：
基本数据类型（数值型（整型（byte.short.int.long）、浮点型（float.double））、字符型（char）、布尔型（boolean））、引用数据类型（class.数组、接口）。
4、JAVA基本运算符号：
赋值运算符、算术运算符、关系运算符、逻辑运算符、条件运算符、括号运算符。
5、JAVA程序基本控制语句：
1、if（判断条件）
{
语句1；
语句2；
}
2、if（判断条件）
{
语句1；
}
else
{
语句2；
}
3、switch（表达式）
{
case选择值1；语句主体1；
break；
case选择值2；语句主体2；
break；
case选择值3；语句主体3；
break；
default：
语句主体；
}
4、for（赋初始值；判断条件；赋值增减量）
{
语句；
}
5、while（判断条件）
{
语句1；
语句2；
}
6、do
{
语句1；
语句2；
}
while（判断条件）；
break跳出循环。
continue跳出本次循环进入到下次循环。
6、数组的概念及使用：
数组是由一组相同类型的变量所组成的数据类型，它们以一个共同的名称来表示。
格式一：
数据类型数组名[]
数组名=new数据类型[个数]
例：
inti[]
i=newint[8]
格式二：
数据类型数组名[]=new数据类型[个数]
例：
inti=newint[8]
7、方法的声明及使用：
完成某一特定功能的代码块。
返回值类型方法名称（类型参数1，类型参数2）
{
程序语句；
return表达式；
}
8、方法的重载：
在同一个类中允许同时存在一个以上的同名方法，只要他们的数据类型参数个数不同即可。
例如：
publicstaticintTest（inti,intj）
{
returni+j;
publicstaticintTest（intx）
{
returnx++;
}
pubicstaticdoubleTset（doublem,doublen）
{
returnm+n;
}
publicstaticintTest（inta,intb,intc）
{
returna-b+c;
}
}
在程序中Test方法被重载了4次，但每个重载了的方法所能接受参数的个数和类型不同。
9、类的定义：
将具有相同属性及相同行为的一组对象称为类。
广义的讲，具有共同性质的事物的集合就称为类。
class类名称
{
数据类型属性；//声明成员变量（属性）
返回值的数据类型方法名称（参数1，参数2）
{
程序语句；
return表达式；//定义方法的内容
}
}
例：
Person.java
ClassPerson
{
Stringname;
intage;
voidtalk（）
{
System.out.println（＂我是：
＂+name+＂,今年：
＂+age+＂岁＂）;
}
}
10、对象的产生与使用：
对象产生的基本形式类名对象名=new类名（）对象可以调用类中的方法访问类中的成员变量，形势为对象.属性对象.方法名（）
11、匿名对象：
没有明确的声明对象，也可以理解为只使用一次的对象，即没有任何一个具体的对象名称引用它。
12.实现类的封装性
封装了相关的成员和方法，通过访问权限来使用内部的东西。
13.构造方法的定义与使用
构造方法的定义方式：
class类名称
{
访问权限类名称（类型1参数1，类型2参数2）
{
语句；
}
}
注意：
1.构造方法的名称必须和类名一致。
2.构造方法无返回值。
例：
classpig
{
publicpig（）
{
System.out.println（“It’sapig.”）;
}
}
14.对象的比较（“==”、“equals（）”
“==”比较的是对象所指的引用
“equals（）”比较的是对象。
15.在类内部调用本类方法
范例：
TestJavaThis1.java
classPerson
{
Stringname;
intage;
publicPerson（）
{
System.out.println（“1.publicPerson（）”）;
}
publicPerson（Stringname,intage）
{
//调用本类中无参构造方法
this（）;
16.this关键字的使用
1.用来区分成员变量和局部变量.
2.用来表示本类内部的构造方法.（this必须放在构造方法中的第一行）
范例:
TestJavaThis.java
classPerson
{
privateStringname;
privateintage;
publicPerson（Stringname,intage）
{
this.name=name;
this.age=age;
}
publicStringtalk（）
{
return“我是:
”+name+”,今年:
“+age+”岁”;
}
}
publicclassTestJavaThis
{
publicstaticvoidmain（String[]args）
{
Personp=newPerson（“张三”,25）;
System.out.println（p.talk（））;
}
}
输出结果：
我是：
张三，今年：
25岁
17.构造方法的重载
1.方法名字相同
2.参数的类型、排列方式、个数不同
例如：
publicstaticintTest（inti,intj）
{
returni+j;
publicstaticintTest（intx）
{
returnx++;
}
pubicstaticdoubleTset（doublem,doublen）
{
returnm+n;
}
publicstaticintTest（inta,intb,intc）
{
returna-b+c;
}
}
在程序中Test方法被重载了4次，但每个重载了的方法所能接受参数的个数和类型不同。
18.对象的引用传递
例：
S1=”abc”
S2=”bcd”
S1=S2
把S2所指的引用”bcd”赋给了S1，这时S1的引用就是”bcd”。
19.static的使用（方法、属性）
1、static：
静态方法：
1直接用类名来调用2一个静态方法可以直接调用另一静态方法调用非静态方法时用对象调用3静态方法中不能用this、super4静态方法不能调用非静态方法中的属性。
Static声明的成员变量为全局变量局部变量不能声明成static。
静态代码块是在static后加个大括号作用是给静态成员赋值。
20.对象数组的使用（静态初始化、动态初始化）
1数组是多个相同类型数据的集合，实现对这些数据的统一管理。
2数组是引用数据类型，数组型数据是对象（object），数组的每个元素相当于该对象的成员变量。
3数组中的元素可以是任何数据类型，包括基本类型和引用类型。
一维数组声明
一维数组的声明方式：
Typevar[]或type[]var;
例如：
inta[];int[]a;doubleb[];
注！
Java语言中声明数组时不能指定其长度（数组中元素的个数），例如：
inta[]5;//错误的
正确的写法：
int[]a;（数据类型数组名[]；//声明一维数组
a=newint[5];数组名=new数据类型[个数]）//分配内存给数组
创建基本一维数组
publicclassTest
{
publicstaticvoidmain（String[]args）
{
int[]s;
s=newint[10];
for（inti=0;i<10;i++）
{
s[i]=2*i+1;
System.out.println（s[i]）;
}
}
}
编译结果：
E:
\>javaTest
1
3
5
7
9
11
13
15
17
19
21.类的继承
通过继承可以简化类的定义，扩展类的功能。
实现继承的方法：
class子类extends父类。
例：
ClassA{
Stringname;
intage;
}
ClassBextendsA{
Stringschool；
}
publicclassTest
{
publicstaticvoidmain（Stringargs[]）{
Bs=newB（）;
s.name=”周洋”;
s.age=”23”;
s.school=”绥化学院”；
System.out.println（“姓名：
”+s.name+”,年龄：
”+s.age+”,学校：
”+s.school）;
}
}
22.子类对象的实例化过程
子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用子类中的相应构造方法。
依次执行
范例：
TestPersonStudentDemol.java
classPerson
{
Stringname;
Intage;
//父类的构造方法
publicPerson（）
{
System.out.println（“1.publicPerson（）{}”）;
}
}
classStudentextendsPerson
{
Stringschool;
//子类的构造方法
PublicStudent（）
{
System.out.println（“2.publicStudent（）{}”）;
}
}
publicclassTestPersonStudentDemol
{
publicstaticvoidmain（String[]args）
{
Students=newStudent（）;
}
}
输出结果：
1.publicPerson（）{}
2.publicStudent（）{}
23．方法的覆写
当一个子类继承一个父类，而子类中的方法与父类中的方法的名称，参数个数、类型完全一致时，就称子类中的这个方法覆写了父类中的方法。
特点：
1、两个类存在继承关系；2、子类里写了一个方法，方法的声明与父类一致。
例如：
classPerson{
publicvoidtest（）{
System.out.println（“Person”）;
}
}
classStudentextendsPerson{
publicvoidtest（）{
System.out.println（“Student”）;
}
}
24．super的使用
super关键字出现在子类中，用super去调用父类中的有参的构造方法，所以super主要功能是完成子类调用父类的内容，也就是调用父类中的构造方法。
注意：
用super调用父类中的构造方法，只能放在第一行。
格式：
super.父类中的属性；
super.父类中的方法；
例如：
（1）classPerson
{
Stringname;
intage;
publicPerson（）
{
}
publicStringtalk（）
{
return"我是：
"+this.name",今年；"+this.age+"岁";
}
}
classStudentextendsPerson
{
Stringschool;
publicStudent（Stringname,intage,Stringschool）
{
super.name=name;
super.age=age;
System.out.println（super.talk（））;
this.school=school;
}
}
publicclassTest
{
publicstaticvoidmain（Stringargs[]）
{
Students=newStudent（"张三"，23，"北京"）;
System.out.println（"，学校:
"+s.school）;
}
}
（2）publicclassKiss1
{
Stringname;
intage;
Kiss1（）
{
System.out.println（“aaaaaaaaaaaaaa”）;
}
Kiss1（Stringname,intage）
{
this.name=name;
this.age=age;
System.out.println（name+age）;
}
}
classKiss2extendsKiss1
{
publicKiss2（）
{
super（"aaaaaaa",23）;
}
publicstaticvoidmain（String[]args）
{
Kiss2p=newKiss2（）;
}
}
25．this与super的区别
this关键字的作用：
1.用来区分成员变量和局部变量.
2.用来表示本类内部的构造方法.（this必须放在构造方法中的第一行）
super关键字出现在子类中，用super去调用父类中的有参的构造方法，所以super主要功能是完成子类调用父类的内容，也就是调用父类中的构造方法。
用super调用父类中的构造方法，只能放在方法体中的第一行。
26．final关键字
final声明的变量就变成了常量，今后不可以修改。
只能声明时初始化或者在构造方法中初始化。
final声明的方法不能被子类复写。
final声明的类不能被继承。
27．抽象类的使用
抽象类：
java可以创建一种类专门用来当作父类，这种类称为“抽象类”
抽象类的定义规则：
1、抽象类和抽象方法都必须用abstract关键字类修饰。
2、抽象类不能被直接实例化，也就是不能直接用new关键字去产生对象。
3、抽象方法只需声明，而不需实现。
4、含有抽象方法的类必须被声明为抽象类，抽象类的子类必须覆写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。
抽象类的定义方法：
Abstractclass类名称
{
//定义抽象类
声明数据成员：
访问权限返回值的数据类型方法名称（参数）
{
？
}
Abstract返回值的数据类型方法名称（参数）；
//定义抽象方法，在抽象方法里，没有定义方法体
}
28．接口的使用
接口（interface）是java所提供的另一种重要技术，它的结构和抽象类非常相似，也具有数据成员与抽象方法，但它与抽象类又有以下两点不同：
1．接口里的数据成员必须初始化，且数据成员均为常量。
2．接口里的方法必须全部声明为abstract，也就是说，接口不能象抽象类一样拥有一般的方法，必须全部都是“抽象方法”。
接口定义的语法如下：
interface接口名称//定义抽象类
{
final数据类型成员名称=常量；//数据成员必须赋初值
abstract返回值的数据类型方法名称（参数…）；
//抽象方法，注意在抽象方法里，没有定义方法主体
}
在java中接口是用于实现多继承的一种机制，也是java设计中最重要的一个环节，每一个由接口实现的类必须在类内部覆写接口中的抽象方法，且可自由地使用接口中的常量。
既然接口里只有抽象方法，它只要声明而不用定义处理方式，于是自然可以联想到接口也没有办法象一般类一样，再用它来创建对象。
利用接口打造新的类的过程，称之为接口的实现（implementation）。
接口的实现：
格式：
class类名称implements接口A，接口B
{
……
}
29．对象的多态性、向上转型及向下转型的概念
Java语言中有（方法重载）和（成员覆写）两种形式的多态。
overload
override
在一个类中
在具有继承关系的两个类中
函数名相同
函数的定义完全相同
参数列表不同
多态其实就是表现在具有相同的代码，但是表现出来的内容却不同
向上转型：
把子类类型对象的引用转化成父类类型对象的引用。
向下转型：
把父类类型对象的引用转化成子类类型对象的引用。
30．抽象类及接口的应用
接口是为了实现Java的多继承。
31．异常的概念、分类及使用
异常：
异常实际上是程序中错误导致中断了正常的指令流的一种事件。
异常的分类：
异常是一个对象，它继承自Throwable类，所有的Throwable类的子孙类所产生的对象都是例外。
Error:
由Java虚拟机生成并抛出，Java程序不做处理。
RuntimeException：
由系统检测，用户的Java程序可不做处理，系统将它们交给缺省的异常处理程序。
Exception：
Java编译器要求Java程序必须捕获或声明所有的非运行时异常。
throw：
用户自己产生异常。
32．Java程序的编写规范
命名规范，常量用大写，类的声明顶格写，一个文件尽量只包含一个类。
33．try…catch语句的使用
用try来捕捉程序中是否会抛出异常，用catch来处理异常。
34.throws和throw:
throws是在方法后抛出一个可能有异常的声明，而throw是在方法内部故意抛出的一个异常。
35.finally关键字:
放在try（）{……}catch（）{……}后面，用法是无论是否会抛出异常，都会执行finally主体中的语句。
39.List,ArrayList的使用
list是用存放引用数据类型的数据的接口，list存放的数据是有序的，而且可以重复。
ArrayList是实现list接口的类。
所以他也同样具有list中的特性。
ArrayList中添加元素用的方法是add（）,获取元素的方法是get（）,并且是用循环输出.
例:
Example1.java
importjava.util.*;
importjava.text.*;
publicclassExample1
{
publicstaticvoidmain（String[]arg）
{
ArrayListp=newArrayList（）;
p.add（“a”）;
p.add（“b”）;
p.add（“c”）;
p.add（“b”）;
p.add（“d”）;
for（inti=0;iSystem.out.println（p.get（i））;
}
}
输出结果：
a
b
c
b
d
此例证明了ArrayList的有序和重复性。
40.Map.ListMap的使用.
Map是双值的，一个位置存两个东西。
Map包括键和值两部分.
键:
只能存引用数据类型，无序的，不能重复。
值：
只能存引用数据类型，允许重复。
put（）方法用来放此映射中关联指定键也指定值。
get（）方法用来取键在此映射中关联的值。
importjava.util.*;
publicTest
{
publicstaticvoidmain（String[]arg）
{
HashMaphm=newHashMap（）;
hm.put（“a”,”b”）;
hm.put（“c”,”d”）;
System.out.println（hm.get（“a”））;
}
}
输出结果为：
b
41.Set.HashSet的使用
Set也是用来存放引用数据类型的接口，存放的数据无序的，不能重复。
HashSet是实现Set接口的一个类，它也同样具有Set的性质。
add（）方法是用来添加数据元素到相应的HashSet表里的方法，
输出的时候用迭代器，再用hasNext（）方法判断是否有下一个元素，
再用next（）方法输出下一个元素。
例题：
importjava.util.*;
publicclassA
{
publicstaticvoidmain（String[]arg）
{
HashSeths=newHashSet（）;
hs.add（“a”）;
hs.add（“b”）;
hs.add（“c”）;
Iteratorit=hs.iterator（）;
while（it.hasNext（））
{
System.out.println（it.next（））;
}
}
}
输出结果为b
c
a
42.Iterator的使用：
返回在此set中的元素上进行迭代的迭代器。
返回的元素没有特定的顺序，返回值类型为Iterator。
用set类的实例化对象调iterator（），再赋给一个Iterator类型的变量，再用while循环判断是否有下一个迭代，如果有则输出下一个迭代。
43.String和StringBuffer的使用：
String类用于比较两个字符串、查找和抽取串中的字符或子串、字符串与其它类型之间的相互转换等。
String类对象的内容一旦被初始化就不能再改变。
StringBuffer类用于内容可以改变的字符串，可以将其它各种类型的数据增加、插入到字符串中，也可以转置字符串中原来的内容。
一旦通过StringBuffer生成了最终想要的字符串，就应该使用StringBuffer.toString（）方法将其转换成String类，随后，就可以使用String类的各种方法操纵这个字符串了。
Stringx=“a”+4+”c”;
编译时等效于
Stringx=newStringBuffer（）.append（“a”）
升级会员 