java.docx

java.docx

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

java

一次编译多次执行（JVM）

垃圾回收

.java文件名和public的类名相同

类体与方法体

只包含一个public的类

non-public的类可以有多个

Publicstaticvoidmain（String[]args）程序入口或开始点

Main（）主方法唯一

main（）method之前必须加上publicstaticvoid这三个标识符。

public代表main（）公有的method；

static表示main（）在没有创建类对象的情况下，仍然可以被运行；

void则表示main（）方法没有返回值。

Main后的括号（）中的参数Stringargs[]表示运行该程序时所需要的参数

标示符规则

不能以数字开头

不能使用关键字

Java中的保留关键字：

abstractbooleanbreakbytecasecatchcharclasscontinuedefaultdodoubleelseextendfalsefinalfinallyfloatforifimplementimportinstanceofintinterfacelongnativenewnullpackageprivateprotectedpublicreturnshortstaticsynchronizedsuperthisthrowthrowstransient

truetryvoidvolatilewhile

gotoconst

System.out是指标准输出，通常与计算机的接口设备有关，如打印机、显示器等。

其后所连接的println，是由print与line所组成的，意义是将后面括号中的内容打印在标准输出设备——显示器上

溢出

Java所使用的就是Unicode字符码系统

三大控制语句：

顺序

选择（if，switch）

循环（while，dowhile，for，）

循环跳离

continue，中断本层循环，执行下次循环

goto，

break，中断循环，执行循环体后面的语句

局部变量

数组

1.声明2.分配内存

Intscore[]=newint[3];

元素索引

Java中获取数组长度，score.length

与数组有关的API方法

拷贝arrayCopy（）;

排序sort（）;

二维数组

与一维数组不同的是，二维数组在分配内存时，必须告诉编译器二维数组行与列的个数。

Intscore[][]=newint[4][3];//分配内存空间

数组名.length//取得数组的行数

数组名[行的索引].length//取得特定行元素的个数

传递一维数组

传递二维数组

返回一维数组前加int[]；

返回二维数组前加int[][]；

方法重载

方法的重载就是在同一个类中允许同时存在一个以上的同名方法，只要它们的参数个数或类型不同即可。

对象特征

静态特征属性

动态特征方法

类

类是一个抽象的概念，要利用类的方式来解决问题，必须用类创建一个实例化的类对象，然后通过类对象去访问类的成员变量，去调用类的成员方法来实现程序的功能。

封装信息隐藏

从程序设计角度来说，一般说来设计较好的程序的类中的属性都是需要封装的。

此时，要设置或取得属性值，则只能用setXxx（）、getXxx（）方法，这是一个明确且标准的规定。

当然，可以把方法设置为private，但是只能在类的内部访问，

如果要在外面进行访问，必须在类内部定义公有方法访问。

继承重用性

多态方法重载成员覆盖

类对象实例化（new）

引用数据类型

//将p1的引用赋给p2

p2=p1;

垃圾对象，指程序中不再使用的对象引用

匿名对象

没有明确声明的对象

只使用一次的对象，或没有任何一个具体的对象名称引用它

构造方法

帮助新创建的对象赋初值

与类同名

无返回值

在创建对象时，自动调用

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

{

程序语句；

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

}

构造方法重载（参数不同）

如果不存在自定义的构造函数，那么系统调用无参构造函数，如果调用错误，将无法通过编译。

对象比较

有两种方式可用于对象间的比较，它们是“==”运算符与equals（）方法。

“==”操作符用于比较两个对象的内存地址值是否相等

equals（）方法用于比较两个对象的内容是否一致

str1.equals（str2）；

Stringstr1="java";

Stringstr2=newString（"java"）;

Stringstr3="java";

str1str3指向同一块内存空间，str2是有new关键字分配的，单独占有一个内存空间。

直接赋值进行初始化比较好

This关键字

用this调用构造方法

This（）;

Static关键字

静态变量——类变量。

修饰类的属性，该属性为公共属性，是所有对象共享的内存空间，可以用其中的一个对象进行修改，也可以用类名进行修改。

静态方法——类方法

privatestaticStringcity="china";对于静态的属性，需要一个公有的静态方法去修改。

如：

publicstaticvoidsetcity（Stringc）

如果在类中声明了一个static类型的属性，则此属性既可以在非static类型的方法中使用，也可以在static类型的方法中使用。

