Java面向对象编程基础

第3章Java面向对象编程基础3.1Java的类3.2创建Java自定义类的方法3.3Java的非访问控制符3.4Java的访问控制符3.5定义和使用Java的方法学习要点：1.理解Java包中类的基本概念，掌握定义Java类和创建对象的方法2.掌握构造函数：构造函数的特点、构造函数的定义3.掌握Java的访问控制符：public、private、protected、4.掌握Java的非访问控制符：静态属性、静态方法与静态初始化器；抽象类和抽象方法；最终类、最终属性、最终方法与终结器5.了解其他修饰符及修饰符的混合使用：native、volatile、synchronized、修饰符混合使用规则6.理解方法的形式参数与实际参数、方法的返回值、方法的调用过程。3.1Java的类3.1.1Java类库的概念

语言规则——程序的书写规范Java语言

类库——已有的有特定功能的Java程序模块

Java的类库大部分是由SUN公司提供的，叫基础类库（JFC）。根据功能不同，Java的类库被划分为若干个不同的包，每个包中都有若干个具有特定功能和相互关系的类和接口。包是一种松散的类的集合。同一个包中的类在缺省情况下可以互相访问，为了便于编程和管理，常把需要在一起工作的类放在一个包里。3.1.2Java中常用的包（1）java.lang包这是Java语言的核心类库，包含了运行Java程序必不可少的系统类，如：基本数据类型、基本数学函数、字符串处理、线程、异常处理等，这个包系统自动加载。（2）java.io包是Java语言的标准输入/输出类库，包含了实现Java程序与操作系统、用户界面以及其他Java程序做数据交换所使用的类。（3）java.util包包含了Java语言中的一些低级的实用工具，如处理时间的Date类、处理变长数组的Vector类，栈Stack类、散列表HashTable类等。（4）java.awt包是Java语言用来构建图形用户界面（GUI）的类库。低级绘图操作——Graphics类等java.awt

图形控件和布局——Container类、

Checkbox类、LayoutManager接口等界面用户控制和事件响应——Event类（5）java.applet包是用来实现在Internet浏览器中运行JavaApplet的工具类，其中包含一个非常有用的类java.applet.Applet。（6）java.awt.event包是对Event类的一个扩充，可以用不同方式来处理不同类型的事件，并使每个图形界面元素本身可以拥有处理它上面事件的能力。3.1.3使用系统类库的方式（1）继承系统类，在用户程序里创建系统类的子类如：

publicclassAccessControl

extends

Applet（2）创建系统类的对象如：TextFieldinput=new

TextField（6）;（3）直接使用系统类如：System.out.println（4+8+”Hello,world!”）;注意：使用系统类之前，用户程序需要用import语句引入所用到的系统类或系统类所在的包。如：importjava.awt.*；

importjava.awt.event.*；3.2创建Java自定义类的方法3.2.1定义类

定义类就是定义类的属性和服务。类的属性是指类内的各项数据；类的服务即成员函数（或方法）。语法结构：[修饰符]class

类名[extends

父类][implements

接口名]{

类成员变量声明

类方法（函数）声明}（1）声明类头：关键字class父类名：跟在extends关键字后，用以说明当前类是已经存在的哪个类的子类。通过定义继承关系，子类可以获得父类的所有属性和方法，并进一步定义它自己的特殊属性例：classPhoneCard

//父类：电话卡

{

longcardNumber;

//定义类属性

privateintpassword;

//定义类属性

}

classPhoneCard200extendsPhoneCard

//子类：200电话卡

{

}接口名：跟在implements关键字后，用以说明当前类中实现了哪个接口定义的功能和方法。修饰符：说明类的特殊性质，分为访问控制符、抽象说明类和最终类说明符。

（2）声明类体：定义类的具体内容，包括类的属性与方法

类的属性：可以是简单变量，也可以是对象、数组等其他复杂数据结构。声明类属性为简单变量的语法：

[修饰符]变量类型变量名[=变量初值]；例：intpassword;声明类属性为对象的语法：[修饰符]类名对象名[=new类名（实际参数列表）]；例：PhoneCard

myCard=newPhoneCard();

修饰符有访问控制符、静态修饰符static、最终修饰符final、易失修饰符volatile和过渡修饰符transient。类的方法：成员函数；规定类属性上的操作，实现类的内部功能的机制，是类与外部交互的窗口.语法结构：[修饰符]返回值类型

