java常用知识点汇总

第一章

Java程序有哪几种类型？

前端(Applet)、本地（Application）及后端（Servlets）程序

Java语言的程序既要被编译又要被解释执行。

同一java源文件中最多只能定义一个带public修饰的类，且要求源程序的文件名必须与public修饰的类名一致。Main方法通常也放在该类中。

编译一个java源程序时应该使用什么命令？

javac表示利用编译器将一个源程序编译为字节码程序；java表示利用解释器来解释执行字节码程序；appletviewer用来执行一个Applet小程序。

Java 源程序与字节码文件的扩展名分别是什么？

.java .class

掌握 Application程序的编写

掌握 Applet 程序的编写

import java.applet.Applet; //import语句用来引入java系统提供的类

import java.awt.*;

public class j1_3 extends Applet //继承Applet类

{

public void paint(Graphics g) //该方法为Applet中实现图形绘制的方法

{ //Applet程序将自动调用该方法进行绘图，paint()方法的参数g是一个代表“画笔”的Graphics对象。

g.setColor(Color.red); //设置画笔颜色

g.drawString("大家好", 40, 80); //在指定位置绘制字符串，后面两个参数为坐标位置

g.drawLine(30, 40 , 130, 40); //绘制直线，始点和末点坐标

g.drawOval(30, 40, 80, 60); //绘制椭圆，四个参数为椭圆外切矩形左上角的坐标、宽度及高度

}

}

Java平台的版本：J2SE、J2ME、J2EE

print 和 println 的差别。

Print实现不换行的数据输出。

Println实现数据输出后换行。

第二章

数组的定义和使用。

数组的定义格式： int c[ ]=new int[5]; float f[ ][ ]=new float [5][6];

在创建多维数组时，最后一维的大小可以不给定。int c[ ][ ]=new int [5][ ];

数组的初始化。有两种方式：

(1) 直接赋值，例如 int a[ ][ ] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};

(2) 先创建好之后，再一个元素一个元素的赋值。例如 int c[ ]=new int[5]; c[0]=1; c[1]=2; ......

基本数据类型。

int、char、boolean 、float等，每一种类型在内存中所占据的长度和缺省值（默认值）。

int 4字节 0

char 2字节 0

boolean 1字节 false

float 4字节 0.0F

什么是自动数据类型转换？什么是强制数据类型转换？

Java规定，数据表示范围小的“短数据类型”转换为数据表示范围大的“长数据类型”，系统将自动进行转换；反之必须使用强制类型转换。

基本数据类型自动转换的递增顺序为：byte->short->char->int->long->float->double。

强制类型转换格式为：变量=(数据类型)表达式。

double i＝15; short b=(short) i;

【注意】布尔类型不能与其他类型学进行转换。

Java语言标识符的命名规则。

四条规则：

(1) 标识符由英文字母 (a~z, A~Z)、数字、下划线 _ 和 美元符号$组成；

(2) 首字母不能使用数字；

(3) 标识符不能是保留字，例如 class；

(4) 大小写字母表示不同的意义，即代表不同的标识符。（大小写敏感）

Java 常用的保留字（关键字）有哪些？分别用来做什么？

abstract、static、public、final、super 、const 、void 、int 、 float…

注意：保留字都是小写字母，且保留字不能作为标识符来使用。

变量的作用域。局部变量与全局变量的差别。

全局变量，也有叫成员变量的，就是类的成员，声明在类里，整个类都能用，还可以通过访问修饰符控制其他类是够可以使用。

局部变量，在方法中，代码块中，方法的参数等地方声明，作用域只有从他声明的地方向下到最近的一个右大括号结束，出了这个范围就无法使用了。

全局变量的隐藏。如果全局变量与局部变量同名，那么在局部变量的作用域内，全局变量就被隐藏了，即不发挥作用。

main()方法。

main方法是程序的入口与出口；main方法的格式是固定的， 一般不能改动。 public static void main(String args[ ])

常用的运算符。

（1）条件运算符： c<10 ? 1: c<25 ? 2 : 3 。

（2）逻辑运算符 && || ！

（3）算术运算符： x+=y; x=x+y; 5%3 int s; s=s+3;

注意：算术的加法与字符串的加法之间的不同：String s; s=s+3;

第三章

掌握Java流程控制语句的使用，包括分支语句、循环语句和跳转语句。

例如if…then… else…语句以及 switch…case… 语句的使用。

int c=1;

switch (c)

{

case 1: … break;

case 2: … break;

default: … break;

}

while 循环和 do…while 循环的区别

While是先判断后执行。do…while是先执行后判断，至少执行一次。

