Java程序设计课件2第二章 类和对象

《Java程序设计》课程1、面向对象程序设计的基本概念；

主要内容2、类和对象；3、类的继承和多态。Java程序设计《Java程序设计》课程学习目标了解面向对象程序设计方法的特征和作用；掌握定义类和产生对象的方法；掌握类中不同成员的作用；了解继承的概念和用法；掌握用方法的重写实现多态。《Java程序设计》课程

2.1类和对象2.1.1项目描述设计一个动态整型数组类，可以实现添加、插入、删除，显示功能。2.1.2项目知识准备（1）面向过程和面向对象●面向过程是以过程为中心的编程方法，主要特点是：认为一个系统应该划分为数据和功能，并且数据和加工数据的功能是分离的；分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，然后依次调用，面向过程最重要的是模块化的设计方法。●面向对象是以对象（实体）为中心的编程方法，主要特点是：研究客观存在的事物特征，运用人类的自然思维方式（如抽象、分类）来构造软件系统；将数据和功能有机结合起来，把数据和相关操作合成为一个整体，隐藏处理细节，并对外显露一些对话接口，来实现对象之间的联系；

采用继承的方式，让对象具有可扩展性。（2）类的定义 抽取同类实体的共同性，自定义出一种包括数据和相关操作的模型，称之为类。例如，我们可以抽象出公司员工的共同特征和行为，构建一个模型：

员工的特征：姓名、性别、年龄

员工的行为：工作、休息、介绍自己

根据员工的特征和行为，可以定义员工类别：《Java程序设计》课程

2.1类和对象案例2-1：员工类的定义publicclassEmployee{//员工类

//类成员定义publicStringname;//员工姓名（数据成员）publicStringsex;//员工性别（数据成员）publicintage;//员工年龄（数据成员）

publicvoidwork()//工作（方法成员）

{System.out.println(name+"在工作。");} publicvoidrest()//休息（方法成员）

{ System.out.println(name+"在休息。");} publicvoidintroduce()//介绍自己（方法成员）

{ System.out.println("我叫"+name+"，"+sex+"，"+age+"岁");}}《Java程序设计》课程

2.1类和对象3）创建对象根据类这个模型，可以创建多个实体，也称为对象（object），类是客观事物的抽象和概括，对象是客观事物的具体实现。

下面的程序创建了两个员工，并执行相关动作：

案例2-2：创建员工对象importcn.cqvie.chapter02.exam1.Employee;classTest{ publicstaticvoidmain(Stringargs[]) { Employeeemp1,emp2;//定义对象指针（定义时为空指针）emp1=newEmployee();//用new关键字创建Employee对象，并将指针指向对象

emp2=newEmployee();//用new关键字创建Employee对象，并将指针指向对象

="马腾云";emp1.sex="男";emp1.age=30;//给员工1的属性赋值

="范小冰";emp2.sex="女";emp2.age=28;//给员工2的属性赋值

emp1.work();//调用对象emp1的work方法

emp1.rest();//调用对象emp1的rest方法

roduce();//调用对象emp1的introduce方法

roduce();//调用对象emp2的introduce方法

}}《Java程序设计》课程

2.1类和对象（4）构造方法构造方法也叫构造函数、构造器（Constructor），用来创建类的实例化对象，可以完成创建对象时的初始化工作。构造方法具有如下特点：●与类的名称相同●函数定义时不含返回值类型，不能在方法中用return语句返回值●访问权限一般为public案例2-3：使用构造方法packagecn.cqvie.chapter02.exam3;

