学习总结

Posted 2021-03-23 noacgnnolife

Java学习总结

一，java的一些基本概念

 

1，Java中的关键字：

             

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	断言，用来进行程序调试
boolean	基本数据类型之一，声明布尔类型的关键字
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	声明一个类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

 

2，变量和常量：变量是利用声明的方式将内存中的某个内存块保留下来以供程序使用。

 

3，基本数据类型：

类型	boolean	char	byte	short	int	long	float	double
字节	1	2	1	2	4	8	4	8

 

自动类型转换：低à高

short,byte,charàintàlongàfloatàdouble

 

强制类型转换：  （转换的类型名）变量名

 

 

 

4，运算符

 

 

5，封装性

为属性封装：private 属性类型 属性名称

为方法封装：private 方法返回值 方法名称（参数列表）{}

只要是被封装的属性，则必须通过setter和getter方法设置和取得。

setter和和getter可以在eclipse上的源码选项中快速建立。

 

6，构造方法

构造方法用于程序的初始化和属性的初始化。

构造方法的声明需要遵守以下要点：

①构造方法必须与类名称一致。

②构造方法的声明处不能有任何返回值类型的声明。

③不能在构造方法中使用return返回值一个值。

 

构造方法定义格式：

 

class 类名称{

      访问权限 类名称（类型1 参数1，类型2 参数2，……）{

              程序语句；

             ……  //构造方法没有返回值

                     }

   }

 

7，this关键字

this关键字有以下作用：

①强调调用本类方法。

②表示类的成员属性（变量）。

③调用构造方法（需放在行首且不能循环调用）

④表示当前对象。

 

8，static关键字

如果使用static声明属性，则此属性称为全局属性（有些也可称为静态属性）。

当我们需要将大量对象的一个属性修改为同一个结果时，就可以用static将该属性改为公共属性。

类属性调用：

类名称.static 属性

 

使用static声明方法：

Static既可以在声明属性时使用，也可以用其来声明方法，用它声明的方法有时也被称为“类方法”，可以由类名称直接调用。

 

9，Java常用的内存区域：

①栈内存空间：保存所有的对象名称（保存了引用的堆内存空间的地址）

②堆内存空间：保存每个对象的具体属性内容。

③全局数据区：保存static类型的属性。

④全局代码区：保存所有的方法定义。

 

二，面向对象编程的基本知识点

 

1，String类

 

（1），String类的常见操作方法

方法	作用	语法示例	返回值
split()	拆分字符串	String.split(" ")	子串的数组
replace()	将匹配的子串替换为指定的字符串	String.replace("hi!","hello!")	替换后的字符串
search()	查找特定的文本段	String.search("hello")	子串在字符串中的第一次出现的位置； 未找到返回-1。
match()	匹配文本段	String.match("hello")	包含所有找到的匹配子串的数组
toUpperCase()	转大写	String.toUpperCase()	转换后的字符串
toLowerCase()	转小写	String.toLowerCase()	转换后的字符串
charAt()	获得指定位置的字符	String.charAt(0)	指定位置的字符
indexOf()	获取指定字符串首次出现的位置	String.indexOf("Hello")	字符串首次出现的位置
substring()	提取字符串	String.substring(startPos,stopPos)	提取到的字符串
substr()	提取指定长度的字符串	String.substr(startPos,length)	提取到的字符串
charCodeAt()	获得指定位置的字符的 Unicode 编码	"a".charCodeAt(0)	返回值是 0 - 65535 之间的整数

                                                                                  

（2），String对象的比较

通常有两种比较方法，用“==”或equals（）方法。两种方法的区别是：“==”比较双方的地址，equals（）方法比较双方的内容。当地址相同时，内容一定相同，而内容相同时，地址不一定相同。由于字符串的地址不好确定，所以当我们在对字符串进行比较时不要使用“==”比较，而是用equals（）方法比较。

 

（3），String类对象实例化方式的区别

String有两种实例化方式，一种是通过直接赋值，一种是使用标椎的new调用构造方法完成实例。两种方法的区别是：前者是在堆内存空间中开辟好的空间的使用权给了变量，后者是在堆内存中开辟新的空间并将使用权赋予对象。前者在空间利用率方面优于后者，因此教材建议我们对字符串的操作采用直接赋值的方式。

 