但用static类型的方法调用非static类型的属性时，则会出现错误。

Main方法

01publicclassTestMain

02{

03/*

04public：

表示公共方法

05static：

表示此方法为一静态方法，可以由类名直接调用

06void：

表示此方法无返回值

07main：

系统定义的方法名称

08Stringargs[]：

接收运行时参数

09*/

10publicstaticvoidmain（String[]args）

11{

12//取得输入参数的长度

13intj=args.length;

14if（j!

=2）

15{

16System.out.println（"输入参数个数有错误！

"）;

17//退出程序

18System.exit

（1）;

19}

20for（inti=0;i

21{

22System.out.println（args[i]）;

23}

24}

25}

静态代码块

被率先执行

static

{

System.out.println（"2.Person类的静态代码块被调用！

"）;

}

与静态方法的区别：

一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的；

需要在项目启动的时候就初始化，在不创建对象的情况下，其他程序来调用的时候,需要使用静态方法，这种代码是被动执行的。

静态方法在类加载的时候就已经加载可以用类名直接调用比如main方法就必须是静态的，这是程序入口

两者的区别就是；静态代码块是自动执行的;静态方法是被调用的时候才执行的；

构造方法的私有

方法依需要，可分为public与private。

同样的，构造方法也有public与private之分。

到目前为止，所使用的构造方法均属于public，它可以在程序的任何地方被调用，所以新创建的对象也都可以自动调用它。

如果构造方法被设为private，则无法在该构造方法所在的类以外的地方被调用。

构造方法虽然被私有了，但并不一定是说此类不能产生实例化对象，只是产生这个实例化对象的位置有所变化，即只能在本类中产生实例化对象。

对象数组

Personp[]=newPerson[3];

p[0]=newPerson（"Gaoqi",23）;

p[1]=newPerson（"wang",14）;

p[2]=newPerson（"wulin",28）;

内部类

内部类可声明成public或private。

当内部类声明成public或private时，对其访问的限制与成员变量和成员方法完全相同。

可以发现由于使用了内部类操作，所以程序在调用score属性的时候减少了创建对象的操作，从而省去了一部分的内存开销，但是内部类在声明时，会破坏程序的结构，在开发中往往不建议读者去使用。

外部类是无法找到内部类中所声明的属性。

而内部类则可以访问外部类的属性。

在类外部引用内部类

在方法中定义内部类

javadoc标记

范例：

PersonJavaDoc.java

/**

*Title:

PersonJavaDoc

*Description:

通过PersonJavaDoc类来说明Java中的文档注释

*Copyright:

（c）2004

*Company:

sunjava

*@authorlixinghua

*@version1.00

*/

类的继承

在java中只允许单继承，不允许多重继承

子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用本类中的相应构造方法。

如果父类中存在自定义的构造函数，那么，系统不会自动生成无参的构造函数，那么子类在创建对象时，就会出错；所以，就需要在父类中添加一个无操作的无参的构造函数。

Super关键字

super主要的功能是完成子类调用父类中的内容，也就是调用父类中的属性或方法。

程序在编译时不再去找父类的无参构造函数了。

用super调用父类中的构造方法，只能放在程序的第一行。

当然，也可以用super调用父类中的属性。

classStudentextendsPerson

{

Stringschool;

publicStudent（Stringn,inta,Strings）

{

super.name=n;

super.age=a;

System.out.println（say（））;

this.school=s;

}

}

父类的属性，方法限制子类访问

Private

子类在继承父类时，会继承父类中的全部的属性与方法。

复写

当一个子类继承一父类，而子类中的方法与父类中的方法的名称，参数个数、类型都完全一致时，就称子类中的这个方法复写了父类中的方法。

同理，如果子类中重复定义了父类中已有的属性，则称此子类中的属性复写了父类中的属性。

抽象类

abstractclassPerson

专门用来当作父类，不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。

可以有抽象方法，也可以有非抽象方法。

抽象类定义规则

·抽象类和抽象方法都必须用abstract关键字来修饰。

·抽象类不能被实例化，也就是不能用new关键字去产生对象。

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

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

在抽象类中，也可以拥有构造方法，但是这些构造方法必须在子类中被调用。

在抽象类定义的语法中，方法的定义可分为两种：