break 和continue的区别 。

break：跳出所在循环体。结束循环。

continue：终止当前一轮循环，继续下一轮循环。

三种注释语句的使用。

// ：单行注释

/* */：多行注释

/** */：文档注释

第四章

怎样创建一个类的对象，应该使用什么保留字？

定义java类后，就可以使用“new+构造方法”来创建类的对象。

如何回收一个不再使用的对象？使用什么保留字？

finalize保留字

Java的内存回收机制。一般由系统的内存回收程序负责释放无用的内存，程序员可以不用负责回收内存。

Java利用package语句来创建一个包。

用户可以定义自己的包，即自定义包，也可以使用Java系统所提供的包，即系统包。

静态变量和方法。

static是静态修饰符，用来表示一个变量或方法是静态的。一个静态变量或方法属于类，不属于任何对象，可以通过“类名.变量名”和“对象名.变量名”来访问。非静态变量和方法则属于具体的对象，只能通过“对象名.变量名”来访问。静态变量也称为类变量，是一个公共的内存单元。

静态：static

用法：是一个修饰符，用于修饰成员（成员变量、成员函数）

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外

还可以直接被类名调用。类名.静态成员。

static特点：

1、随着类的加载而加载。

也就是说：静态会随着类的消失而消失，说明他的生命周期最长。

2、优先于对象存在

明确一点：静态是先存在，对象是后存在的。

3、被所有对象所共享。

4、可以直接被类名所调用。

实例变量和类变量的区别：

1、存放位置。

类变量随着类的加载而存在于方法区中。

实例变量随着对象的建立而存在于堆内存中。

2、生命周期。

类变量生命周期最长，随着类的消失而消失。

实例变量生命周期随着对象的消失而消失。

静态使用注意事项：

1、静态方法只能是访问静态成员。

非静态方法既可以访问静态也可以访问非静态。

2、静态方法中不可以定义this,super关键字。

因为静态优先于对象存在，所以静态方法中不可以出现this。

3、主函数是静态的。

静态有利有弊

利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份。

可以直接被类名调用。

弊：生命周期过长。

访问出现局限性（静态虽好，只能访问静态）。

类的成员变量进行初始化的主要途径。主要有5种途径。

（1）、自动初始化，如果是基本成员变量就赋值0，其他赋值null，boolean赋值false。

（2）、直接赋值，就是在定义类成员变量的地方为其赋值。

（3）、通过调用方法来提供初始值。如果方法带参数的话，参数必须是之前被初始化了的。

（4）、构造器初始化。通过带有参数的构造函数来构造Java 对象，通过输入不同的参数使得Java对象具有不同初始值。但要明确一点：无法阻止自动初始化的进行，它将在构造器被调用之前发生。

（5）、静态数据的初始化。静态数据属于类，只占用一份存储区域。静态初始化只有在必要时才会进行。当创建对象或者第一次访问静态数据时，它们才会被初始化，此后，静态对象不会再被初始化。

第五章

面向对象技术的三大特性。

封装、继承、多态。

子类对象与父类对象的关系。

子类的对象可以直接赋值给父类的对象，但是父类的对象不能直接赋值给子类的对象，必须进行类型转换。

Father f=new Father(); Son s=new Son();

f=s; s=(Son)f;

继承的概念。单重继承与多重继承的区别。

继承指的是一个类从另一个类从获得属性和方法的过程。继承使用extends关键字。Java不支持多重继承。为了实现多重继承的功能，Java采用接口技术，接口可以支持多重继承。接口中的变量和方法都是public 的。

什么是Object类？

Object是所有类的父类，它有很多类对象会用到的方法，例如比较常用的toString 、equals，当你新建xx类时，你可以重写Object已经定义的方法，也可以直接调用Object中的方法，如果你写一个封装的方法，不确定传进来的是什么类型的值，就可以使用Object作为一个笼统类。

Java语言的构造方法。什么是构造方法？构造方法有哪些特点？什么是缺省的构造方法？

构造方法就是与类同名的那个方法，它的作用是可以用来初始化，

1.构造器必须与类同名（如果一个源文件中有多个类，那么构造器必须与公共类同名）

2.每个类可以有一个以上的构造器

3.构造器可以有0个、1个或1个以上的参数

4.构造器没有返回值

5.构造器总是伴随着new操作一起调用

如果你没有定议任何构造方法的形式，程式会为你取一个不带任何参数的构造函数，那么你产生类的对像时只能用不带参数的方法。

函数调用时参数的传递问题（即到底是值传递还是地址传递）。