（4），字符串的内容不可改变

这是字符串特别重要的特性，字符串的内容一旦声明则不可改变。

我们在对一个String对象的内容进行的改变实际上是通过内存地址的“断开”和“连接”变化完成的，而字符串中的内容没有任何变化。

 

 

2，数组

（1），数组的声明

数据类型 数组名称[]=null;

数组名称=new 数据类型[长度];

 

（2），数组的静态初始化

数据类型 数组名[]={初值0，初值1，……，初值n};

 

3，包

包如同文件夹一样，可以将功能相似的类或接口组织在同一个包中。

语法格式：package pkg1[．pkg2[．pkg3…]];

 

 

 

 

 

4，继承

类的继承格式：

class（）父类{}       // 定义父类

 

class 子类 extends 父类{}  //使用extends关键字实现继承

 

子类可以继承父类中的操作，同时子类也可以定义自己的属性和方法。

一个父类可以有多个子类，但一个子类只能有一个父类。

子类可以直接使用父类中的非私有属性和方法，但是不能直接访问父类中的私有成员。

 

5，方法的覆写与重载

覆写是指子类定义了与父类中同名的方法，但方法的覆写必须考虑到权限。

即子类中覆写的方法权限必须大于或等于父类中的被覆写的方法的权限。

 

重载是指方法名称相同但参数的类型或个数不同的方法。

以下是重载与覆写的区别：

序号	区别点	重载	覆写
1	单词	Overloading	Overriding
2	定义	方法名称相同，参数类型或个数不同	方法名称，参数类型，返回值全部相同
3		对权限无要求	被覆写的方法不能拥有更严格的权限
4	范围	发生在一个类中	发生在继承类中

 

 

6，super关键字

使用super关键字可以从子类中调用父类中的构造方法，普通方法，属性。

this与super不能同时使用且this与super不能出现在主方法中。这是因为super和this的调用都必须出现在构造方法的首行。

以下是this与super的区别：

序号	区别点	this	super
1	属性访问	访问本类中的属性，如果本类没有此属性则从父类中继续查找	访问父类中的属性
2	方法	访问本类中的方法，如果本类中没有此方法，则从父类中继续查找	直接访问父类中的方法
3	调用构造	调用本类构造，必须放在构造方法的首行	调用父类构造方法，必须放在子类构造方法的首行
4	特殊	表示当前对象	无此概念

 

 

7，final关键字

在声明和使用final关键字需要注意一下几点;

① final声明的类不能有子类

② final声明的方法不能被子类覆写

③ final声明的变量即成为常量，常量不可以修改

 

8，抽象类

Java中有一种专门用来当做父类的类，这种类被称为抽象类。

 

抽象类的定义及使用规则如下：

① 包含抽象方法的类必须是抽象类；

② 抽象类和抽想方法都要使用abstract关键字声明；

③ 抽象方法只需声明而不需要实现；

④ 抽象类必须被子类继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法。

 

抽象类的定义就是比普通方法多了一些抽象方法，其他基本与普通方法一致。

抽象类不能使用final关键字声明。

抽象类中可以定义构造方法，但需要在子类引用super关键字，如果父类存在一个有参数的构造方法的话最好也再定义一个无参的构造方法。可以避免出错。

 

9，接口

接口是一种特殊的类，里面由全局常量和公共的抽象方法组成。

 

（1）接口的定义格式：

 

1 Interface 接口名称{

2

3        全局变量:

4

5        抽象方法;

6

7 }

 

 

 

（2）实现接口

接口的使用必须通过子类（或称为实现类，以下称为实现类），子类通过implements关键字实现接口。

 

1 class 实现类implements接口A，接口B,…… {

2

3 }

 

一个实现类可以同时实现多个接口，同时实现类也必须覆写完两个两个接口中的所有抽象方法。接口可以继承多个接口，但接口不能被多个实现类继承，接口也不能继承抽象类。

（3），接口与抽象类的实际应用

①抽象类实际应用——模板设计

②接口的实际应用——制定标准

 

10，object类的基本作用

Object是java中最为常见的一个系统程序类，object类可以实现参数统一。

 

