java学习笔记.docx

java学习笔记.docx

《java学习笔记.docx》由会员分享，可在线阅读，更多相关《java学习笔记.docx（25页珍藏版）》请在冰点文库上搜索。

java学习笔记

目录

接口1

多态性1

抽象类和接口的实现2

Object类2

包装类3

匿名内部类3

异常的基本概念3

异常的其他概念5

包的定义和导入6

访问控制权限及命名规范7

多线程8

线程常用操作方法9

线程的操作规范11

同步和死锁11

线程的生命周期12

泛型入门12

通配符13

泛型的其他应用14

Java常用类库15

StringBuffer15

Runtime类16

国际化程序17

System类18

日期操作类19

Math和Random类19

NumberFormat类20

接口

接口的定义格式：

Interface接口名称{全局常量；抽象方法；}

1.接口的所有访问权限都是public

2.接口的使用中必须有子类，子类必须重新写抽象方法，implements关键字实现。

一个子类可以实现多个接口，则子类不是抽象类的话，肯定要覆写接口中全部的抽象方法。

3.一个子类可以同时继承抽象类和实现接口。

格式如下：

Class子类extends抽象类implements接口A,接口B,….{};

4.一个接口不能继承一个抽象类。

但是却可以通过extends关键字同时继承多个接口，实现接口的多继承。

格式：

Interface子接口extends父接口A，父接口B，….{}

5.接口是一个特殊的类，只包含全局常量和抽象方法

接口中的抽象方法可以不加入abstract而抽象类中的抽象方法中必须有abstract关键字声明。

多态性

1.向上转型：

通过其子类进行父类对象的实例化操作的，则如果调用的方法被子类覆写过，则肯定调用被覆写过的方法。

转型之后，因为操作的是父类的对象，所以无法找到子类中定义的新方法。

2.向下转型：

将父类对象变成子类对象，称为向下转型，向下转型需要采用强制的手段。

但在进行对象向下转型操作的时候有一个注意点：

如果想要产生对象的向下转型，则肯定必须先产生一个向上转型的关系“Aa=newB（）”表示建立关系

Instanceof关键字

1.在java中使用instanceof关键字判断一个对象是哪个类的实例

对象instanceof类---返回Boolean类型

2.在开发中一定要注意，对于向下转型操作最好增加验证，以保证转型时不会发生ClassCastException.

3.在程序开发中重点的设计应该放在父类上，只要父类设计的足够合理，则开发肯定会非常的方便，而且在开发中一定记住：

一个类永远不要去继承一个已经实现好的类，而只能继承抽象类或实现接口。

抽象类和接口的实现

1，之所以抽象类和接口不能实例化，是因为其内部包含了各个抽象方法，抽象方法本身都是为、未实现的方法所以不能调用。

2.通过对象的多态性可以发现，子类发生了向上转型关系后，所调用的全部方法都是被覆写过得方法。

3.对java程序来说，如果一个类要实现一个接口，则肯定要覆写次接口当中的全部抽象方法，如果一个接口中的定义的抽象方法过多，但是在子类中又用不到这么多抽象方法，则肯定很麻烦，所以此时就需要一个中间的过度，但是此过度类又不希望被直接使用，所以将此过度类定义成抽象类最合适，即一个接口首先被一个抽象类（适配器），并在此抽象类中实现若干方法，则以后的子类直接继承此抽象类，就可以有选择的覆写所需要的方法。

4.一个抽象类中可以包含一个接口，反之，一个接口也可以定义一个抽象类

5.在开发中，一个类永远不要去继承一个已经实现好的类，要么继承抽象类，要么实现接口，如果接口和抽象类同时都可以使用的话，那么优先使用接口，避免单继承局限。

Object类

1.如果一个类在定义时没有明确指明继承哪一个类则默认继承了Object类。

ClassAextendsObject{}

2.Object中的主要方法：