方法名（参数列表）throws

例外名1，例外名2，...{

局部变量声明；

语句序列；}

classPhoneCard

//例3.1{ longcardNumber; privateintpassword; doublebalance; StringconnectNumber;

booleanconnected;

boolean

performConnection(long

cn,intpw) {

if(cn==cardNumber&&pw==password) { connected=true; returntrue; } else { connected=false; returnfalse; } } doublegetBalance() { if(connected) returnbalance; else return-1; }voidperformDial() { if(connected) balance-=0.5; }}3.2.2创建类的实例对象创建对象的一般格式：类名

新建对象名=new

构造函数()；

new是为新建对象开辟内存空间的算符。构造函数（）用来完成对象的初始化。如：TextFieldinput=newTextField(6);

建立一个名为input、长度为6的文本框。

PhoneCardmyCard=newPhoneCard();

建立一个名为myCard的电话卡对象。3.2.3Java中的构造函数（1）基本概念构造函数：用来初始化对象（为其成员变量赋初值）的一个特殊方法。构造函数名与类名相同构造函数可以有0个或多个参数特点构造函数始终和new关键字一起调用构造函数没有返回值构造函数一般不能由编程人员显示地直接调用在创建一个类的新对象时，系统自动调用构造函数对其进行初始化。引入构造函数的原因:1)满足面向对象程序设计中对象初始化的需要;2)提高灵活度，使初始化工作除赋值外有更复杂的操作;

在不定义构造函数时，系统会自动为该类生成一个默认的构造函数。（2）构造函数的定义例：为PhoneCard类定义如下构造函数，初始化它的成员变量。

PhoneCard(long

cn,intpw,doubleb,Strings) {

cardNumber=cn; password=pw; balance=b;

connectNumber=s; connected=false; }

定义了构造函数之后，就可以用如下的语句创建并初始化PhoneCard对象：

PhoneCard

newCard=newPhoneCard(12345678,1234,50.0,″300″);

这个对象的卡号是12345678，密码是1234，金额是50.0，电话卡的接入号码是字符串“300”。

可见，构造函数定义了几个形式参数，创建对象的语句在调用构造函数时，就需要提供几个类型、顺序一致的实际参数，指明新建对象各个成员变量的初始值。构造函数的调用是在用new运算符创建类对象时由系统自动完成。创建此对象示例：PhoneCard

newCard=newPhoneCard(33006655,6666,100.0,″300″);

说明:

newCard是新建对象名关键字new通知系统开辟内存单元，创建运算符第一个PhoneCard说明新对象属于哪个类第二个PhoneCard用来隐含调用PhoneCard类的构造函数

例3-2UsePhoneCard.java 1：publicclassUsePhoneCard 2：{ 3：publicstaticvoidmain(Stringargs［］) 4：{ 5：PhoneCard

myCard=newPhoneCard (12345678,1234,50.0,″300″); 6：System.out.println(myCard.toString()); 7：} 8：} 9：classPhoneCard 10：{ 11：longcardNumber;

12：privateintpassword; 13：doublebalance; 14：StringconnectNumber; 15：booleanconnected; 16：

17：PhoneCard(long

cn,intpw,doubleb,Strings) 18：{ 19：cardNumber=cn; 20：password=pw; 21：if(b>0) 22：balance=b; 23：else 24：System.exit(1);

25：connectNumber=s; 26：connected=false; 27：} 28：boolean

performConnection(long

cn,intpw) 29：{ 30：if(cn==cardNumber&&pw== password) 31：{ 32：connected=true; 33：returntrue; 34：} 35：else 36：{ 37：connected=false;

38：returnfalse; 39：} 40：} 41：doublegetBalance() 42：{ 43：if(connected) 44：returnbalance; 45：else 46：return-1; 47：} 48：voidperformDial() 49：{ 50：if(connected) 51：balance-=0.5;

52：} 53：publicStringtoString() 54：{ 55：Strings=″电话卡接入号码：″+

connectNumber 56：+″＼n电话卡卡号：″+cardNumber 57：+″＼n电话卡密码：″+password 58：+″＼n剩余金额：″+balance; 59：if(connected) 60：return(s+″＼n电话已接通。″); 61：else 62：return(s+″＼n电话未接通。″); 63：} 64：}例3-2的第5句创建了一个PhoneCard的对象myCard，第6句调用了myCard的方法toString()，把myCard中的各个域数据组合成一段信息在屏幕上输出。3.3Java的非访问控制符Java的非访问控制符

