JAVA教程全集电子版（中）

　　第4章 面向对象的程序设计基础
　　如前所述，Java语言是一种纯面向对象的编程语言，面向对象的程序设计是以类为基础的。从本章开始，我们将从类入手，详细介绍面向对象程序设计的基本思想和方法。
　　本章将简要介绍面向对象的基本概念、定义类、构造对象等。4.1 面向对象的基本概述
　　随着计算机应用的深入，软件的需求量越来越大，另一方面计算机硬件飞速发展也使得软件的规模越来越大，导致软件的生产、调试、维护越来越困难，因而发生了软件危机。人们期待着一种效率高、简单、易理解且更加符合人们思维习惯的程序设计语言，以加快软件的开发步伐、缩短软件开发生命周期，面向对象就是在这种情况下应运而生的。4.1.1 类和对象
　　我们可以把客观世界中的每一个实体都看作是一个对象，如一个人、一辆汽车、一个按钮、一只鸟等等。因此对象可以简单定义为：＂展示一些定义好的行为的、有形的实体＂。当然在我们的程序开发中，对象的定义并不局限于看得见摸得着的实体，诸如一个贸易公司，它作为一个机构，并没有物理上的形状，但却具有概念上的形状，它有明确的的经营目的和业务活动。根据面向对象的倡导者Grady Booch的理论，对象具有如下特性：
　　1） 它具有一种状态；
　　2） 它可以展示一种行为；
　　3） 它具有唯一的标识。
　　对象的状态通过一系列属性及其属性值来表示；对象的行为是指在一定的期间内属性的改变；标识是用来识别对象的，每一个对象都有唯一的标识，诸如每个人都有唯一的特征，在社会活动中，使用身份证号码来识别。
　　我们生活在一个充满对象的世界中，放眼望去，不同形状、不同大小和颜色各异的对象；静止的和移动的对象。面对这些用途各异、五花八门的对象，我们该如何下手处理它们呢？借鉴于动物学家将动物分成纲、属、科、种的方法。我们也可以把这些对象按照它们所拥有的共同属性进行分类。例如，麻雀、鸽子、燕子等都叫作鸟。它们具有一些共同的特性：有羽毛、有飞翔能力、下蛋孵化下一代等。因此我们把它们归属为鸟类。
　　综上所述我们可以简单地把类定义为：＂具有共同属性和行为的一系列对象＂。4.1.2 面向对象的特点
　　1. 什么是面向对象
　　面向对象的方法将系统看作是现实世界对象的集合，在现实世界中包含被归类的对象。如前所述，面向对象系统是以类为基础的，我们把一系列具有共同属性和行为的对象划归为一类。属性代表类的特性，行为代表有类完成的操作。
　　例如：例如汽车类定义了汽车必须有属性：车轮个数、颜色、型号、发动机的能量等；类的行为有：启动、行驶、加速、停止等。
　　对象是类的一个实例，它展示了类的属性和行为。例如，李经理的那辆红旗牌轿车就是汽车类的一个对象。
　　2. 面向对象的特性
　　1）抽象
　　所谓抽象就是不同的角色站在不同的角度观察世界。比如，当你购买电视机时，站在使用的角度，你所关注的是电视机的品牌、外观及功能等等。然而，对于电视机的维修人员来说，站在维修的角度，他们所关注的是电视机的内部，各部分元器件的组成及工作原理等。
　　其实，所有编程语言的最终目的都是提供一种＂抽象＂方法。在早期的程序设语言中，一般把所有问题都归纳为列表或算法，其中一部分是面向基于＂强制＂的编程，而另一部分是专为处理图形符号设计的。每种方法都有自己特殊的用途，只适合解决某一类的问题。面向对象的程序设计可以根据问题来描述问题，不必受限于特定类型的问题。我们将问题空间中的元素称之为＂对象＂，在处理一个问题时，如果需要一些在问题空间没有的其他对象，则可通过添加新的对象类型与处理的问题相配合，这无疑是一种更加灵活、更加强大的语言抽象方法。
　　2）继承
　　继承提供了一种有助于我们概括出不同类中共同属性和行为的机制，并可由此派生出各个子类。
　　例如，麻雀类是鸟类的一个子类，该类仅包含它所具有特定的属性和行为，其他的属性和行为可以从鸟类继承。我们把鸟类称之为父类（或基类），把由鸟类派生出的麻雀类称之为子类（或派生类）。
　　在Java中，不允许类的多重继承（即子类从多个父类继承属性和行为），也就是说子类只允许有一个父类。父类派生多个子类，子类又可以派生多个子子类，… 这样就构成了类的层次结构。
　　3）封装
　　封装提供了一种有助于我们向用户隐藏他们所不需要的属性和行为的机制，而只将用户可直接使用的那些属性和行为展示出来。
　　例如，使用电视机的用户不需要了解电视机内部复杂工作的具体细节，他们只需要知道诸如：开、关、选台、调台等这些设置与操作就可以了。
　　4）多态
　　多态指的是对象在不同情况下具有不同表现的一种能力。
　　例如，一台长虹牌电视机是电视机类的一个对象，根据模式设置的不同，它有不同的表现。若我们把它设置为静音模式，则它只播放画面不播放声音。
　　在Java中通过方法的重载和覆盖来实现多态性。
　　3. 面向对象的好处
　　今天我们选择面向对象的程序设计方法，其主要原因是：
　　1）现实的模型
　　我们生活在一个充满对象的现实世界中，从逻辑理念上讲，用面向对象的方法来描述现实世界的模型比传统的过程方法更符合人的思维习惯。
　　2）重用性
　　在面向对象的程序设计过程中，我们创建了类，这些类可以被其他的应用程序所重用，这就节省程序的开发时间和开发费用，也有利于程序的维护。
　　3）可扩展性
　　面向对象的程序设计方法有利于应用系统的更新换代。当对一个应用系统进行某项修改或增加某项功能时，不需要完全丢弃旧的系统，只需对要修改的部分进行调整或增加功能即可。可扩展性是面向对象程序设计的主要优点之一。4.2 类
　　面向对象的程序设计是以类为基础的，Java程序是由类构成的。一个Java程序至少包含一个或一个以上的类。4.2.1 定义类
　　如前所述，类是对现实世界中实体的抽象，类是一组具有共同特征和行为的对象的抽象描述。因此，一个类的定义包括如下两个方面：
　　定义属于该类对象共有的属性（属性的类型和名称）；
　　定义属于该类对象共有的行为（所能执行的操作即方法）。
　　类包含类的声明和类体两部分，其定义类的一般格式如下：
　　[访问限定符] [修饰符] class 类名 [extends 父类名] [implements 接口名列表>]//类声明
　　{ //类体开始标志
　　[类的成员变量说明] //属性说明
　　[类的构造方法定义]
　　[类的成员方法定义] //行为定义
　　} //类体结束标志
　　对类声明的格式说明如下：
　　1） 方括号＂[]＂中的内容为可选项，在下边的格式说明中意义相同，不再重述。
　　2） 访问限定符的作用是：确定该定义类可以被哪些类使用。可用的访问限定符如下：
　　a) public 表明是公有的。可以在任何Java程序中的任何对象里使用公有的类。该限定符也用于限定成员变量和方法。如果定义类时使用public进行限定，则类所在的文件名必须与此类名相同（包括大小写）
　　b) private表明是私有的。该限定符可用于定义内部类，也可用于限定成员变量和方法。
　　c) protected 表明是保护的。只能为其子类所访问。
　　d) 默认访问 若没有访问限定符，则系统默认是友元的 (friendly)。友元的类可以被本类包中的所有类访问。
　　3） 修饰符的作用是：确定该定义类如何被其他类使用。可用的类修饰符如下：
　　a) abstract 说明该类是抽象类。抽象类不能直接生成对象。
　　b) final 说明该类是最终类，最终类是不能被继承的。
　　4） class是关键字，定义类的标志（注意全是小写）。
　　5） 类名是该类的名字，是一个Java标识符，含义应该明确。一般情况下单词首字大写。
　　6） 父类名跟在关键字 ＂extends＂后，说明所定义的类是该父类的子类，它将继承该父类的属性和行为。父类可以是Java类库中的类，也可以是本程序或其他程序中定义的类。
　　7） 接口名表是接口名的一个列表，跟在关键字＂implements＂后，说明所定义的类要实现列表中的所有接口。一个类可以实现多个接口，接口名之间以逗号分隔。如前所述，Java不支持多重继承，类似多重继承的功能是靠接口实现的。
　　以上简要介绍了类声明中各项的作用，我们将在后边的章节进行详细讨论。
　　类体中包含类成员变量和类方法的声明及定义，类体以定界符左大括号＂{＂开始，右大括号＂}＂结束。类成员变量和类方法的声明及定义将下边各节中进行详细讨论。
　　我们先看一个公民类的定义示例。
　　public class Citizen
　　{
　　[ 声明成员变量 ] //成员变量（属性）说明
　　[ 定义构造方法 ] //构造方法（行为）定义
　　[ 定义成员方法 ] //成员方法（行为）定义
　　}
　　我们把它定义为公有类，在任何其他的Java程序中都可以使用它。4.2.2 成员变量
　　成员变量用来表明类的特征（属性）。声明或定义成员变量的一般格式如下：
　　[访问限定符] [修饰符] 数据类型 成员变量名[=初始值];
　　其中：
　　1）访问限定符用于限定成员变量被其它类中的对象访问的权限，和如上所述的类访问限定符类似。
　　2）修饰符用来确定成员变量如何在其他类中使用。可用的修饰符如下：
　　a) static 表明声明的成员变量为静态的。静态成员变量的值可以由该类所有的对象共享，它属于类，而不属于该类的某个对象。即使不创建对象，使用＂类名.静态成员变量＂也可访问静态成员变量。
　　b) final 表明声明的成员变量是一个最终变量，即常量。
　　c) transient 表明声明的成员变量是一个暂时性成员变量。一般来说成员变量是类对象的一部分，与对象一起被存档（保存），但暂时性成员变量不被保存。
　　d) volatile 表明声明的成员变量在多线程环境下的并发线程中将保持变量的一致性。
　　3）数据类型可以是简单的数据类型，也可以是类、字符串等类型，它表明成员变量的数据类型。
　　类的成员变量在类体内方法的外边声明，一般常放在类体的开始部分。
　　下边我们声明公民类的成员变量，公民对象所共有的属性有：姓名、别名、性别、出生年月、出生地、身份标识等。
　　import java.util.*;
　　public class Citizen
　　{
　　//以下声明成员变量（属性）
　　String name;
　　String alias;
　　String sex;
　　Date brithday; //这是一个日期类的成员变量
　　String homeland;
　　String ID;
　　//以下定义成员方法（行为）
　　……
　　}
　　在上边的成员变量声明中，除出生年月被声明为日期型（Date）外，其他均为字符串型。由于Date类被放在java.util类包中，所以在类定义的前边加上import语句。4.2.3 成员方法
　　方法用来描述对象的行为，在类的方法中可分为构造器方法和成员方法，本小节先介绍成员方法。
　　成员方法用来实现类的行为。方法也包含两部分，方法声明和方法体（操作代码）。
　　方法定义的一般格式如下：
　　[访问限定符] [修饰符] 返回值类型 方法名([形式参数表]) [throws 异常表]
　　{
　　[ 变量声明 ] //方法内用的变量，局部变量
　　[ 程序代码 ] //方法的主体代码
　　[ return [ 表达式 ] ] //返回语句
　　}
　　在方法声明中：
　　1）访问限定符如前所述。
　　2）修饰符用于表明方法的使用方式。可用于方法的修饰符如下：
　　a) abstract说明该方法是抽象方法，即没有方法体（只有＂{}＂引起的空体方法）。
　　b) final说明该方法是最终方法，即不能被重写。
　　c) static说明该方法是静态方法，可通过类名直接调用。
　　d) native说明该方法是本地化方法，它集成了其他语言的代码。
　　e) synchronized说明该方法用于多线程中的同步处理。
　　3）返回值类型应是合法的java数据类型。方法可以返回值，也可不返回值，可视具体需要而定。当不需要返回值时，可用void（空值）指定，但不能省略。
　　4）方法名是合法Java标识符，声明了方法的名字。
　　5）形式参数表说明方法所需要的参数，有两个以上参数时，用＂，＂号分隔各参数，说明参数时，应声明它的数据类型。
　　6）throws 异常表定义在执行方法的过程中可能抛出的异常对象的列表（放在后边的异常的章节中讨论）。
　　以上简要介绍了方法声明中各项的作用，在后边章节的具体应用示例中再加深理解。
　　方法体内是完成类行为的操作代码。根据具体需要，有时会修改或获取对象的某个属性值，也会访问列出对象的相关属性值。下边还以公民类为例介绍成员方法的应用，在类中加入设置名字、获取名字和列出所有属性值3个方法。
　　例4.1 完善公民类Citizen。程序如下：
　　/* 这是一个公民类的定义程序
　　* 程序的名字是：Citizen.java
　　*/
　　import java.util.*;
　　public class Citizen
　　{
　　//以下声明成员变量（属性）
　　String name;
　　String alias;
　　String sex;
　　Date brithday; //这是一个日期类的成员变量
　　String homeland;
　　String ID;
　　//以下定义成员方法（行为）
　　public String getName() //获取名字方法
　　{ //getName()方法体开始
　　return name; //返回名字
　　} //getName()方法体结束
　　/***下边是设置名字方法***/
　　public void setName(String name)
　　{ //setName()方法体开始
　　this.name=name;
　　} //setName()方法体结束
　　/***下边是列出所有属性方法***/
　　public void displayAll()
　　{ //displayAll()方法体开始
　　System.out.println(＂姓名：＂+name);
　　System.out.println(＂别名：＂+alias);
　　System.out.println(＂性别：＂+sex);
　　System.out.println(＂出生：＂+brithday.toLocaleString());
　　System.out.println(＂出生地：＂+homeland);
　　System.out.println(＂身份标识：＂+ID);
　　} //displayAll()方法体结束
　　}
　　在上边的示例中，两个方法无返回值（void），一个方法返回名字（String）；两个方法不带参数，一个方法带有一个参数，有关参数的使用将在后边介绍。在显示属性方法中，出生年月的输出使用了将日期转换为字符串的转换方法toLocaleString()。
　　需要说明的是，在设置名字方法setName()中使用了关键字this，this代表当前对象，其实在方法体中引用成员变量或其他的成员方法时，引用前都隐含着＂this.＂，一般情况下都会缺省它，但当成员变量与方法中的局部变量同名时，为了区分且正确引用，成员变量前必须加＂this.＂不能缺省。4.2.4 构造方法
　　构造方法用来构造类的对象。如果在类中没有构造方法，在创建对象时,系统使用默认的构造方法。定义构造方法的一般格式如下：
　　[public] 类名（[形式参数列表]）
　　{
　　[方法体]
　　}
　　我们可以把构造方法的格式和成员方法的格式作一个比较，可以看出构造方法是一个特殊的方法。应该严格按照构造方法的格式来编写构造方法，否则构造方法将不起作用。有关构造方法的格式强调如下：
　　1）构造方法的名字就是类名。
　　2）访问限定只能使用public或缺省。一般声明为public，如果缺省，则只能在同一个包中创建该类的对象。
　　3）在方法体中不能使用return语句返回一个值。
　　下边我们在例4.1定义的公民类Citizen中添加如下的构造方法：
　　public Citizen(String name,String alias,String sex,Date brithday,String homeland,String ID)
　　{
　　this.name=name;
　　this.alias=alias;
　　this.sex=sex;
　　this.brithday=brithday;
　　this.homeland=homeland;
　　this.ID=ID;
　　}
　　到此为止，我们简要介绍了类的结构并完成了一个简单的公民类的定义。4.3 对象
　　我们已经定义了公民（Citizen）类，但它只是从＂人＂类中抽象出来的模板，要处理一个公民的具体信息，必须按这个模板构造出一个具体的人来，他就是Citizen类的一个实例，也称作对象。4.3.1 对象的创建
　　创建对象需要以下三个步骤：
　　1. 声明对象
　　声明对象的一般格式如下：
　　类名 对象名;
　　例如：
　　Citizen p1,p2; //声明了两个公民对象
　　Float f1,f2; //声明了两个浮点数对象
　　声明对象后，系统还没有为对象分配存储空间，只是建立了空的引用，通常称之为空对象（null）。因此对象还不能使用。
　　2. 创建对象
　　对象只有在创建后才能使用，创建对象的一般格式如下：
　　对象名 = new 类构造方法名([实参表]);
　　其中：类构造方法名就是类名。new运算符用于为对象分配存储空间，它调用构造方法，获得对象的引用（对象在内存中的地址）。
　　例如：
　　p1=new Citizen(＂丽柔＂,＂温一刀＂,＂女＂,new Date(),＂中国上海＂,＂410105651230274x＂);
　　f1=new Float(30f);
　　f2=new Float(45f);
　　注意：声明对象和创建对象也可以合并为一条语名，其一般格式是：
　　类名 对象名 = new 类构造方法名([实参表]);
　　例如：
　　Citizen p1=new Citizen(＂丽柔＂,＂温一刀＂,＂女＂,new Date(),＂中国上海＂,＂410105651230274x＂);
　　Float f1=new Float(30f);
　　Float f2=new Float(45f);
　　3. 引用对象
　　在创建对象之后，就可以引用对象了。引用对象的成员变量或成员方法需要对象运算符＂.＂。
　　引用成员变量的一般格式是： 对象名.成员变量名
　　引用成员方法的一般格式是： 对象名.成员方法名（[实参列表]）
　　在创建对象时，某些属性没有给于确定的值，随后可以修改这些属性值。例如：
　　Citizen p2=new Citizen(＂李明＂,＂＂,＂男＂,null,＂南京＂,＂50110119850624273x＂);
　　对象p2的别名和出生年月都给了空值，我们可以下边的语句修正它们：
　　p2.alias=＂飞翔鸟＂;
　　p2.brithday=new Date(＂6/24/85＂);
　　名字中出现别字，我们也可以调用方法更正名字：
　　p2.setName(＂李鸣＂);4.3.2 对象的简单应用示例
　　本小节介绍两个简单的示例，以加深理解前边介绍的一些基本概念，对Java程序有一个较为全面的基本认识。
　　例4.2 编写一个测试Citizen类功能的程序，创建Citizen对象并显示对象的属性值。
　　/* Citizen测试程序
　　* 程序的名字是：TestCitizenExam4_2.java
　　*/
　　import java.util.*;
　　public class TestCitizenExam4_2
　　{
　　public static void main(String [] args)
　　{
　　Citizen p1,p2; //声明对象
　　//创建对象p1,p2
　　p1=new Citizen(＂丽柔＂,＂温一刀＂,＂女＂,new Date(＂12/30/88＂),＂上海＂,＂421010198812302740＂);
　　p2=new Citizen(＂李明＂,＂ ＂,＂男＂,null,＂南京＂,＂50110119850624273x＂);
　　p2.setName(＂李鸣＂); //调用方法更正对象的名字
　　p2.alias=＂飞翔鸟＂; //修改对象的别名
　　p2.brithday=new Date(＂6/24/85＂); //修改对象的出生日期
　　p1.displayAll(); //显示对象p1的属性值
　　System.out.println(＂----------------------------＂);
　　p2.displayAll(); //显示对象p2的属性值
　　}
　　}
　　如前所述，一个应用程序的执行入口是main()方法，上边的测试类程序中只有主方法，没有其他的成员变量和成员方法，所有的操作都在main()方法中完成。
　　编译、运行程序，程序运行结果如图4-1所示。
　　需要说明的是，程序中使用了JDK1.1的一个过时的构造方法Date(日期字符串)，所以在编译的时候，系统会输出提示信息提醒你注意。一般不提倡使用过时的方法，类似的功能已由相关类的其他方法所替代。在这里使用它，主要是为了程序简单阅读容易。
　　请读者认真阅读程序，结合前边介绍的内容，逐步认识面向对象程序设计的基本方法。
　　在程序中，从声明对象、创建对象、修改对象属性到执行对象方法等等，我们一切度是围绕对象在操作。
　　例4.3 定义一个几何图形圆类，计算圆的周长和面积。
　　/* 这是一个定义圆类的程序
　　* 程序的名字是CircleExam4_3.prg
　　* 该类定义了计算面积和周长的方法。
　　*/
　　public class CircleExam4_3
　　{
　　final double PI=3.1415926; //常量定义
　　double radius=0.0 ; //变量定义
　　//构造方法定义
　　public CircleExam4_3(double radius)
　　{
　　this.radius=radius;
　　}
　　//成员方法计算周长
　　public double circleGirth()
　　{
　　return radius*PI*2.0;
　　}
　　//成员方法计算面积
　　public double circleSurface()
　　{
　　return radius*radius*PI;
　　}
　　//主方法
　　public static void main(String [] args)
　　{
　　CircleExam4_3 c1,c2;
　　c1=new CircleExam4_3(5.5);
　　c2=new CircleExam4_3(17.2);
　　System.out.println(＂半径为5.5圆的周长=＂+c1.circleGirth()+＂ 面积=＂+c1.circleSurface());
　　System.out.println(＂半径为17.2圆的周长=＂+c2.circleGirth()+＂ 面积=＂+c2.circleSurface());
　　}
　　}
　　编译、运行程序，执行结果如图4-2所示。4.3.3 对象的清除
　　在Java中，程序员不需要考虑跟踪每个生成的对象，系统采用了自动垃圾收集的内存管理方式。运行时系统通过垃圾收集器周期性地清除无用对象并释放它们所占的内存空间。
　　垃圾收集器作为系统的一个线程运行，当内存不够用时或当程序中调用了System.gc()方法要求垃圾收集时，垃圾收集器便于系统同步运行开始工作。在系统空闲时，垃圾收集器和系统异步工作。
　　事实上，在类中都提供了一个撤销对象的方法finalize()，但并不提倡使用该方法。若在程序中确实希望清除某对象并释放它所占的存储空间时，只须将空引用（null）赋给它即可。4.4 方法的进一步讨论
　　我们已经介绍了方法的声明及方法的引用。本节主要讨论方法引用中的参数传递、方法的重载以及static(静态)方法等概念。4.4.1方法引用及参数传递
　　在Java中，方法引用有两种方式：系统自动引用和程序引用。系统自动引用一般用在一些特定的处理中，我们将在后边的章节遇到它。本小节主要介绍程序引用方法及参数传递问题。
　　1. 方法声明中的形式参数
　　在方法声明中的＂（）＂中说明的变量被称之为形式参数（形参），形参也相当于本方法中的局部变量，和一般局部变量所不同的是，它自动接受方法引用传递过来的值（相当于赋值）。然后在方法的执行中起作用。例如，在Citizen类中的方法：
　　public void setName(String name)
　　{
　　this.name=name;
　　}
　　当对象引用该方法时，该方法的形参name接受对象引用传递过来的名字，然后它被赋给对象的属性name。
　　2. 方法引用中的实际参数
　　一般我们把方法引用中的参数称为实际参数（实参），实参可以是常量，变量、对象或表达式。例如：
　　Citizen p2=new Citizen(＂李明＂,＂ ＂,＂男＂,null,＂南京＂,＂50110119850624273x＂);
　　p2.setName(＂李鸣＂);
　　方法引用的过程其实就是将实参的数据传递给方法的形参，以这些数据为基础，执行方法体完成其功能。
　　由于实参与形参按对应关系一一传递数据，因此在实参和形参的结合上必须保持＂三一致＂的原则，即：
　　1） 实参与形参的个数一致；
　　2） 实参与形参对应的数据类型一致；
　　3） 实参与形参对应顺序一致。
　　3. 参数传递方式
　　参数传递的方式有两种：按值传递和按引用传递。
　　1）按值传递方式
　　一般情况下，如果引用语句中的实参是常量、简单数据类型的变量或可计值的基本数据类型的表达式，那么被引用的方法声明的形参一定是基本数据类型的。反之亦然。这种方式就是按值传递的方式。
　　2）按引用传递方式
　　当引用语句中的实参是对象或数组时，那么被引用的方法声明的形参也一定是对象或数组。反之亦然。这种方式称之为是按引用传递的。
　　下边举例说明参数的传递。
　　例4.4 传递方法参数示例。
　　/* 这是一个简单的说明方法参数使用的示例程序
　　* 程序的名字：ParametersExam4_4.java
　　*/
　　public class ParametersExam4_4
　　{
　　/**下边定义方法swap(int n1,int n2) 该方法从调用者传递的实际参数值获得n1,n2
　　* 的值，这是一种传值方式。方法的功能是交换 n1,n2的值。
　　*/
　　public void swap(int n1,int n2) //定义成员方法带两个整型参数
　　{
　　int n0; //定义方法变量n0,
　　n0=n1; //先将n1的值赋给n0
　　n1=n2; //再将n2的值赋给n1
　　n2=n0; //最后将n0 (原n1) 的值赋给n2
　　System.out.println(＂在swap()方法中：n1=＂+n1+＂ n2=＂+n2+＂ -------------＂);
　　}
　　public static void main(String [] arg) //以下定义main()方法
　　{
　　int n1=1,n2=10; //定义方法变量
　　ParametersExam4_4 par=new ParametersExam4_4();//创建本类对象
　　par.swap(n1,n2); //以方法变量n1,n2的值为实参调用方法swap
　　System.out.println(＂在main()方法中：n1=＂+n1+＂ n2=＂+n2);
　　}
　　}
　　编译、运行程序，执行结果如图4-3所示。
　　看到程序的执行结果，读者可能会有疑问，不是在swap方法中交换了n1,n2的值么，为什么在main()中仍然是原来的值呢？
　　程序的执行过程是这样的：当在main()方法中执行对象的swap()方法时，系统将方法调用中的实参n1,n2的值传递给swap()方法的形式参数n1,n2,在swap()方法体的执行中形式参数n1,n2的值被交换，这就是我们看到的swap()方法中的输出结果，由于形参n1,n2是swap()方法的局部变量，它们只在该方法中有效，它们随方法的结束而消失，因此在swap()方法中并没有涉及对实参的改变，所以在main()方法中，n1,n2还是原来的值。
　　例4.5 方法参数传递引用方式示例。
　　/* 这是一个简单的说明方法参数使用的示例程序
　　* 程序的名字：ParametersExam4_5.java
　　*/
　　import java.util.*;
　　public class ParametersExam4_5
　　{
　　/**下边定义方法swap()
　　* 对象n从调用者传递的实际参数获得引用。
　　* 该方法的功能是交换对象中成员变量n1,n2的值。
　　*/
　　public void swap(Citizen p1,Citizen p2)
　　{
　　Citizen p; //定义方法变量p
　　p=p1; p1=p2; p2=p; // 交换p1,p2对象的引用
　　p2.alias=＂发烧游二＂; //修改p2的别名
　　p1.alias=＂网中逑大＂; //修改p1的别名
　　System.out.println(p1.name+＂ ＂+p1.alias+＂ ＂+p1.sex);//显示相关属性
　　System.out.println(p2.name+＂ ＂+p2.alias+＂ ＂+p2.sex);//显示相关属性
　　System.out.println(＂-----------------------＂);
　　}
　　//以下定义main()方法
　　public static void main(String [] arg)
　　{
　　ParametersExam4_5 par=new ParametersExam4_5();//创建本类对象
　　//下边创建两个Citizen对象
　　Citizen p1=new Citizen(＂钱二＂,＂＂,＂男＂,new Date(＂12/23/88＂),＂杭州＂,＂ ＂);
　　Citizen p2=new Citizen(＂赵大＂,＂＂,＂男＂,new Date(＂8/31/85＂),＂北京＂,＂ ＂);
　　par.swap(p1,p2); //以对象p1,p2实参调用方法swap
　　p1.displayAll(); //输出p1对象的属性值
　　System.out.println(＂--------------------------＂);
　　p2.displayAll(); //输出p2对象的属性值
　　}
　　}
　　编译、运行程序，程序的执行结果如图4-4所示。
　　程序的执行过程是这样的：当在main()方法中执行对象的swap()方法时，系统将方法调用中的实参p1,p2对象的引用传递给swap()方法的形式参数p1,p2对象，在swap()方法体的执行中形式参数p1,p2对象引用值(即地址)被交换，随后修改了对象的属性值，这就是我们看到的swap()方法中的输出结果，同样由于形参p1,p2是swap()方法的局部变量，它们只在该方法中有效，它们随方法的结束而消失。但需要注意的是，swap()方法中修改的对象属性值并没有消失，这些修改是在原对象的地址上修改的，方法结束，只是传递过来的原对象引用的副本消失，原对象依然存在。因此我们就看到了main()中的显示结果。4.4.2方法的重载
　　所谓重载(Overloading)就是指在一个类中定义了多个相同名字的方法，每个方法具有一组唯一的形式参数和不同的代码，实现不同的功能。
　　方法的名字一样，在对象引用时，系统如何确定引用的是哪一个方法呢？
　　在Java中，方法的名称、类型和形式参数等构成了方法的签名，系统根据方法的签名确定引用的是那个方法，因此方法的签名必须唯一。所以我们在编写重载方法时，应该注意以下两点：
　　1） 方法的返回值类型对方法的签名没有影响，即返回值类型不能用于区分方法，因为方法可以没有返回值。
　　2） 重载方法之间是以所带参数的个数及相应参数的数据类型来区分的。
　　下边我们举例说明方法重载的应用。例如，在Citizen类中添加如下的构造方法：
　　public Citizen()
　　{
　　name=＂无名＂;
　　alias=＂匿名＂;
　　sex=＂ ＂;
　　brithday=new Date();
　　homeland=＂ ＂;
　　ID=＂ ＂;
　　}
　　然后再添加如下3个显示对象属性的成员方法：
　　/*****显示3个字符串属性值的方法****/
　　public void display(String str1,String str2,String str3)
　　{
　　System.out.println(str1+＂ ＂+str2+＂ ＂+str3);
　　}
　　/*****显示2个字符串属性值和一个日期型属性的方法****/
　　public void display(String str1,String str2,Date d1)
　　{
　　System.out.println(str1+＂ ＂+str2+＂ ＂+d1.toString());
　　}
　　/*****显示3个字符串属性值和一个日期型属性的方法****/
　　public void display(String str1,String str2,Date d1,String str3)
　　{
　　System.out.println(str1+＂ ＂+str2+＂ ＂+d1.toString()+＂ ＂+str3);
　　}
　　在Citizen类中添加上述的方法之后，我们给出一个测试重载方法的例子：
　　例4.6 使用Citizen类创建对象，显示对象的不同属性值。
　　/*这是一个简单的测试程序
　　* 程序的名字是：TestCitizenExam4_6.java
　　* 程序的目的是演示重载方法的使用。
　　*/
　　public class TestCitizenExam4_6
　　{
　　public static void main(String [] args)
　　{
　　Citizen p1,p2; //声明对象
　　p1=new Citizen(); //创建对象
　　p2=new Citizen(＂钱二＂,＂发烧游二＂,＂男＂,new Date(＂12/23/88＂),＂杭州＂,＂暂无＂);
　　System.out.println(＂-----对象p1-----＂);
　　p1.display(p1.name,p1.alias,p1.sex); //显示姓名、别名、性别
　　p1.display(p1.name,p1.alias,p1.brithday); //显示姓名,别名,生日
　　p1.display(p1.name,p1.sex,p1.brithday,p1.ID);//显示姓名,性别,生日及出生地
　　System.out.println(＂-----对象p2-----＂);
　　p2.display(p2.name,p2.alias,p2.sex); //显示姓名、别名、性别
　　p2.display(p2.name,p2.sex,p2.brithday,p2.homeland);//显示姓名,性别,生日及出生地
　　p2.display(p2.name,p2.ID,p2.brithday,p2.sex);//显示姓名,身份标识,生日,性别
　　}
　　}
　　编译、运行程序。程序执行结果如图4-5所示。
　　请读者认真阅读程序，理解重载方法的应用。
　　由方法的重载实现了静态多态性（编译时多态）的功能。在很多情况下使用重载非常方便，比如在数学方法中求绝对值问题，按照Java中的基本数据类型byte、short、int、long、float、double，在定义方法时，如果使用六个不同名称来区分它们，在使用中不但难以记忆还比较麻烦。若使用一个名字abs()且以不同类型的参数区分它们，这样做既简洁又方便。4.4.3 静态(static)方法
　　所谓静态方法，就是以＂static＂修饰符说明的方法。在不创建对象的前提下，可以直接引用静态方法，其引用的一般格式为：
　　类名.静态方法名( [ 实参表 ] )
　　一般我们把静态方法称之为类方法，而把非静态方法称之为类的实例方法（即只能被对象引用）。
　　1. 使用方法注意事项
　　在使用类方法和实例方法时，应该注意以下几点：
　　1）当类被加载到内存之后，类方法就获得了相应的入口地址；该地址在类中是共享的，不仅可以直接通过类名引用它，也可以通过创建类的对象引用它。只有在创建类的对象之后，实例方法才会获得入口地址，它只能被对象所引用。
　　2）无论是类方法或实例方法，当被引用时，方法中的局部变量才被分配内存空间，方法执行完毕，局部变量立该释放所占内存。
　　3）在类方法里只能引用类中其他静态的成员（静态变量和静态方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的变量和方法，需要创建类的对象后才能使用；而类方法在使用前不需要创建任何对象。在非静态的实例方法中，所有的成员均可以使用。
　　4）不能使用this和super关键字（super关键字在后面章节中介绍）的任何形式引用类方法。这是因为this是针对对象而言的，类方法在使用前不需创建任何对象，当类方法被调用时，this所引用的对象根本没有产生。
　　下边我们先看一个示例.
　　例4.7 在类中有两个整型变量成员，分别在静态和非静态方法display()中显示它们。若如下的程序代码由错，错在哪里，应如何改正。
　　public class Example4_7
　　{
　　int var1, var2;
　　public Example4_7()
　　{
　　var1=30;
　　ver2=85;
　　}
　　public static void display()
　　{
　　System.out.println(＂var1=＂+var1);
　　System.out.println(＂var2=＂+var2);
　　}
　　public void display(int var1,int var2)
　　{
　　System.out.println(＂var1=＂+var1);
　　System.out.println(＂var2=＂+var2);
　　}
　　public static void main(String [] args)
　　{
　　Example4_7 v1=new Example4_7();
　　v1.display(v1.var1,v1.ver2);
　　display();
　　}
　　}
　　编译程序，编译系统将显示如下的错误信息：
　　Example4_7.java:11: non-static variable var1 cannot be referenced from a static context
　　System.out.println(＂var1=＂+var1);
　　^
　　Example4_7.java:12: non-static variable var2 cannot be referenced from a static context
　　System.out.println(＂var2=＂+var2);
　　^
　　2 errors
　　我们可以看出两个错误均来自静态方法display()，错误的原因是在静态方法体内引用了外部非静态变量，这是不允许的。此外，也应该看到在非静态方法display()中设置了两个参数用于接收对象的两个属性值，这显然是多余的，因为非静态方法由对象引用，可以在方法体内直接引用对象的属性。
　　解决上述问题的方法是：
　　1） 将带参数的display()方法修改为静态方法，即添加修饰符static；
　　2） 将不带参数的display()方法修改为非静态方法，即去掉修饰符static；
　　3） 修改main()中对display()方法的引用方式，即静态的方法直接引用，非静态的方法由对象引用。
　　2. main() 方法
　　我们在前边的程序中已经看到了main()方法的应用。main()方法就是一个静态的方法，main()方法也是一个特殊的方法，在Java应用程序中可以有许多类，每个类也可以有许多方法。但解释器在装入程序后首先运行的是main()方法。
　　main()方法和其他的成员方法在定义上没有区别，其格式如下：
　　public static void main(String [] args)
　　{
　　//方法体定义
　　………
　　}
　　其中：
　　1） 声明为public以便解释器能够访问它。
　　2） 修饰为static是为了不必创建类的实例而直接调用它。
　　3） void 表明它无返回值。
　　4） 它带有一个字符串数组参数（有关数组的内容，将在后边的章节介绍），它可以接收引用者向应用程序传递相关的信息，应用程序可以通过这些参数信息来确定相应的操作，就象其他方法中的参数那样。
　　main()方法不能象其他的类方法那样被明确地引用用，那么如何向main()方法传递参数呢？我们只能从装入运行程序的命令行传递参数给它。其一般格式如下：
　　java 程序名 实参列表
　　其中：
　　1）java是解释器，它将装入程序并运行之。
　　2）程序名是经javac 编译生成的类文件名，也就是应用程序的文件名。
　　3）当实参列表包含多个参数时，参数之间以空格分隔，每个参数都是一个字符串。需要注意的是，如果某个实参字符串中间包含空格时，应以定界符双引号(＂ ＂)将它们引起来。
　　尽管数组部分的内容还没有介绍，但还是要举一个简单的例子说明main()方法参数的传递及操作。
　　例4.8 从命令行传递＂This is a simple Java program. ＂,＂ok!＂两个字符串并显示。程序参考代码如下：
　　/**这是一个简单的演示程序，程序名为 CommandExam4_8.java
　　*其目的是演示接收从命令行传递的参数并显示。
　　*/
　　class CommandExam4_8
　　{
　　public static void main(String [ ] args)
　　{
　　System.out.println(args[0]); //显示第一个字符串
　　System.out.println(args[1]); //显示第二个字符串
　　}
　　}
　　在命令提示符下编译、运行程序。操作步骤及执行结果如图4-6所示。4.4.4 最终（Final）方法
　　在Java中，子类可以从从父类继承成员方法和成员变量，并且可以把继承来的某个方法重新改写并定义新功能。但如果父类的某些方法不希望再被子类重写，必须把它们说明为最终方法，final修饰即可。
　　所谓最终方法，是指不能被子类重写（覆盖）的方法。定义final方法的目的主要是用来防止子类对父类方法的改写以确保程序的安全性。
　　一般来说，对类中一些完成特殊功能的方法，只希望子类继承使用而不希望修改，可定义为最终方法。定义最终方法的一般格式如下：
　　[访问限定符] final 数据类型 最终方法名([参数列表])
　　{
　　//方法体代码
　　………
　　}
　　我们将会在后边的章节中看到最终方法的例子。4.5 变量的进一步讨论
　　在前边的例子中，我们已经看到了变量的应用。和方法类似，我们可以把变量分为静态(static)变量、最终变量（final）和一般变量。一般把静态变量称为类变量，而把非静态变量称为实例变量。
　　1.实例变量和类变量
　　下边我们通过例子来讨论类变量和实例变量之间的区别。
　　例4.9 编写一个学生入学成绩的登记程序，设定录取分数的下限及上限（满分），如果超过上限或低于下限，就需要对成绩进行审核。程序参考代码如下：
　　/* 这是一个学生入学成绩登记的简单程序
　　* 程序的名字是：ResultRegister.java
　　*/
　　import javax.swing.*;
　　public class ResultRegister
　　{
　　final int MAX=700; //分数上限
　　final int MIN=596; //分数下限
　　String student_No; //学生编号
　　int result; //入学成绩
　　public ResultRegister(String no, int res) //构造方法
　　{
　　String str;
　　student_No=no;
　　if(res>MAX || resMAX || resMAX || res

谁才是中国当代真正的企业家？谢谢邀答。据平面媒体报道与世人口碑相传，获中国当代真正企业家的有玻璃大王曹德旺，格力女强人董明珠，华为任正非。当然还有若干有良心的企业家，但都没有以上三人驰名！谢谢阅读！正确的路线近期很多用户的花呗都被关闭了，这意味着什么？也包括网商贷和借呗。这就是阿里系出事的后果，银行对信贷审核更严格，稍微有一点不符合大数据的就会关停，以前可能还有些松动和容忍，现在0容忍。你足额还完款后，额度还逐渐降低，不排除全部拥有6亿用户的QQ，想要留住00后文AI财经社魏一宁编辑杨洁2021年11月，许多QQ用户发现，打开PC端QQ私聊窗口的时候，窗口变宽了一圈，因为聊天窗口右边的QQ秀界面消失了。2020年12月，QQ秀付费服务红钻Facebook加密货币项目负责人要离职，Diem数字货币再遇阻北京商报讯（记者汤艺甜）当地时间11月30日，Facebook母公司Meta的加密货币项目负责人大卫马库斯（DavidMarcus）周二宣布，他将于年底离职。据了解，马库斯于201在人人喊打中，联想集团如何突围？联想被亿万大众这座铁壁铜墙包围着，想突破是自取灭亡。要解决自身包袱，除非把债务还清后将主体企业归还中科院，但如果有违法犯罪行为，那就应当投案自首，以求宽大处理。要技术没技术，资不抵苹果官方magesafe外接电池加13PM使用前些天入了一个苹果官网的外接电池，之前用过华强北的，也用过其他第三方的，搭配过12pm使用，说一下对比体验。华强北12pm一言难尽这是我第一次用磁吸的组合，咋说好，逼格够了，但是体为啥现在很多人选择国产手机？国内手机厂商都在加大自己手机短板的研发，现在国产知名手机已经可以和国外的手机平起平坐了，有些品牌在某个手机领域表现优异，硬件参数要超过国外品牌，这也是让更多国人选择了我们国产手机的您是怎么了解到头条，因为什么才选择加入头条的呢，您会放弃吗？感谢邀请回答问题！当初，了解今日头条，也是玩电脑刷手机时，一个偶然之间无意的机会，发现今日头条的。发现今日头条这个平台以后，从浏览今日头条诸多栏目的过程中，自己也从多角度进行了进一哈啰出行基石投资顺丰同城，加快两轮换电新基建布局11月30日，哈啰出行宣布与顺丰同城达成战略合作，双方在未来将携手共建两轮电动车换电新基建，持续提升城市便捷服务能力。据顺丰同城招股说明书披露，哈啰已在近期加入了顺丰同城港股IPO成交价5。73亿元！乐视大厦总算卖出去了贾老板下周能回来吗11月30日，乐视大厦（即乐视网公司总部乐融大厦）终于卖出去了，全程仅有北京衡盈物业管理有限公司一家参与竞拍，最终成交价即底价5。73亿元。说来也有趣，北京寸土寸金，乐视大厦两次拍长安加速电气化转型，与华为宁德时代共同造车随着新能源汽车的风向越来越明显，很多品牌都开始了电气化转型，尤其是国产品牌，电气化转型的速度远远超过了合资品牌。像比亚迪吉利北汽这些传统汽车品牌，新能源都做得不错。而同样作为老牌车
<<<<<<－>>>>>>