classEmployee{//员工类

publicStringname;//员工姓名（数据成员）

publicStringsex;//员工性别（数据成员）

publicintage;//员工年龄（数据成员）

publicEmployee(Stringname,Stringsex,intage){//构造方法（3个参数）

=name;this.sex=sex;this.age=age;//属性设置为传人的参数值

} publicEmployee(){//构造方法（无参数）

this("无名氏","男",18);//通过this关键字调用另一个构造函数，将属性设置为默认值《Java程序设计》课程

2.1类和对象

} publicvoidwork(){//工作（方法成员）

System.out.println(name+"在工作。"); } publicvoidrest(){//休息（方法成员）

System.out.println(name+"在休息。"); } publicvoidintroduce(){//介绍自己（方法成员）

System.out.println("我叫"+name+"，"+sex+"，"+age+"岁"); }}publicclassTest{ publicstaticvoidmain(Stringargs[]){ Employeeemp1,emp2;//定义对象指针（定义时为空指针）

emp1=newEmployee();//调用无参数构造方法创建对象

emp2=newEmployee("马腾云","男",30);//调用含3个参数的构造方法创建对象

emp1.introduce();//调用对象emp1的introduce方法

emp2.introduce();//调用对象emp2的introduce方法

}}《Java程序设计》课程

2.1类和对象（5）静态成员静态成员用static关键字进行修饰，表示“静态”或者“全局”的意思，可以用来修饰成员变量和成员方法，也可以形成静态static代码块。被static修饰的成员独立于任何对象，能被该类的所有对象共享。静态数据成员在程序运行期间一直存在，不会因为对象的消亡而被释放。静态方法中只能访问静态成员，不能访问非静态成员，也不能使用this、super等关键字。下面的代码用静态成员实现单例模式，确保该类只能产生唯一的对象：publicclassSingleton{privateSingleton(){}//构造方法设置为私有，禁止用new产生对象

privatestaticSingletonsingle=null;//静态工厂方法（必须调用该方法获得对象）//调用格式：Singleton.getInstance();publicstaticSingletongetInstance(){if(single==null){//确保对象只生成一次

single=newSingleton();}returnsingle;}}《Java程序设计》课程

2.1类和对象（5）用包来管理类在一个比较大的程序中，类的名字可能会冲突，包就像文件夹一样，将同名的类装到不同的包中，可以避免冲突。①申明包申明包的格式是：package包名;JavaSE中自带的包命名通常以java开头，一些扩展包命名以javax开头。自己定义的包，通常用公司域名的倒写加上项目名作为包名，比如公司域名为，开发的项目为project1，则包名为ject1。②引用包对包的引用需要import关键字，格式是：“import包名.类名;”。如果要引用包中的所有类，格式是：“import包名.*;”。默认情况下，java.lang包中的类自动引入，无需用import语句显式引入。例如，A类属于项目project1，B类属于项目projrct2，B类要引用A类，则程序为：《Java程序设计》课程

2.1类和对象//A.javapackageject1;//该类所属的包publicclassA{…}

//B.javapackageject2;//该类所属的包importject1;//引用的包publicclassB{ publicstaticvoidmain(Stringargs[]) { Aobj=newA();//使用A类}}《Java程序设计》课程

2.1类和对象2.1.3项目实施（1）功能分析

列表类要实现一组整型数据的存储，并记住实际存入的整数个数，因此需要定义的数据成员包括一个整型数组arr和实际长度length。列表要具备的添加、插入、删除、显示功能，通过定义相应的方法来实现。（2）编码通过分析我们可以编写以下代码实现功能：classMyList//列表类{ privateint[]a;//存放数据的数组

privateintlength;//数组实际长度

publicMyList()//构造函数

{ a=newint[100]; length=0; } publicvoidadd(intx)//在列表末尾添加元素x { a[length]=x; length++;《Java程序设计》课程

2.1类和对象 } publicvoidinsert(intn,intx)//在第n个位置前面插入元素x（n从0开始）