一种是一般的方法，它和先前介绍过的方法没有什么两样；另一种是“抽象方法”，它是以abstract关键字为开头的方法，此方法只声明了返回值的数据类型、方法名称与所需的参数，但没有定义方法体。

那么子类中需要复写实现这个抽象方法。

publicabstractStringtalk（）;//只有声明，没有函数体，在子类中复写

与一般类相同，在抽象类中，也可以拥有构造方法，但是这些构造方法必须在子

类中被调用。

Object类

所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类就默认继承Object类。

Final关键字

1、final标记的类不能被继承。

2、final标记的方法不能被子类复写。

3、final标记的变量（成员变量或局部变量）即为常量，只能赋值一次。

接口interface

接口（interface）是Java所提供的另一种重要技术，它的结构和抽象类非常相似，具有数据成员与抽象方法，

1、接口里的数据成员必须初始化，且数据成员均为常量，且不可更改。

2、接口里的方法必须全部声明为abstract，也就是说，接口不能像抽象类一样保有一般的方法，而必须全部是“抽象方法”。

在java中接口是用于实现多继承的一种机制，也是java设计中最重要的一个环节，每一个由接口实现的类必须在类内部复写接口中的抽象方法，且可自由地使用接口中的常量。

既然接口里只有抽象方法，它只要声明而不用定义处理方式，那么无法用它来创建对象。

利用接口打造新的类的过程，称之为接口的实现（implementation）。

InterfacestudentextendsPerson

接口是java实现多继承的一种机制，一个类只能继承一个父类，但如果需要一个类继承多个抽象方法的话，就明显无法实现，所以就出现了接口的概念。

一个类只可以继承一个父类，但却可以实现多个接口。

接口与一般类一样，均可通过扩展的技术来派生出新的接口。

原来的接口称为基本接口或父接口，派生出的接口称为派生接口或子接口。

通过这种机制，派生接口不仅可以保留父接口的成员，同时也可加入新的成员以满足实际的需要。

接口间的继承通过关键字extends实现。

接口可以继承多个接口，

一个类可以实现多个接口，接口间用“,”隔开，且需要复写所有接口的全部抽象方法。

如下：

classstudentimplementsPerson,Person1

{

publicStringsay（）

{

return"复写接口person的abstract方法say（）";

}

publicStringsay1（）

{

return"复写接口person1的abstract方法say1（）";

}

}

对象多态性

子类实例化对象可以转换为父类实例化对象

向上转型，父类对象通过子类对象去实例化。

向下转型，父类的对象可以转换为子类对象，这时则必须要进行强制的类型转换。

一、向上转型可以自动完成；用子类实例化时，调用子类和父类相同的函数时，先调用子类的；如果调用只有父类的函数时，则显示父类的函数。

publicstaticvoidmain（String[]args）

{

Personp=newstudent（）;

p.fun1（）;

p.fun2（）;

}

二、向下转型必须进行强制类型转换，

publicstaticvoidmain（String[]args）

{

Personp=newstudent（）;

students=（student）（p）;

s.fun1（）;

s.fun3（）;

}

instanceof关键字的使用

用于判断一个类是否实现了某个接口，也可以用它来判断一个实例对象是否属于一个类。

instanceof的语法格式为：

对象instanceof类（或接口）

它的返回值是布尔型的，或真（true）、或假（false）。

接口对象的实例化

接口是可以被实例化的，但是不能被直接实例化，通过接口的子类对其进行实例化。

classstudentimplementsPerson

Personp=newstudent（）;

使用接口就是定义一个统一的标准。

例如：

interfaceUSB

{

publicabstractvoidstart（）;

publicabstractvoidstop（）;

}

classMP3implementsUSB

{

publicvoidstart（）

{

System.out.println（"MP3devicestart"）;

}

publicvoidstop（）

{

System.out.println（"MP3devicestop"）;

}

}

classMoveDiskimplementsUSB

{

publicvoidstart（）

{

System.out.println（"MoveDiskdevicestart"）;

}

publicvoidstop（）

{

System.out.println（"MoveDiskdevicestop"）;

}

}

classcomputer

{

publicvoidwork（USBu）

{

u.start（）;

u.stop（）;

}

}

publicclassinterfacestandard

{

publicstaticvoidmain（String[]args）

{

newcomputer（）.work（newMP3（））;

newcomputer（）.work（newMoveDisk（））;

}

}