PublicObject（）构造方法

PublicBooleanequals（Objectobj）对象比较

PublicinthashCode（）取得Hash码

PublicStringtoString（）对象打印时调用

3.ToString（）方法是主动调用的

包装类

1.

匿名内部类

1.内部类：

在一个类的内部还有另一个类成为内部类，那么匿名内部类，如果一个类在整个操作中只使用一次的话，就可以将其定义为匿名内部类，匿名内部类是在抽象类及接口的基础上发展起来的。

异常的基本概念

1.异常是导致程序中断运行的一种指令流，如果不对异常进行正确的处理，则可能导致程序的中断的执行，造成不必要的损失，所以在程序的设计中必须要考虑各种异常的发生，并正确的做好相应的处理，这样才能保证程序的正常的执行。

2.一旦发生异常后，异常之后的语句不会执行，而是直接结束程序，并将错误报告给用户。

在计算机发展史中有两大杀手：

断电和被除数为0。

3.异常的处理

4.异常：

数组超出绑定ArrayIndexOutofBoundsException

数字格式化异常：

NumberFormatException

算数异常：

ArithmeticException

5.异常类的继承结构

在整个java的异常结构中，实际上有一下两种最常用的类：

Exception和Error，这两个类都是Throwable的子类

Exception：

一般表示的是程序中出现的问题，可以直接使用try….catch处理

Error:

一般指JVM错误，程序中无法处理

一般在输出异常信息的时候，可以直接使用System.out.println（）打印异常信息，也可以通过Exception提供的一个方法：

publicvoidprintStackTrace（）;

6.Java异常处理的机制

在Java的异常处理中，实际上也是按照面向对象的方式进行处理，处理的步骤如下：

一旦发生异常，则首先会产生一个异常类的实例化对象。

在try语句中对此异常对象进行捕捉；

产生的异常对象与catch语句中的各个异常类型进行匹配，如果匹配成功，则执行catch语句中的代码

7.如果出现一些其他的异常无法知道的话，则可以最后使用Exception进行捕捉。

注：

在处理异常中，捕捉更粗的异常要放在捕捉更细的异常之后。

8.当所有的异常处理的方式是一样的时候就可以直接使用Exception进行捕捉，然而，在一个比较细致的开发中是不建议这样使用的，所有的异常最好分别捕捉。

异常的其他概念

1.throws关键字

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

Throws的使用格式public返回值类型方法名称（参数列表….）throws异常类{}

2.throw关键字

Throw关键的作用是在程序中抛出一个异常。

抛出的时候抛出的是一个异常类的实例化对象。

3.Exception和RuntimeException的区别

Exception在程序中是必须使用try….catch进行处理的

RuntimeException可以不使用try…..catch进行处理，但是如果产生异常，则异常由JVM进行处理。

4.自定义异常类

只需要继承Exception就可以完成自定义异常类。

因为在Java中提供的都是标准的异常类（包括一些异常信息等等），如果需要定义自己想要的异常信息的时候就可以自定义异常类。

ClassMyExceptionextendsException{}

5.断言（assert）

就是断定某一个操作的结果肯定是正确的，如果程序执行到出现断言语句的时候发现结果不正确了，则会出现错误的信息。

定义的格式;

assertBoolean表达式

assertboolean表达式：

详细信息；

断言在实际开发中并不常见。

包的定义和导入

1.包的定义

格式：

package包名称.子类的名称；

定义包之后，实际上类的名称就是：

包.类名称。

所谓的包实际上就是一个文件夹，一个*.class文件要保存在的一个文件夹之中。

既然包本省就是一个文件夹，所以在Java的编译指令中就提供了专门的打包编译命令，在编译的时候加上参数。

打包编译：

javac–dA.java生成完*.class之后，就可以直接访问了

2.包的导入

Import语句

语法：

import包名称.子包名称.类名称;--------------手工导入所需要的类