（1）在java中所有的类都有一个公共的父类object类，一个类只要没有明显的继承一个类，则肯定是object类的子类。以下两代码的含义是一样的：

 

class  Person extends Object{}

class  Person{}

 

（2）Object类的主要方法

序号	方法名称	类型	描述
1	public Object()	构造	构造方法
2	public boolean equals(Object obj)	普通	对象比较
3	public int hashCode()	普通	取得Hash码
4	public String toSting()	普通	对象打印时调用

 

 

三，Java的实际运用

 

1，异常

   

（1），异常的基本概念

       异常是导致程序中断运行的一种指令流，如果不对异常进行正确的处理，可能会导致程序的中断执行。

 

（2），异常的处理方式

   异常通常有三种处理方式：①立刻处理  ②延后处理  ③不处理

   ①，②种方式都可以一定程度上的解决异常，而第③种则是在一些异常低概率出现的情况下进行的一种处理方式。有时如果异常出现的概率很低，且该异常处理起来极其麻烦，那么为了效率我们可以不对该异常进行处理。有时不处理异常也不失为一种有效的解决问题的方式。

 

（3），在程序中使用异常处理

   ①异常处理格式：

  

 

 1      try{

 2

 3        //有可能出现异常的语句

 4

 5        }catch(异常类 异常对象){

 6

 7            //编写异常的处理语句

 8

 9 }finally{

10

11     //一定会运行的程序代码

12

13 }

 

 

 

try用于捕获可能出现的异常代码，catch用于找到匹配的异常类型进行相应的处理。finally可作为异常的统一出口。注意，finally是可以省略的。

 

一个catch语句只能处理一种与之相配的异常处理类，因此我们可以直接使用所有异常类的父类Exception类作为异常处理类，这样就可以用一个catch处理所有类型的异常了。

 

（4），throws和throw关键字

   ①throws关键字

     在定义一个方法的时候可以使用throws关键字声明，使用throws关键字声明的方法表示此方法不处理异常，而交个方法的调用处进行处理。

       throws使用格式

     

1   public 返回值类型 方法名称(参数列表...)throws 异常类{}

 

    ②throw关键字

         与throws关键字不同，我们可以直接使用throw关键字抛出一个异常。抛出时直接抛出异常类的实例化对象即可。

 

（5），Exception类和RuntimeException类 

    （1）Exception在程序中必须使用try...catch进行处理

    （2）RuntimeException类可以不使用try...catch进行处理，但如果有异常产生，则异常将由JVM进行处理。

   

（6），自定义异常类

  

   我们定义自己的异常类时只需要让自定义的异常类成为Exception   RuntimeException类的子类即可。

 

 

2，多线程

       （1）线程与进程

      

 

 

 

 （2）线程的状态

 

  线程主要有五种状态，分别是：

 

①创建状态：在程序中用构造方法创建一个线程对象后，新的线程对象便处于新建状态。此时，它拥有对应的内存空间和其他资源，但还处于不可运行状态。

 

 

 

②就绪状态：新建线程对象后，调用该线程的start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待CPU服务。

 

 

 

③运行状态：当就绪状态的线程被调用并获得CPU资源时，线程进入运行状态。此时，自动调用该线程对象的run()方法。

 

 

 

④堵塞状态：一个正在执行的线程在某些特殊情况下，如果被人为挂起或需要执行耗时输入输出操作时，CPU会中断该线程的执行，进入堵塞状态。

 

 

 

⑤死亡状态：线程调用stop()或run()方法执行结束后，即进入死亡状态。

 

 

 

（3）线程操作的相关方法

 

static int activeCount() 
          返回当前线程的线程组中活动线程的数目。 
 void checkAccess() 
          判定当前运行的线程是否有权修改该线程。 
 int countStackFrames() 
          已过时。 该调用的定义依赖于 suspend()，但它遭到了反对。此外，该调用的结果从来都不是意义明确的。 
static Thread currentThread() 
          返回对当前正在执行的线程对象的引用。 
static void dumpStack() 
          将当前线程的堆栈跟踪打印至标准错误流。 
static int enumerate(Thread[] tarray) 
          将当前线程的线程组及其子组中的每一个活动线程复制到指定的数组中。 