{ if(n<0)n=0; if(n>length)n=length; for(inti=length-1;i>=n;i--)a[i+1]=a[i]; a[n]=x; length++;//添加后长度加1 } publicvoiddelete(intn)//删除第n个元素（n从0开始）

{ if(n<0||n>length-1)return; for(inti=n;i<=length-2;i++)a[i]=a[i+1]; length--;//删除后长度减1 } publicintget(intn)//获取第n个元素值

{ returna[n]; } publicintgetLength()//获取列表长度

{《Java程序设计》课程

2.1类和对象 returnlength; } publicvoidshow() { for(inti=0;i<length;i++) System.out.print(a[i]+""); System.out.println(); }}publicclassTest{publicstaticvoidmain(String[]args){ MyListlist=newMyList(); list.add(10);list.add(20);list.add(30); list.show(); list.insert(2,75); list.show(); list.delete(1); list.show(); }}《Java程序设计》课程

2.1类和对象（3）调试运行，显示结果该程序的运行结果如图2.1所示：《Java程序设计》课程

2.1类和对象2.1.4能力拓展（1）选择题①下列哪个类声明是正确的()

A、publicvoidHi｛…｝B、publicclassMove()｛…｝

C、publicclassvoidnumber{…}D、publicclassCar｛…｝②下面的方法声明中，哪个是正确的（）A、publicclassmethodName(){}B、publicvoidintmethodName(){}C、publicvoidmethodName(){}D、publicvoidmethodName{}③下面对构造方法的描述不正确是()。A、系统提供默认的构造方法 B、构造方法可以有参数，也可以有返回值C、构造方法可以重载 D、构造方法可以设置参数

④设

A为已定义的类名，下列声明A类的对象a的语句中正确的是

()。

A、

floatAa;B、

publicAa=A(); C、

Aa=newint();D、Aa=newA();《Java程序设计》课程

2.1类和对象⑤关键字（

）表示一个类定义的开始。A、

declareB、newC、

classD、以上答案都不对（2）填空题①在Java程序中定义的类中包括有两种成员，分别是：

、

。②

是Java语言中定义类时必须使用的关键字。③

是抽象的，而

是具体的。④定义在类中方法之外的变量称为

。

⑤下面是一个类的定义，请将其补充完整。

class

{ privateStringname; privateintage; publicStudent(

s,inti){ name=s;age=i;《Java程序设计》课程

2.1类和对象}}（3）编程题①设计一个长方形类，成员变量包括长和宽。类中有计算面积和周长的方法，并有相应的setter方法和getter方法设置和获得长和宽，并编写测试类进行功能测试。②改进列表类，增加一个构造方法，可以设置数组的最大长度，并增加查找、排序、逆序功能。《Java程序设计》课程

2.2封装、继承和多态2.2.1项目描述设计一个员工工资管理程序，用计算公司不同类型员工的工资，并打印出收入清单。2.2.2项目知识准备（1）面向对象设计的封装性封装是把类设计成一个黑匣子，将将里面包含的某些数据和操作隐藏起来，对外公开特定的操作接口函数进行访问，这样可以避免外部对内部的干扰。对类成员的访问权限包括：公有（public）、私有（private）、保护（protected）、默认。●公有（public）用public修饰的类成员（包括变量和方法）称为公有的，公有成员允许应用程序中所有的方法访问，不仅允许类内部的方法访问，也允许同一个包或不同包中的类方法访问。这里的访问指存取公有数据，调用公有方法。《Java程序设计》课程

2.2封装、继承和多态案例2-4：公有成员的可访问性classMyClass{publicintx;//公有变量

publicvoidsetX(inti)//公有方法

{x=i;} publicvoidshowX()//公有方法

{ System.out.println("调用showX，x="+x);}}publicclassTest{ publicstaticvoidmain(Stringargs[]) { MyClassobj=newMyClass();obj.setX(20);//调用类的公有方法给公有变量赋值

obj.showX();//调用类的公有方法显示公有变量的值

obj.x=100;//直接给obj对象的公有变量赋值

System.out.println("直接输出x="+obj.x);//直接输出公有变量的值

}}《Java程序设计》课程

2.2封装、继承和多态●私有（private）用private修饰的类成员称为私有的，类的私有成员只能被这个类的方法直接访问，而不能被类以外的方法访问。一般把不需要外界知道的数据或操作定义为私有成员，这样既有利于数据的安全性，也符合隐藏内部信息处理细节的原则。在案例2-3中，如果将MyClass类的成员x定义为private，main方法中访问obj.x的代码会出错，但是MyClass类中的setX和showX方法允许访问私有成员x。案例2-5：隐藏数据成员publicclassEmployee//Employee.java{privateStringname;//姓名

privateStringsex;//性别

privateintage;//年龄

privatefloatsalary;//基本工资

publicStringgetName(){ returnname;}publicvoidsetName(Stringname){ =name;《Java程序设计》课程

2.2封装、继承和多态}publicStringgetSex(){ returnsex;}publicvoidsetSex(Stringsex){ this.sex=sex;}publicintgetAge(){ returnage;}publicvoidsetAge(intage){ this.age=age;}publicfloatgetSalary(){ returnsalary;}publicvoidsetSalary(floatsalary){ this.salary=salary;}

《Java程序设计》课程

2.2封装、继承和多态publicEmployee()//构造方法（无参数）{this("无名氏","男",18,2000);}

publicEmployee(Stringname,Stringsex,intage,floatsalary)//构造方法

{ =name;this.sex=sex; this.age=age;this.salary=salary;}}提醒：上面所说的某个类可“访问”，是指在某个类的方法中，可以读写本类或其它类的数据（变量）成员，或可以调用本类或其它类的方法（函数）成员，只有在类的方法中（函数体中），才能完成“访问”这个动作。《Java程序设计》课程