static

静态修饰符:修饰属性和方法

abstract

抽象修饰符:修饰类和方法

final

最终修饰符:修饰类、属性和方法3.3.1静态属性、静态方法与静态初始化器（１）静态属性被static修饰的属性不属于任何一个类的具体对象，是公共的存储单元。任何对象访问它时，取到的都是相同的数值。当需要引用或修改一个static限定的类属性时，可以使用类名，也可以使用某一个对象名，效果相同。（２）静态方法用static修饰符修饰的方法，是属于整个类的方法,称为静态方法。例如，在PhoneCard200中如果需要修改附加费，可以定义一个静态方法setAdditory()：

staticvoidsetAdditory(doublenewAdd) { if(newAdd>0)

additoryFee=newAdd; }

用static修饰的方法的含义：1）调用这个方法时应该使用类名做前缀，不用某个具体的对象名；2）该方法属于整个类，它在内存中的代码段随着类的定义而分配和装载；3）该方法不能操纵属于某个对象的成员变量，即static方法只能处理static数据。（3）静态初始化器与构造函数类似，完成初始化工作，但两者的区别是：静态初始化器对每个类初始化，构造函数对每个新创建的对象初始化。静态初始化器在所属的类加载入内存时由系统调用运行，构造函数则在产生新对象时由系统自动执行。静态初始化器不是方法，没有方法名、返回值和参数列表。总之，静态初始化器对整个类完成初始化操作，一般是给static类成员变量赋初值。例TestStatic.java//测试静态属性、静态方法与静态初始化器的综合例题publicclassTestStatic{publicstaticvoidmain(Stringargs[]){ PhoneCard200my200_1=newPhoneCard200(100.0); PhoneCard200my200_2=newPhoneCard200(200.5); //测试静态初始化器

System.out.println("第1张200卡的卡号："+my200_1.cardNumber);

System.out.println("第1张200卡的金额："+my200_1.balance);

System.out.println("第1张200卡的附加费："+my200_1.additoryFee);

System.out.println("第1张200卡的密码："+my200_1.password);

System.out.println("第2张200卡的卡号："+my200_2.cardNumber);

System.out.println("第2张200卡的金额："+my200_2.balance);

System.out.println("第2张200卡的附加费："+my200_2.additoryFee);

System.out.println("第2张200卡的密码："+my200_2.password);

System.out.println("---------直接操作修改静态属性：测试静态属性"); my200_1.additoryFee=0.4;//直接操作修改对象的静态属性，可以实现对类和其它同类对象同一属性的修改

System.out.println("第2张200卡的附加费："+my200_2.additoryFee); System.out.println("200卡类的附加费："+PhoneCard200.additoryFee);

System.out.println("第1张200卡类的附加费："+my200_1.additoryFee);

System.out.println("----------调用静态方法修改静态属性：测试静态方法"); PhoneCard200.setAdditory(0.6);//调用静态方法修改类的静态属性，可以实现其所有同类对象同一属性的修改

System.out.println("修改后第1张200卡类的附加费："+my200_1.additoryFee);

System.out.println("修改后第2张200卡的附加费："+my200_2.additoryFee);

System.out.println("--------测试修改密码的各种方法"); my200_2.password=222;//用普通赋值法给对象的非静态属性赋值

System.out.println("第2张200卡的密码："+my200_2.password);//对该对象的非静态属性操作有效

System.out.println("第1张200卡的密码："+my200_1.password);//对其它同类对象的非静态属性操作无效

//PhoneCard200.password=333;

//用普通赋值法给类的非属性赋值，编译不能通过

my200_2.changePwd(666);//调用类中的方法实现密码的修改

System.out.println("第2张200卡的密码："+my200_2.password);//对该对象的非静态属性操作有效

System.out.println("第1张200卡的密码："+my200_1.password);//对其它同类对象的非静态属性操作无效

}} classPhoneCard200

//定义类：PhoneCard200{

staticlongnextCardNumber; staticStringconnectNumber="200"; staticdoubleadditoryFee;

//静态属性

longcardNumber;

intpassword=111;

booleanconnected; doublebalance;

PhoneCard200(doublebi)

//构造函数