异常处理

异常处理方法

1交由java默认的异常处理机制做处理，这种方法只输出异常信息，并终止程序。

2自行编写异常处理模块。

异常类的继承架构

Exception类扩展出数个子类，其中IOException、RunntimeException是较常用的两种。

RunntimeException即使不编写异常处理的程序代码，依然可以编译成功，而这种异常必须是在程序运行时才有可能发生。

IOException一定要编写异常处理的程序代码才行，它通常用来处理与输入/输出相关的操作，如文件的访问、网络的连接等。

抛出异常throw

抛出异常有下列两种方式：

1、程序中抛出异常

2、指定方法抛出异常

包及访问权限

包（package）

Package名称；

定义了包以后，执行程序有一定的变动。

如下：

javac–d.package1.java//生成一个demo文件夹

javademo.java.package1

import语句的使用

如果几个类分别属于不同的package时，在某个类要访问到其它类的成员时，则必须做下列的修改：

若某个类需要被访问时，则必须把这个类公开出来，也就是说，此类必须声明成public。

若要访问不同package内某个public类的成员时，在程序代码内必须明确地指明“被访问package的名称.类名称”。

importpackage名称.类名称；

将某个package内的整个类导入，后续访问时就不需要再写包名称了。

在java中有这样的规定：

导入全部类或是导入指定的类，对于程序的性能是没有影响的。

importdemo.java.a.Person改成importdemo.java.a.*，

JDK中常见的包

java.lang—包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能

java.awt—包含了构成抽象窗口工具集（abstractwindowtoolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）。

javax.swing—此包用于建立图形用户界面。

java.applet—包含applet运行所需的一些类。

—包含执行与网络相关的操作的类。

java.io—包含能提供多种输入/输出功能的类。

java.util—包含一些实用工具类，如定义系统特性、与日期日历相关的函数。

类成员的访问控制权限

Private只能在类内部访问

Public

Protect

默认访问权限default默认的访问控制成员可以被这个包中的其它类访问。

如果一个子类与其父类位于不同的包中，子类也不能访问父类中的默认访问控制成员。

命名习惯

◆包名中的字母一律小写，如：

demo.java。

◆类名、接口名应当使用名词，每个单词的首字母大写，如：

TestPerson。

◆方法名，第一个单词小写，后面每个单词的首字母大写，如：

talkMySelf。

◆常量名中的每个字母一律大写，如：

COUNTRY。

多线程

进程一次性执行完毕原子性动态执行

多进程操作系统能同时运行多个进程，cpu具有分时机制，所以每一个进程都能循环获得分配给自己的时间片。

线程（Thread）比进程更小的执行单位，可以在进程内部同时执行。

实现并发程序控制

单一线程

多线程

通过继承Thread类来实现。

通过实现Runnable接口实现多线程

Thread类也是Runnable接口的一个子类，但其无法实现资源共享。

但是Runnable接口实现的子类可实现。

一个类继承了Thread类后，该类的一个对象无论调用多少次start（）方法，都只有一个线程在运行。

如果运行多个线程对象的start（）方法，就会相应的执行多少个线程，而且，这些线程独占各自的资源。

实现Runnable接口的类，启动多个线程对象，操作的是同一个资源，实现了资源共享。

Thread类

Runnable接口

一个线程对象.start（）方法

多个线程对象.start（）方法

多个资源

一个资源

占用资源

独占

共享

可见，实现Runnable接口相对于继承Thread类来说，有如下显著的优势：

（1）、适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码、数据有效分离，较好地体现了面向对象的设计思想。

（2）、可以避免由于Java的单继承特性带来的局限。

开发中经常碰到这样一种情况，即：

当要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么就只能采用实现Runnable接口的方式了。

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

当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。

多个线程可以操作相同的数据，与它们的代码无关。

当共享访问相同的对象时，即共享相同的数据。

当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。

事实上，几乎所有多线程应用都可用第二种方式，即实现Runnable接口。

线程状态

五种状态：

创建Threadth=newThread（）;

就绪调用start（）方法，启动线程，此时线程进入就绪状态，等待CPU的调度；

运行自动调用线程对象的run（）方法，run（）定义了线程的操作和功能；

阻塞一个正在运行的线程，在某些情况下