2.2封装、继承和多态类成员的可访问性总结如下：表2-1类成员的可访问性

同一个类同一个包中的类其它包中的子类其它包中的类公有（public）√√√√保护（protected）√√√×默认√√××私有（private）√×××《Java程序设计》课程

2.2封装、继承和多态（2）面向对象设计的继承性继承就是以原有类为基础来创建一个新类，新类能传承原有类的数据和行为，并能扩充新的成员，从而达到代码复用的目的。在继承关系中原有的类称为父类（或基类），新的类称为子类（或派生类）。在Java中只允许单重继承，一个父类可以有多个子类，但一个子类只能有一个父类，但支持多层继承，即子类还可以有子类。这样的继承关系就形成了继承树，如图2.1所示。《Java程序设计》课程

2.2封装、继承和多态定义继承关系的语法格式是：

[访问权限]class类名

extends父类名{//……（类体）}如果没有extends子句，则该类默认继承自Object类。用final修饰的类不能被继承。子类继承父类之后，具有如下特点：●继承到了父类所有的属性和方法，即父类将数据和方法成员传递给子类：案例2-6：类的继承和传递性classEmployee//Employee.java{privateStringname;//姓名

privateStringsex;//性别

privateintage;//年龄

privatefloatsalary;//基本工资

publicEmployee(Stringname,Stringsex,intage,floatsalary)//构造方法

{=name;this.sex=sex;this.age=age;this.salary=salary;}《Java程序设计》课程

2.2封装、继承和多态publicEmployee()//构造方法（无参数）{this("无名氏","男",18,2000);}publicStringgetName(){ returnname;}publicvoidsetName(Stringname){ =name;}publicStringgetSex(){returnsex;}publicvoidsetSex(Stringsex){ this.sex=sex;}publicintgetAge(){returnage;}publicvoidsetAge(intage){this.age=age;}publicfloatgetSalary(){returnsalary;}publicvoidsetSalary(floatsalary){this.salary=salary;}}classManagerextendsEmployee{privatefloatbonus;//经理的奖金

publicfloatgetBonus(){returnbonus;}publicvoidsetBonus(floatbonus){this.bonus=bonus;}}《Java程序设计》课程

2.2封装、继承和多态publicclassTest{//test.java publicstaticvoidmain(String[]args){Employeeemployee=newEmployee();//创建Employee对象并为其赋值

employee.setName("李小洪");employee.setSalary(2000);employee.setAge(20);Managermanager=newManager();//创建Manager对象并为其赋值

manager.setName("雷小军");manager.setSalary(3000);manager.setAge(30);manager.setBonus(2000);//输出经理和员工的属性值

System.out.println("员工的姓名："+employee.getName());System.out.println("员工的工资："+employee.getSalary());System.out.println("员工的年龄："+employee.getAge());System.out.println("经理的姓名："+manager.getName());System.out.println("经理的工资："+manager.getSalary());System.out.println("经理的年龄："+manager.getAge());System.out.println("经理的奖金："+manager.getBonus()); }}《Java程序设计》课程

2.2封装、继承和多态●子类可对父类方法的访问权限如下表：表2-2子类对父类成员的可访问性