Import包名称.子包名称.*;--------------------JVM自动加载所需要的类

3.class和publicclass

如果一个类需要被外包所访问。

则此类一定要定义成publicclass，而且一般在开发中对于一个*.java文件中往往都是之定义一个类：

publicclass。

如要导入一个包中的许多类。

可以直接使用“*”的方式进行导入。

4.系统常见的包

5.jar的使用

使用jar.exe可以讲所有的类文件进行压缩。

Jar命令的主要参数：

“C”：

创建新的文档

“V”：

生成详细的输出信息

“F“：

指定存档的文件名

访问控制权限及命名规范

1.访问控制权限

Java中存在四种访问权限：

private，default，public，protected。

2.Java命名规范

类：

所有的单词首字母大写

方法：

第一个单词的首字母小写，之后每个单词的首字母大写。

属性：

第一个单词的首字母小写，之后的每一个单词的首字母大写

包：

所有的单词的字母都是小写

常量：

多有的单词的字母都是大写

多线程

1.Java中多线程的实现

两种方式：

继承Thread，实现Runnable接口；

2.继承Thread类

Thread类是在java.lang包中定义的，一个类只要继承了Thread类，此类就称为多线程操作。

在thread子类之中，必须明确的覆写Thread类中的run（）方法，此方法为线程的主体。

多线程额定义语法：

3.Runnable接口

在java中可以通过实现Runnable接口的方式实现多线程，Runnable接口中之定义一个抽象类：

publicvoidrun（）；

4.Thread和Runnable的区别

使用Thread类在操作多线程的时候无法达到资源共享的目的，二而使用Runnable接口实现的多线程可以实现资源的共享。

实现Runnable接口比继承Thread类有如下明显的优势：

适合多个相同程序代码的多线程去处理同一个资源

可以避免由于单继承局限所带来的影响

增强了程序的健壮性，代码能够被多个程序共享，代码与数据是独立的

在开发中使用Runnable接口是最合适的

线程常用操作方法

1.取得和设置线程名称

在Thread类中，可以通过getName（）方法取得线程的名称，通过setName（）方法设置线程的名称。

线程的名称一般在启动线程前设置，但也允许为已经执行的线程设置名称。

允许两个Thread对象有相同的名字。

但为了清晰，因避免这种情况的发生。

另外，如果程序并没有为线程指定名称，则系统会自动的为线程分配一个名称。

No.

方法名称

类型

描述

1

PublicTread（Runnabletarget）

构造

接受Runnable接口的子类对象，实例化Thread对象

2

PublicThread（Runnabletarget,Stringname）

构造

同上，并设置线程名称

3

PublicThread（Stringname）

构造

实例化thread对象，并设置线程名称

4

PublicstaticThreadcurrentThread（）

普通

返回目前正在执行的线程

5

PublicfinalStringgetName（）

普通

返回线程的名称

6

PublicfinalintgetName（）

普通

发挥线程的优先级

7

PublicbooleanisInterrupted（）

普通

判断目前线程是否被终端，如果是返回true

8

PublicfinalBooleanisAlive（）

普通

判断线程是否在活动，如果是返回true

9

Publicfinalvoidjoin（）throwsInterruptedException

普通

判断线程死亡

10

普通

11

PublicfinalvoidsetName（）

普通

设置线程名称

12

Publicvoidrun（）

普通

执行线程

13

普通

14

Publicstaticvoidsleep（longmillis）throwsInterruptedException

普通

目前正在执行的线程休眠millis毫秒

15

Publicvoidstart（）

普通

开始执行线程

16

Publicstaticvoidyield（）

普通

将正在执行的线程暂停，允许其他线程执行

17

PublicfinalvoidsetDaemon（Booleanon）

普通

将一个线程设置成后台执行

18

普通

2.取得当前线程

程序可以通过currentThread（）方法取得当前正在运行的线程的对象。

3.判断线程是否启动