static Map<Thread,StackTraceElement[]> getAllStackTraces() 
          返回所有活动线程的堆栈跟踪的一个映射。 
 ClassLoader getContextClassLoader() 
          返回该线程的上下文 ClassLoader。 
static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() 
          返回线程由于未捕获到异常而突然终止时调用的默认处理程序。 
 long getId() 
          返回该线程的标识符。 
 String getName() 
          返回该线程的名称。 
 int getPriority() 
          返回线程的优先级。 
 StackTraceElement[] getStackTrace() 
          返回一个表示该线程堆栈转储的堆栈跟踪元素数组。 
 Thread.State getState() 
          返回该线程的状态。 
 ThreadGroup getThreadGroup() 
          返回该线程所属的线程组。 
 Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() 
          返回该线程由于未捕获到异常而突然终止时调用的处理程序。 
static boolean holdsLock(Object obj) 
          当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。 
 void interrupt() 
          中断线程。 
static boolean interrupted() 
          测试当前线程是否已经中断。 
 boolean isAlive() 
          测试线程是否处于活动状态。 
 boolean isDaemon() 
          测试该线程是否为守护线程。 
 boolean isInterrupted() 
          测试线程是否已经中断。 
 void join() 
          等待该线程终止。 
 void join(long millis) 
          等待该线程终止的时间最长为 millis 毫秒。 
 void join(long millis, int nanos) 
          等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。 
 void resume() 
          已过时。 该方法只与 suspend() 一起使用，但 suspend() 已经遭到反对，因为它具有死锁倾向。有关更多信息，请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？。 
 void run() 
          如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。 
 void setContextClassLoader(ClassLoader cl) 
          设置该线程的上下文 ClassLoader。 
 void setDaemon(boolean on) 
          将该线程标记为守护线程或用户线程。 
static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) 
          设置当线程由于未捕获到异常而突然终止，并且没有为该线程定义其他处理程序时所调用的默认处理程序。 
 void setName(String name) 
          改变线程名称，使之与参数 name 相同。 
 void setPriority(int newPriority) 
          更改线程的优先级。 
 void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) 
          设置该线程由于未捕获到异常而突然终止时调用的处理程序。 
static void sleep(long millis) 
          在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。 
static void sleep(long millis, int nanos) 
          在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。 
 void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 

 
static void yield() 暂停当前正在执行的线程对象，并执行其他线程。

 

（4）java中线程的实现

       ①继承Thread类

    

 

 1  class 类名称 extends Thread{

 2

 3        属性...

 4

 5        方法...

 6

 7        public void run(){

 8

 9             线程主体;

10

11         }

12 }

 

 

注意：我们要想正确地启动线程，是不能直接调用run()方法的，而是直接调用从Thread类中继承而来的start()方法。

 

  （3）同步与死锁

          如果一个多线程的程序是通过Runable接口实现的，则意味着类中的属性将被多个线程共享。因此，如果多个线程要操作同一资源时，就有可能出现资源同步的问题。

          所谓同步，是指多个操作在同一个时间段内只能有一个线程进行，其他线程要等待此线程完成之后才可以继续执行。

         

       ①使用synchronized关键字实现同步

       

1   synchronized(同步对象){

2       需要同步的代码；

3 }

 

使用同步代码块时必须指定一个需要同步的对象，但一般都将当前对象(this)设置为同步对象。

②死锁

  所谓死锁，就是两个线程都在等待彼此先完成，造成程序的停滞状态。一般程序的死锁是在程序运行时出现。

通常多个线程共享同一资源时需要同步，但过多的同步操作则有可能会带来死锁问题。

 

3，File类

 

       （1）File类的主要介绍

 

              File类可以进行创建或删除文件等常用操作。

 

              File类的构造方法

 

        public File(String pathname)  //实例化File类时，必须设置好路径

 

 

 

       （2）File类的主要方法和常量

 

file.createNewFile()；     创建空文件    创建成功返回true 创建失败返回false

 

file.delete();     删除文件 删除成功返回true 删除失败返回false

 

file.exists();      判断文件或目录是否存在     存在返回true 不存在返回false

 