同一包中的子类同一个包中的非子类不同包中的子类不同包中的非子类公有（public）√√√√保护（protected）√√√×默认√√××私有（private）××××《Java程序设计》课程

2.2封装、继承和多态●构造子类时，要先调用父类的构造方法案例2-7：继承关系中构造方法的调用顺序classA{ publicA() { System.out.println("A类的构造方法被调用"); }}classBextendsA{ publicB()//默认会先调用A类的无参构造方法

{ System.out.println("B类的构造方法被调用"); }}

publicclassTest{ publicstaticvoidmain(String[]args){ Bobj=newB(); }}《Java程序设计》课程

2.2封装、继承和多态输出结果如下：《Java程序设计》课程

2.2封装、继承和多态（3）面向对象设计的多态性多态指同类事物有多种状态。多态有两种表现形式：覆盖和重载。覆盖是指子类重新定义父类的方法，而重载是指同一个类中存在多个同名方法，而这些方法的参数不同。①方法的重载(overload)重载是指同一个类中存在多个名字相同的方法，这些方法或参数个数不同，或参数类型不同，或两者都不同。方法重载不考虑返回值。重载解决了方法命名困难的问题，同样的操作采用同样的名称，也增强了程序的可读性。例如，System.out.print可以打印不同类型的数据，就是依赖重载来实现的：publicvoidprint(booleanb)publicvoidprint(charc)publicvoidprint(inti)publicvoidprint(longl)publicvoidprint(floatf)publicvoidprint(doubled)构造方法也可以重载，在案例2-3中，Employee类包含两个构造方法，一个无参数，一个有参数。《Java程序设计》课程

2.2封装、继承和多态②方法的覆盖(override)在继承的过程中，父类的某些方法可能由不符合子类的需要，java允许子类对父类的同名方法进行重新定义。如果子类方法与父类方法同名，则子类覆盖超类中的同名方法。在进行覆盖时，应注意以下三点：●子类不能覆盖超类中声明为final或static的方法；●子类必须覆盖超类中声明为abstract的方法，或者子类也声明为abstract；●子类覆盖超类中同名方法时，子类方法声明必须与超类被覆盖方法的声明一样。案例2-8：子类覆盖父类的方法classA{ publicvoidm1() { System.out.println("调用A类的m1方法。"); } publicvoidm2() { System.out.println("调用A类的m2方法。"); }}classBextendsA{ publicvoidm1()《Java程序设计》课程

2.2封装、继承和多态 { System.out.println("调用B类的m1方法。"); } publicvoidm2(intx) { System.out.println("调用B类的m2方法（带参数）。"); } }publicclassTest{ publicstaticvoidmain(String[]args){ Aobj1=newA(); Bobj2=newB(); obj1.m1(); obj1.m2(); obj2.m1(); obj2.m2(); obj2.m2(100); }}《Java程序设计》课程

2.2封装、继承和多态输出结果如下《Java程序设计》课程

2.2封装、继承和多态③通过父类的指针访问子类的对象通过父类的指针访问子类对象的方法时，会自动识别对象的类别，找到合适的方法进行调用。在项目实践中，经常把同一个父类继承下来的多个子类对象的指针放入集合进行管理，然后用遍历的方式来依次调用每个对象的方法。案例2-9：通过父类的指针访问子类的对象classShape//形状类{ publicvoidshow() { System.out.println("显示一个形状（实际是无法实现的）。"); }}classRectangleextendsShape//矩形类{ publicvoidshow() { System.out.println("显示一个矩形。"); }}《Java程序设计》课程

2.2封装、继承和多态classCircleextendsShape//圆形类{ publicvoidshow() { System.out.println("显示一个圆形。"); }}publicclassTest{ publicstaticvoidmain(String[]args){ Shapes;//父类的指针

s=newShape(); System.out.println("我是"+s.getClass().getName()+"类的对象。");//自报类名

s.show(); s=newRectangle(); System.out.println("我是"+s.getClass().getName()+"类的对象。");//自报类名

s.show(); s=newCircle(); System.out.println("我是"+s.getClass().getName()+"类的对象。");//自报类名

s.show(); }}《Java程序设计》课程

2.2封装、继承和多态输出结果如下：《Java程序设计》课程