4.线程的强制运行

在线程操作中，可以使用join（）方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行

5.线程的休眠

直接使用Thread.sleep（）方法

6.线程的中断

通过interrupt（）方法

7.后台线程

在java中，只要一个程序没有执行完，则整个java的进程不会消失，所以此时可以设置一个后台线程，这样即使java进程结束了，此后台线程依然会继续执行

直接调用setDeamon（）;

8.线程的优先级

线程的操作规范

同步和死锁

1.同步代码块

代码块分为四种：

普通代码块：

是直接定义在方法中的

构造快：

是直接定义在类中的，优先于构造方法执行，重复调用

静态块：

是使用static关键字声明的，优先于构造块执行，只执行一次

同步代码块：

使用synchronized关键字声明的代码块，称为同步代码块

同步代码块的格式：

synchronized（同步对象）{

需要同步的代码

}

2.同步方法

格式：

synchronized方法返回值方法名称（参数列表）{}

3.Object类对线程的支持——等待和唤醒

Object类是多有类的父类，在此类中有一下几个方法是对线程操作有所支持的

唤醒现在有来那个·两个方法：

notify和notifyAll。

一般来说，所有等待的线程会按照顺序进行排列，如果现在使用notify（）方法的话，则会唤醒第一个等待的线程执行，二如果使用notifyAll（）方法，则会唤醒所用的等待线程，那个线程的优先级高，那个线程就有可能先执行。

线程的生命周期

1.一个线程创建之后通过start（）方法进入到运行状态，在运行状态中可以使用yield（）进行礼让，但是仍然可以进行，如果现在一个线程需要暂时停止的话，可以使用suspend（）、sleep（）、wait（）。

如果现在线程不需要再执行则可以通过stop结束，或者一个新的线程直接调用stop（）方法进行结束以上有如下几个方法：

suspend（）：

暂挂起线程

resume（）：

回复挂起线程

stop（）：

停止线程

因为以上的三个方法会产生死锁的问题，所以现在已经不再建议使用了。

如果现在假设要停止一个线程的运行如何去做呢？

通过设置标位，让线程停止运行

泛型入门

1.泛型可以解决数据类型的安全性的问题，他主要的原理，是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。

这样在类声明或者实例化的时候只要指定好需要的类型即可。

泛型类的定义格式：

【访问权限】class类名称<泛型类1,泛型类2….泛型类3>{

[访问权限]泛型类型标识变量名称；

[访问权限]泛型类标识方法名称（）；

[访问权限]返回值类型声明方法名称（泛型类型标识变量称）；

}

泛型对象的定义

类名称<具体类>对象名称=new类名称<具体类>（）;

G

2.泛型类的构造方法

构造方法可以为类中的属性初始化，那么如果类中的属性通过泛型指定，而又需要通过构造设置属性内容的时候，那么构造方法的定义与之前并无不同，不需要想声明类那样指定类型。

使用格式：

[访问权限]构造方法（[<泛型类型>参数名称]）{}

3.泛型的警告

在泛型应用中最好在声明类的时候指定好其内部的数据类型，例如：

Info，但是也可以不指定类型，这样一来用户在使用这样的类的时候，就会出现不安全的警告信息。

通配符

1.匹配任意类型的通配符

在开发中对象的引用传递是最常见的，但是如果在泛型类的操作中，在进行引用传递的时候泛型类型必须匹配才能传递，否则是无法传递的。

在使用

>只能接受，但不能修改

2.受限泛型

之前设置泛型类型的时候，实际上都是可以任意设置的，只要是类就可以设置。

但是在Java中的泛型中可以指定一个泛型的上限和下限。

范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。

而范围下限使用super进行声明，表示参数化的类型可能是指定的类型，或者是此类型的父类型，直至Object类。

3.在泛型中，子类的泛型类型是无法使用父类的泛型类型接受的，例如Info不能使用Info