file.isFile(); 判断是否是文件    是文件返回true    不是文件返回false

 

file.isDirectory();     判断是否是目录    是目录返回true    不是目录返回false

 

file.getName(); 获取文件或目录的名称 返回String类型文件或目录的名称

 

file.getPath();  获取文件或目录的地址 返回String类型文件或目录的地址

 

file.getAbsolutePath();    获取文件或目录的绝对路径 返回String类型文件或目录的绝对路径

 

file.lastModified();   获取文件或目录的最后修改日期  返回long类型文件或目录的最后修改日期

 

file.length();    获取文件或目录的大小，单位为字符  返回int类型文件或目录的大小，单位为字符

 

 

（3）RandomAccessFile类

 

 

 

 

4，Java IO

（1）Java IO中常用的类：

 

类	说明
File	文件类
RandomAccessFile	随机存取文件类
InputStream	字节输入流
OutputStream	字节输出流
Reader	字符输入流
Writer	字符输出流

 

1)  字节流：数据流中最小的数据单元是字节
2)  字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。

在java中IO操作也是有相应步骤的，以文件的操作为例，主要操作流程如下：

①使用File类打开一个文件。

②通过字节流或字符流的子类指定输出的位置。

③进行读写操作。

④关闭输入/输出。

 

（2）字节流：主要是操作byte类型数据，以byte数组为准，主要操作类就是outputStream类和InputStream类。

OutputStream类的常用方法：

方法	方法介绍
public abstract void write(int b)	写入一个字节，可以看到这里的参数是一个 int 类型，对应上面的读方法，int 类型的 32 位，只有低 8 位才写入，高 24 位将舍弃。
public void write(byte b[])	将数组中的所有字节写入，和上面对应的 read() 方法类似，实际调用的也是下面的方法。
public void write(byte b[], int off, int len)	将 byte 数组从 off 位置开始，len 长度的字节写入
public void flush()	强制刷新，将缓冲中的数据写入
public void close()	关闭输出流，流被关闭后就不能再输出数据了

 

InputStream类的常用方法：

方法	方法介绍
public abstract int read()	读取数据
public int read(byte b[])	将读取到的数据放在 byte 数组中，该方法实际上是根据下面的方法实现的，off 为 0，len 为数组的长度
public int read(byte b[], int off, int len)	从第 off 位置读取 len 长度字节的数据放到 byte 数组中，流是以 -1 来判断是否读取结束的
public long skip(long n)	跳过指定个数的字节不读取
public int available()	返回可读的字节数量
public void close()	读取完，关闭流，释放资源
public synchronized void mark(int readlimit)	标记读取位置，下次还可以从这里开始读取，使用前要看当前流是否支持，可以使用 markSupport() 方法判断
public synchronized void reset()	重置读取位置为上次 mark 标记的位置
public boolean markSupported()	判断当前流是否支持标记流，和上面两个方法配套使用

 

（3）在程序中一个字符等于两个字节，java提供了Reader和Writer两个专门操作字符流的类。

Writer类的常用方法：

方法	方法介绍
public void write(char cbuf[])	写入一个字符数组
abstract public void write(char cbuf[], int off, int len)	从字符数组的 off 位置写入 len 数量的字符
public Writer append(CharSequence csq)	追加吸入一个字符序列
abstract public void flush()	强制刷新，将缓冲中的数据写入

Reader类的常用方法：

方法	方法介绍
public int read(java.nio.CharBuffer target)	读取字节到字符缓存中
public int read()	读取单个字符
abstract public int read(char cbuf[], int off, int len)	从 off 位置读取 len 长度的字符到 char 数组中
public boolean ready()	和上面的 available() 方法类似
public void mark(int readAheadLimit)	标记读取位置，下次还可以从这里开始读取，使用前要看当前流是否支持，可以使用 markSupport() 方法判断
abstract public void close()	关闭流释放相关资源

 

PS：字节流与字符流的区别：字节流直接操作文件，而字符流会先将数据放在缓存之后，再从缓存写入文件。

 

5，Java UI的相关知识点

 

（1），AWT  

AWT，抽象窗口工具包。被保存在java.awt包中。

AWT包中提供的所有工具类主要有以下三种：