如果参数的类型为基本类型，那么通常是值传递，即实参的值被传递给形参；如果参数是一个类的对象，那么通常是地址传递，即实参的地址被传递给形参。

覆盖与重载。

重载是同一个类中有多个方法同名，但方法的参数个数或者类型不同 。

覆盖是父类与子类之间有多个方法同名，并且参数个数和类型都相同。只是方法体不同。

一个java程序中可以有多个类，但只能有一个主类（即public 类）。

主类中一般有一个主方法，main()方法。

注意main()方法的格式。

修饰符:

(1) 访问权限修饰符。

(2) abstract修饰符。

abstract修饰的类称为抽象类， abstract修饰的方法称为抽象方法，抽象方法只能位于抽象类中，但抽象类中也可以有非抽象的方法。

(3) final修饰符。final修饰的类被称为最终类，最终类不能被继承。final修饰的方法被称为最终方法，最终方法不能被重写。

接口的定义(interface)和实现(implements)。

接口是由常量和抽象方法所组成的特殊类。接口中的变量和方法都是public的。

注意 public、protected、default（不加修饰符）、private之间所存在的差别。

public protected default private：

同一个类中： ok ok ok ok

同一个包中： ok ok ok no

子类： ok ok no no

不同包中： ok no no no

第六章

String类与StringBuffer类。

注意一下String类的常用方法的使用：length(), charAt(), toUpperCase(), toLowerCase(), valueOf()方法;

String类适用于描述字符串事物。

那么他就提供了多个方法对字符串进行操作。

常见操作有哪些？

1、获取

1.1 字符串中的字符数，也就是字符串的长度。

int length():获取长度

1.2 根据位置获取位置上某个字符。

char charAt(int index)

1.3 根据字符获取该字符在字符串中的位置。

int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。

int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch第一次出现的位置。

1.4 根据字符串获取该字符串在字符串中的位置。

int indexOf(String str):返回的是str在字符串中第一次出现的位置。

int indexOf(String str,int fromIndex):从fromIndex指定位置开始，获取str第一次出现的位置。

2、判断

2.1 字符串中是否包含某一个子串。

boolean contains(str):

特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1，则表示该str不在字符串中存在。所以，也可以用于对指定判断是否包含。

2.2 字符串中是否有内容。

boolean isEmpty():原理就是判断长度是否为0.

2.3 字符串是否以指定位置开头。

boolean startsWith(str):

2.4 字符串是否以指定位置结尾。

boolean endsWith(str):

2.5 判断字符串内容是否相同。 复写了Object类中的equals方法。

boolean equals(str):

2.6 判断内容是否相同并忽略大小写。

boolean equalsIgnoreCase():

3、转换

3.1 将字符数组转成字符串

构造函数：

String(char[])

String(char[],offset,count):将字符数组中由offset位置开始之后的count个字符转换成字符串。

静态方法：

static String copyValueOf(char[]);

static String copyValueOf(char[] data,int offset,int count)

static String valueOf(char[]);

3.2 将字符串转换成字符数组

char[] toCharArray();

3.3 将字节数组转换成字符串

String(byte[]);

String(byte[],offset,count):将字节数组中的一部分转换成字符串。

3.4 将字符串转换成字节数组

byte[] getBytes();

3.5 将基本数据类型转换成字符串

String valueOf(int)

String valueOf(double)

特殊：字符串和字符数组走在转换过程中是可以指定编码表的；

4、替换

String replace(oldchar,newchar);

5、切割

String split(regex);

6、子串

String substring(begin);

String substring(begin,end);

7、转换、去除空格、比较u

7.1 将字符串转换成大些或小写。

String toUpperCase()：转换成大写

String toLowerCase(): 转换成小写

7.2 将字符串两端的多个空格去掉。

String trim();

7.3 对两个字符串进行自然顺序的比较。

int comparaTo(String);

StringBuffer：字符串缓冲区，是一个容器。

特点：

1、长度是可变化的。

2、可以直接操作多种数据类型。

3、最终会通过toString()方法变成字符串。

StringBuffer可以对字符串内容进行增删。

CURD C create U update R read D delete

1、存储

StringBuffer append():将指定数据作为参数添加到已有数据结尾处。

StringBuffer insert(index,数据)：可以将数据插入到指定index位置。

2、删除

StringBuffer delete(start,end):删除缓冲区中指定位置的数据，包含start，不包含end。

StringBuffer deleteCahrAt(index):删除指定位置的字符。

3、获取

char charAt(int index)

int indexOf(String str)

int lastIndexOf(String str)

int length()

String substring(int start,int end)

4、修改