{

cardNumber=nextCardNumber++; balance=bi; }

static

//静态初始化器

{

nextCardNumber=2001800001;

additoryFee=0.2; }

staticvoidsetAdditory(double

newAdd)

//静态方法

{

if(newAdd>0)

additoryFee=newAdd; //password=6666;//静态方法不能操作非静态变量

}

int

changePwd(int

pwd)

//普通方法

{ password=pwd; returnpwd; }}3.3.2抽象类与抽象方法（1）抽象类

没有具体实例对象的类。使用抽象类的优点是可以充分利用公共属性来提高开发和维护程序的效率。例：”交通工具”，代表了所有具体交通工具的共同属性，如速度、加速、减速等。所以可将“交通工具”类定义为抽象类。交通工具陆地交通工具海上交通工具空中交通工具自行车汽车java语句可表述为：abstractclasstransportmeans

{

floatspeed;

//速度

voidstart()

//启动

{

...

}

voidstop()

//停止

{

...

}

floatspeedUp(floatincreaseSpeed)//加速

{

...

}}（2）抽象方法用abstract声明的仅有方法头而没有具体的方法体和操作实现的抽象方法。方法体的具体实现由当前类的不同子类在各自的类定义中完成。只能把abstract方法作为一个共同的接口。所有的抽象方法必须存在于抽象类中。使用abstract方法可以隐藏具体的细节信息。例TestAbstract.java

//抽象类与抽象方法的使用publicclassTestAbstract{publicstaticvoidmain(Stringargs[]){ PhoneCard200my200=newPhoneCard200(50.0);//用PhoneCard200的构造函数初始化对象my200 PhoneCard200my2002=newPhoneCard200(60.0);//用PhoneCard200的构造函数初始化对象my2002 IC_CardmyIC=newIC_Card(50.0);//用IC_Card的构造函数初始化对象myIC System.out.println("200卡可以拨打"+my200.TimeLeft()+"次电话。");

System.out.println("IC

卡可以拨打"+myIC.TimeLeft()+"次电话。");

System.out.println("第1张200卡的卡号："+my200.cardNumber);

System.out.println("第2张200卡的卡号："+my2002.cardNumber);

System.out.println("第2张200卡可以拨打"+my2002.TimeLeft()+"次电话。");}}

abstractclassPhoneCard

//抽象类{ doublebalance; abstractvoidperformDial();//抽象方法，不需要定义方法体

//voidperformChangePwd();

//出错，要么加上abstract，要么定义方法体

doubleTimeLeft()

//一般方法，需要定义方法体，计算可以拨打的次数

{ doublecurrent=balance;

inttimes=0; do {

performDial();//调用抽象方法

times++; }while(balance>=0); balance=current; returntimes-1; }}classPhoneCard200extendsPhoneCard{ staticlongnextCardNumber; staticfinalStringconnectNumber="200"; staticdoubleadditoryFee; longcardNumber;

intpassword;

booleanconnected;

static

//静态初始化器，初始化类

{

nextCardNumber=2001800001;

additoryFee=0.1; }

PhoneCard200(doubleib)

//PhoneCard200的构造函数

{

cardNumber=nextCardNumber++; balance=ib; }

voidperformDial()

//子类PhoneCard200实现的抽象方法

{ balance-=0.5+additoryFee; }

//abstractvoidperformChange();

//出错，非抽象类不可以定义抽象方法} classIC_CardextendsPhoneCard{ IC_Card(doubleib)//IC_Card的构造函数

{ balance=ib; } voidperformDial()//子类IC_Card实现的抽象方法

{ balance-=0.8; }}3.3.3最终类、最终属性、最终方法用final最终修饰符来修饰类、属性和方法。（1）最终类——不能有子类

（2）最终属性(域)——可用来修饰常量，若成员变量被声明为final，则整个执行过程中都不会变。语法：staticfinaldoubleadditoryFee=0.1;注意：需要说明常量的数据类型需要同时指出常量的具体取值为了节省空间，常量通常被声明为static（3）最终方法——功能和语句都不能被修改的方法，即不能被当前类的子类重载。目的是为了预防不必要的重复定义。例：finaldoublegetAdditoryFee()