2.2封装、继承和多态案例2-10：通过父类的指针数组（集合）来管理多个子类的对象classShape//形状类{ publicvoidshow() {

System.out.println("显示一个形状（实际是无法实现的）。"); }}classRectangleextendsShape//矩形类{ publicvoidshow() {

System.out.println("显示一个矩形。"); }}classCircleextendsShape//圆形类{ publicvoidshow() {《Java程序设计》课程

2.2封装、继承和多态

System.out.println("显示一个圆形。"); }}

publicclassTest{

publicstaticvoidmain(String[]args){ Shape[]s=newShape[3];//包含3个对象指针的数组（集合）

s[0]=newShape();//第0个指针指向shape对象

s[1]=newRectangle();//第1个指针指向rectangle对象

s[2]=newCircle();//第2个指针指向circle对象

for(inti=0;i<s.length;i++)//遍历数组

s[i].show();//依次调用每个指针所指对象的show方法

}}《Java程序设计》课程

2.2封装、继承和多态输出结果如下《Java程序设计》课程

2.2封装、继承和多态2.2.3项目实施（1）功能分析

假设某公司员工包括经理、销售员、技术员这这几类，都是员工(Employee)类的子类，先定义创建各个员工对象，设置属性，再用一个数组（集合）将所有员工组织起来，用循环遍历每个员工，显示收入情况。（2）编码通过分析我们可以编写以下代码实现功能：//Employee.javapublicclassEmployee//员工{privateStringname;//姓名

privatefloatsalary;//基本工资

publicEmployee(Stringname,floatsalary)//构造方法

{ =name;this.salary=salary;}publicStringgetName(){ returnname;}publicvoidsetName(Stringname){ =name;}publicfloatgetSalary(){returnsalary;}publicvoidsetSalary(floatsalary){this.salary=salary;}publicfloatgetEarnings()//总收入

{ returnsalary;}《Java程序设计》课程

2.2封装、继承和多态}//Manager.javapublicclassManagerextendsEmployee//经理

{ privatefloatbonus;//经理的奖金

publicfloatgetBonus(){returnbonus;}publicvoidsetBonus(floatbonus){this.bonus=bonus;}publicManager(Stringname,floatsalary){ super(name,salary); }publicfloatgetEarnings()//总收入（覆盖父类方法）

{returnthis.getSalary()+this.getBonus();}}//Seller.javapublicclassSellerextendsEmployee//销售员{ privatefloatdeduct;//销售提成

publicSeller(Stringname,floatsalary){ super(name,salary); }《Java程序设计》课程

2.2封装、继承和多态 publicfloatgetDeduct(){ returndeduct; } publicvoidsetDeduct(floatdeduct){ this.deduct=deduct; } publicfloatgetEarnings()//总收入（覆盖父类方法）

{returnthis.getSalary()+this.getDeduct(); }}//Technician.javapublicclassTechnicianextendsEmployee//技术员{ privatefloatroyalty;//项目提成

publicfloatgetRoyalty(){ returnroyalty; } publicvoidsetRoyalty(floatroyalty){ this.royalty=royalty; } publicTechnician(Stringname,floatsalary){《Java程序设计》课程

2.2封装、继承和多态 super(name,salary); } publicfloatgetEarnings()//总收入（覆盖父类方法）

{returnthis.getSalary()+this.getRoyalty();}}//Test.javapublicclassTest{ publicstaticvoidmain(String[]args){ Managerm=newManager("马腾云",3500);//经理

m.setBonus(5000); Sellers1=newSeller("雷小军",2000);//销售员

s1.setDeduct(3000); Sellers2=newSeller("李小宏",2000);//销售员

s2.setDeduct(3500); Techniciant1=newTechnician("张龙",2500);//技术员

t1.setRoyalty(3500); Techniciant2=newTechnician("赵虎",3000);//技术员

t2.setRoyalty(3500);《Java程序设计》课程

2.2封装、继承和多态

Employee[]emp=newEmployee[]{m,s1,s2,t1,t2}; //列举每个员工的收入

for(inti=0;i<emp.length;i++) { System.out.println("姓名:"