StringBuffer replace(int start,int end,String str)：用字符串替换某段位置的字符串。

void setCharAt(int index,char ch):用字符替换某个位置的字符。

5、反转

StringBuffer reverse():

6、

将缓冲区指定数据存储到指定字符数组中。

void getChars(int srcbegin,int srcend,char[] dst,int dstBegin)

srcbegin:字符串中开始截取的位置

srcend：字符串中结束位置

dst：数组

dstBegin：数组开始存放数据的位置

用双引号括起来的字符串称为字符串常量，它是一个匿名的String对象。

同一个字符串常量在内存中只有一个，例如，常量 “a” 在内存中只有一个。

字符串的连接运算符： + ，例如： 2+“,”+3

字符串的比较运算：

equals() 方法：用来比较两个字符串对象所包含的值是否相等。

＝＝ 运算符 ：用来比较两个字符串对象在内存的地址是否相等。

equals() 方法与 equalsIgnoreCase() 方法的区别。

equals() 方法：用来比较两个字符串对象所包含的值是否相等。

equalsIgnoreCase() 方法：不区分大小写的比较两个字符串对象所包含的值是否相等。

Math类中的方法 ： random( )，sin(x) cos(x)

ceil(x) ：求不小于给定实数的最小整数。

Math类中的常量：PI、E

包装类： Integer类: parseInt(), toString()

Double类: parseDouble() Float类 …….

第七章

Java异常处理机制。

Throwable 类是 Java 语言中所有错误或异常的超类（这就是一切皆可抛的东西）。它有两个子类：Error和Exception。

Error：用于指示合理的应用程序不应该试图捕获的严重问题。这种情况是很大的问题，大到你不能处理了，所以听之任之就行了，你不用管它。

Exception：它指出了合理的应用程序想要捕获的条件。Exception又分为两类：一种是CheckedException，一种是UncheckedException。这两种Exception的区别主要是CheckedException需要用try...catch...显示的捕获，而UncheckedException不需要捕获。通常UncheckedException又叫做RuntimeException。

对于可恢复的条件使用被检查的异常（CheckedException），对于程序错误（言外之意不可恢复，大错已经酿成）使用运行时异常（RuntimeException）。

我们常见的RuntimeExcepiton有IllegalArgumentException、IllegalStateException、NullPointerException、IndexOutOfBoundsException等等。对于那些CheckedException就不胜枚举了，我们在编写程序过程中try...catch...捕捉的异常都是CheckedException。io包中的IOException及其子类，这些都是CheckedException。

异常是如何被抛出的、捕获和处理的？

throws/throw 关键字：

如果一个方法没有捕获一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。

也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。

一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。

捕获异常

使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下：

try

{

// 程序代码

}catch(ExceptionName e1)

{

//Catch 块

}

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。

如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。

finally关键字

finally 关键字用来创建在 try 代码块后面执行的代码块。

无论是否发生异常，finally 代码块中的代码总会被执行。

在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。

finally 代码块出现在 catch 代码块最后

catch 不能独立于 try 存在。

在 try/catch 后面添加 finally 块并非强制性要求的。

try 代码后不能既没 catch 块也没 finally 块。

try, catch, finally 块之间不能添加任何代码。

Java异常处理模块可以同时捕获多个异常，如果这些异常之间具有继承关系，则必须先捕获子类的异常，再捕获父类的异常。

Java 异常处理所涉及的关键字：

try、throw、catch 、throws、finally

第十章

Applet小程序的设计与开发。

import java.applet.*

注意 Applet 小程序和Application程序的区别。

Applet的生命周期以及生命周期中每个方法的作用。

在Java Applet的生命周期中，共有四种状态（初始态、运行态、停止态和消亡态）和四个方法：init()、start()、stop()和destroy()。

1. init()

当创建Java Applet且第一次使用支持Java的浏览器载入时，就会执行init()方法。在Java Applet生命周期中，该方法只执行一次，因此可以利用这一点在init()方法中进行一些只需执行一次的初始化操作，例如对变量的初始化等。

2. start()

调用完init()方法后，系统将自动调用start()方法。当用户离开包含Applet的主页后又再返回时，或者当浏览器从图标状态恢复为窗口时，系统都会自动再执行一遍start()方法。

和init()方法不同，start()方法在Applet的生命周期中被多次调用，该方法是Applet的主体。在start()方法中，可以执行一些任务，或者是启动相关的线程来执行任务，如循环播放歌曲等。

3. stop()

和star()方法相对应，当用户离开Applet所在页面或者是浏览器变成图标时，系统都会调用stop()方法，因此该方法也是可以被多次调用的。