{

returnadditoryFee;

}注意：所有已被private修饰符限定为私有的方法，以及所有包含在final类中的方法，都被缺省地认为是final的。例：TestFinal.java//最终类、最终方法、最终属性、终结器的综合例题publicclassTestFinal{publicstaticvoidmain(Stringargs[]){ PhoneCard200my200_1=newPhoneCard200(100.0); PhoneCard200my200_2=newPhoneCard200(200.5);

System.out.println("第1张200卡的卡号："+my200_1.cardNumber);

System.out.println("第1张200卡的金额："+my200_1.balance);

System.out.println("第1张200卡的附加费："+my200_1.additoryFee);

System.out.println("第1张200卡的密码："+my200_1.getAdditoryFee());

System.out.println("第2张200卡的卡号："+my200_2.cardNumber);

System.out.println("第2张200卡的金额："+my200_2.balance);

System.out.println("第2张200卡的连接号："+my200_2.connectNumber); my200_1.setAdditory(0.9);

System.out.println("修改后第2张200卡的连接号："+my200_2.connectNumber);

//my200_1.additoryFee=0.4;

//出错，不能给对象的最终属性赋值

//PhoneCard200.setAdditory(0.6);

//出错，不能修改对象的最终属性

IC_CardmyIC=newIC_Card(50.0);

System.out.println("IC

卡可以拨打"+myIC.TimeLeft()+"次电话。"); }}finalclassPhoneCard

//定义为final最终类,则下面的IC卡不能定义为其子类,若定义为抽象类,IC卡可以为子类{ doublebalance;

//abstractvoidperformDial();

//final中不能定义抽象方法

doubleTimeLeft()//一般方法，需要定义方法体，计算可以拨打的次数

{ doublecurrent=balance;

inttimes=0; do { // performDial();//不能调用该方法

times++; }while(balance>=0); balance=current; returntimes-1; }}

classPhoneCard200//定义类：PhoneCard200{ staticlongnextCardNumber; staticStringconnectNumber="200"; staticfinaldoubleadditoryFee=0.5;//静态最终属性，被赋值后就不可以再修改

//这里如果不赋值,可以在静态初始化器中修改

longcardNumber;

intpassword=222;

booleanconnected; doublebalance; PhoneCard200(doublebi)//构造函数

{

cardNumber=nextCardNumber++; balance=bi; } static//静态初始化器

{

nextCardNumber=2001800001;

//additoryFee=0.2;

//出错，如果定义时没有赋初值才可以

}

staticvoidsetAdditory(double

newAdd)//静态方法

{

if(newAdd>0)

//additoryFee=newAdd;//不能操作最终变量

connectNumber="300"; } finaldoublegetAdditoryFee()//最终方法

{ returnadditoryFee; }voidperformDial()//PhoneCard200的方法

{ balance-=0.5+additoryFee; }}/*classIC_CardextendsPhoneCard

//PhoneCard被定义为final则不能有子类{ IC_Card(doubleib)//IC_Card的构造函数

{ balance=ib; } voidperformDial()//子类IC_Card的方法

{ balance-=0.8; }}*/3.4Java的访问控制符3.4.1Java的访问控制符种类

public

类、属性和方法

private

属性和方法

protected

属性和方法（另外还有一种缺省定义）作用：限定类、属性和方法可以被程序里的哪些其他部分访问和调用3.4.2语法结构修饰符1、修饰符2...修饰符N

class

类名{...}修饰符1、修饰符2...修饰符N

数据类型

属性名

修饰符1、修饰符2...修饰符N

方法返回值类型

方法名(形式参数列表)

3.4.3访问控制符的特点公共访问控制符public——可以被所有其他类所访问和引用。但对类而言，其中包含的属性和方法能否被访问看自身的访问控制符是否也为public。缺省访问控制符——规定该类只能被同一包中的类访问和引用，称之为包访问性；类中的属性和方法若也没有访问控制符来限定，则同样具备包访问性。私有访问控制符private——只能被该类自身所访问和修改，不能被任何其他类（包括子类）获取和引用。保护访问控制符protected——只能被该类自身、与它在同一个包中的其他类、在其他包中该类的子类引用，其主要作用是允许其他包中的它的子类来访问父类的特定属性。类、属性和方法的访问控制类属性与方法public缺省publicABprotectedB+CB缺省BBprivateDD例：AccessControl.java//测试访问控制符的使用importjava.applet.Applet;importjava.awt.*;publicclassAccessControlextendsApplet //定义主类，在浏览器中显示信息{