（1）组件 （2）容器 （3）布局管理器

 

（2），Swing  

AWT大量地引用Windows函数，被称为重量级组件，但也因为大量的Windows函数，导致AWT很难在Windows以外的系统上使用，因此Java2中提供了轻量级的界面组件——Swing。

 

①基本容器JFrame

 

 

 

 

 

JFrame可用来创建窗体。

 

在JFrame中可以使用Dimension类设置窗体大小。Point类可以控制窗体的出现坐标。

 

 

 

 

 

 

 

 

 

 

 

②标签组件JLabel

JLabel组件表示的是一个标签，本身是用来显示信息的，一般情况下是不能直接更改其显示内容的。

JLabel可以创建文字和图片。根据不同的需要可以改变文字的字体。

 

 

 

 

 

③按键组件JButton

JButton组件表示一个普通的按钮，使用此类就可以直接在窗体中增加一个按钮。

 

④布局管理器

Swing中主要有五种布局管理器：①FlowLayout ②BorderLayout ③GridLayout ④CardLayout  ⑤绝对定位

 

1），FlowLayout：属于流式布局管理器，它可以让组件像流水一样依次进行排列。

2），BorderLayout：是将一个窗体的版面划分为东西南北中五个区域，可以将需要的组件放到这五个区域中。BorderLayout非常实用，因为大部分软件都是这种类似的排版。

3），GridLayout：它可以将组件按表格的形式进行管理，在使用此布局管理器的时候必须设置显示的行数和列数。

4），CardLayout：它可以将一组组件彼此重叠地进行布局，就像一张张卡片一样，每次只会展现一个界面。

5），绝对定位：如果不想在窗体中指定布局管理器，也可以通过设置绝对坐标的方式完成布局。

（3）事件和监听器：

       事件是指一个对象发生状态变化，监听器则是不断监听事件变化，并根据这些事件进行相应地处理。如果没有能够接收和处理事件的对象，图形界面程序所发生的一切事件都是无用的。

       值的注意的是，所有监听器都是以接口的形式实现的。为了减少不必要的代码，我们在使用监听器的时候，通常都使用对应的监听适配器。

 

①，窗体事件

       WindowListener是专门用来处理窗体事件的监听接口，一个窗体的所有状态变化，如窗口打开与关闭、缩小与最大化等都可以用这个接口进行监听。

 

②，动作事件

       动作事件可以使按钮变得有意义，在Swing中，可以使用ActionListener接口处理按钮的动作事件。由于ActionLIstener接口定义了一个方法，因此没有对应的监听适配器。

 

③，键盘事件

        使用KeyListener接口可以对键盘的操作进行监听。详见书本p684-685

。

④，鼠标事件

        使用MouseMotionListener可以对鼠标的拖拽操作进行监听。

 

（4），菜单组件

       （1）JMenu和JMenuBar

              ①JMenu的常用方法：

 

 

 

 

 

              ②JMenuBar的常用方法：

 

 

 

 

 

 

 

       （2）JMenuItem

              JMenuItem可以用于在菜单内创建菜单项。

              （1）JMenuItem类的常用方法：

 

 

 

（3），事件处理

JMenuItem和JMenuBar都是AbstractButton类的子类，所以事件处理的机制是完全一样的。

 

 

个人感想：

本学期的Java的学习结束了，我认为自己在本学期的java学习态度方面比以前要好，课余在java上花费的学习时间也比较多，在完成老师布置的作业后也会抽空去复习往期学习的代码。但缺点也很明显，比如：（1）在学习时出现难懂的问题时大多都没有立刻解决，而是搁置不管，而且解决的问题也没有建立一个错题集去总结。（2）在复习老师上课演示的代码时由于没有做详细的笔记，导致经常会忘，降低了复习效率（这个毛病一直到期末才解决，方法很简单，用手机把代码拍下来就好了...）。（3）上课的时候偶尔会走神。

总而言之，学习态度比刚进入大学时的自己要更认真，但是学习的方法还很笨拙，就是反复操练学过的东西，也没有做出出色的成绩。因此，学无止境，我需要继续保持这样的学习态度，并且吸取教训，争取以更好的姿态去迎接下一个学期的java学习。