stop()方法起到这样的作用：当用户在当前时刻并不十分关注Applet时，停止一些耗用资源的工作，这样就可以提高系统的运行速度，而且系统会自动调用该方法，并不需要人为干预。倘若编写的Applet中不涉及动画等多媒体，一般不必重写该方法。

4. destroy()

当用户关闭浏览器时，系统就会调用destroy()方法，应该注意stop()方法和destroy()方法的区别。

Applet中图形的绘制方法：

drawString、drawChars、drawBytes、drawLine、drawRect、fillRect、drawRoundRect、drawOval、drawArc、drawPolygon等。

图形绘制的相关方法：drawRect(100,100,150,150); setColor(Color.black); drawLine(10,10,10,50);

第十一章

Java图形用户界面开发。

常用的容器有哪些？

Frame、Panel、Applet、Dialog、Window。

常用的布局类型有哪些？

BorderLayout(边界布局)、FlowLayout(流式布局)、GridLayout(网格布局)、CardLayout(卡片布局)、GridBagLayout(网格包布局)，其中Frame的缺省布局类型是BorderLayout；Panel和Applet的缺省布局类型是 FlowLayout。

各种组件的使用

例如文本输入的组件（TextField和TextArea）、标签(Label)、按钮(Button)、列表(List )、下拉列表(Choice)等。

设置Frame、Panel等容器的大小和背景色。

setBounds、setSize和setBackground。

Frame 带标题和缩放功能；

Panel 不带标题和缩放功能。

Frame 对象默认是看不见的，需要通过setVisible方法来设置其可见性为true。

另外，Frame对象默认大小为0×0像素。

Java图形用户界面开发需要导入包：java.awt，而图形用户界面中的事件处理，则需要导入包：java.awt.event

Java事件处理的实现步骤（三个步骤）。

在Java的图形界面开发中，要让图形界面接收到用户的操作，就要给各个组件添加事件处理机制。在事件处理过程中，涉及到3类对象。第一是Event事件，实现用户对图形界面组件的操作，以类的形式出现，比如窗口操作对应类为WindowEvent，键盘操作对应类为KeyEvent；第二是事件源，即事件发生的场所，比如一个按钮、单选框或复选框、文本框等；第三就是事件处理者，接收发生的事件并进行处理，也称监听器。

1、创建接受响应的组件（控件）

2、实现相关事件监听接口

3、注册事件源的动作监听器

4、事件触发时的事件处理

题型：填空题、选择题、简答题、程序阅读题、程序填空题、编程题。

复习方法：多看上课的ppt课件和教材。

另外，把实验课做过的实验题重新做一遍，编程题可能是以前实验做过的。

finally:最终，作为一个修饰符。

1、可以修饰类，函数，变量。

2、被finally修饰的类不可以被继承。为了避免被继承后，被子类复写功能。

3、被finally修饰的功能不能被复写。

4、被finally修饰的变量是一个常量，只能赋值一次。既可以修饰成员变量，也可以修饰局部变量。

当在描述事物时，一些数据出现的值是固定的。那么这时为了增强阅读性，都给这些值起个名字，方便于阅读。而这个值不需要改变，所以加上finally修饰。

包名：所有字母全部小写。

类名接口名：多单词组成时，所有单词首字母全大写。

变量名和函数名：多单词组成时，第一个单词首字母小写，其他单词首字母大写。

常量名：所有字母都大写，多单词组成时，单词间下划线连接。

Java中常量的分类：

1、整形常量，所有整数。

2、小数常量，所有小数。

3、布尔型常量，true,false。

4、字符常量，将一个数字字符或符号用‘’标识。

5、字符串常量，将一个或多个字符用“”标识。

6、null常量，只有null

转义字符:通过\来改变后面字母或者符号的含义。

\n：换行

\b：退格，相当于backspace键

\r：按下回车键，Windows系统，回车键由两个字符来表示\r\n

\t：制表符，相当于tab键

以后开发实际上就是找对象使用，没有对象就创建一个对象。

类：对现实生活中事物的描述。

对象：就是这类事物实实在在存在的个体。

包与包之间进行访问，被访问的包及类中的成员，需要public修饰。

不同包中的子类还可以直接访问父类中被protected修饰的成员。

包与包之间可以使用的权限有两种：public protected

为了简化类名的书写，使用一个关键字：import

import 导入的是包中的类。

建议：不要写通配符*，需要用到包中的哪个类就导入哪个类。

建议定包名不要重复。

可以用url来定义，url是唯一的。

以上就是java常用知识点汇总的详细内容，更多请关注其它相关文章！