ClassBeAccessedc=newClassBeAccessed();//创建被访问使用类的对象（区域D）

subClasssc=newsubClass();//创建被访问类子类的对象（区域C）

PackageClass

ic=newPackageClass();//创建被访问类同一包中类的对象（区域B）

publicvoidpaint(Graphicsg) //显示可访问信息

{

g.drawString("SelfAccessible:",10,20);//类可以访问自己的所有属性和方法

g.drawString(c.toString(),20,35);

g.drawString("SubAccessible:",10,55);//子类可以直接访问父类的哪些属性

g.drawString(sc.AccessDirectly(),20,70);

g.drawString("PackageAccessible:",10,90);//同包中的类可以访问哪些属性

g.drawString(ic.AccessDirectly(),20,105);

g.drawString("Accessusingpublicmethod:",10,125);//通过调用被访问类的

g.drawString(sc.AccessCls(),20,140); //公共方法来访问它的

g.drawString(ic.AccessCls(),20,155); //所有性质的属性

}}classClassBeAccessed

//被访问类是非公共类，同一包中的其他类都可创建其对象{publicStringm_PublicProperty; //公共属性

Stringm_FriendlyProperty; //缺省属性（又称为友元）

protectedStringm_ProtectedProperty;//保护属性

privateStringm_PrivateProperty; //私有属性

ClassBeAccessed() //构造函数，为各属性赋初值

{

m_PublicProperty=newString("Public");

m_FriendlyProperty=newString("Friendly");

m_ProtectedProperty=newString("Protected");

m_PrivateProperty=newString("Private");}publicStringtoString() //公共方法：连接各属性的字符串并显示

{

return(m_PublicProperty+";" +m_FriendlyProperty+";" +m_ProtectedProperty+";" +m_PrivateProperty+";");}}classsubClassextendsClassBeAccessed

//被访问类的子类{

ClassBeAccessedc=newClassBeAccessed(); //创建被访问类的对象StringAccessDirectly()//直接调用被访问类的属性，可调用的有：

{

return(c.m_PublicProperty+";" //公共属性

+c.m_FriendlyProperty+";" //缺省属性

+c.m_ProtectedProperty+";"); //保护属性

}StringAccessCls()//通过调用被访问类的公共方法，可以调用它的各种性质的属性

{

return(c.toString());}}classPackageClass

//与被访问类在同一个包中的类{

ClassBeAccessedc=newClassBeAccessed(); //创建被访问类的对象

StringAccessDirectly()//直接调用被访问类的属性，可调用的有：

{

return(c.m_PublicProperty+";" //公共属性

+c.m_FriendlyProperty+";" //缺省属性

+c.m_ProtectedProperty+";"); //保护属性

}StringAccessCls(){

return(c.toString());//通过调用被访问类的公共方法，可以调用它的各种性质的属性

}}3.4.4其他修饰符及修饰符的混合使用（1）volatile易失域修饰符可以同时被几个线程所控制和修改;一般用于修饰接受外部输入的属性，如当前时间的变量由系统后台线程修改;（2）native本地方法修饰符用来声明用其他语言书写方法体并具体实现方法功能的特殊的方法。声明：nativedoubleCaculateTax(Employeeemp);

//调用C++编写的CaculateTax模块调用：Emp1.m_Tax=CaculateTax(Emp1);

目的是充分利用已经存在的程序功能模块和避免重复工作；要注意跨平台性能。（3）synchronized同步方法修饰符用于多线程共存的程序中的协调和同步。如果是一个类的方法（即static的方法），那么在系统调用执行前，将把系统类Class中对应当前类的对象加锁；

如果修饰的是一个对象的方法（未用static修饰的方法），则这个方法在被调用执行前，将把当前对象加锁。（4）修饰符的混合使用大多数情况下，修饰符是可以混合使用的。例如：publicabstractclasstransportmeans...但有以下例外：abstract不能与final并列修饰同一个类；abstract不能与private、static、final、native并列修饰同一个方法；abstract类中不能有private的成员（包括属性和方法）；abstract方法必须在abstract类中；static方法中不能处理非static的属性、不能调用非static方法。3.5定义和使用Java的方法回顾：

Java程序的基本结构引入Java类库；定义用户类n{

定义类n的若干变量或对象；

定义类n的方法1；

定义类n的方法2；

...

定义类n的