Java类、对象与接口

格式：ppt
大小：3.11 MB
文档页数：53

下载文档原格式

Java中抽象类与接口的比较

的抽象。比如我们要开发一个管理乐
能被实例化的，更重要的是接口中的方法都是抽象的，这些方法要到实现
器的软件，会发现问题领域存在着笛这个接口的类中去实现。接口的本质子、古筝等一些具体概念，它们是不是在ｃａｓｓｌｓｅ之间建立起一个协议，它同的，但都属于乐器，这里的乐器就
抽象类和接口都位于继承树的上
层，它们具有以下相同点：
ｍｌｍｅｔａｉ｛系，接口的多继承性正好可以解决这ｉｐｅｎｓＲｄｏ
ｖｉｉ（ｌ・；ｏｄｗｒｅ）ｌ：ｔ＿
１）都代表系统的抽象层。２）都不能被实例化。
ｐｂｉＳｒｇｗｈｔ）｛ｕｌｔｎａ（ｃｉ
ｒｔｎｅｕｒ ‘ ｎｓｒ ‘ ｔｕｍｅ ”ＩＩｎｔ
｝｝
我们知道，类可以被实例化生成法都是抽象的，没有涉及特殊手机的多个对象来使用，但抽象类不能被实任何细节，也没有涉及这些操作的具
现，因为每一种乐器的演奏和调节方
ｌ１什么是抽象类，
的两种机制，二者有很大的相似性，艾存在
本质的区别。本文从抽象类和接１３的重要性
在面向对象的概念中，所有的对式都是不同的，所以这些方法的实现
出发，分别介绍了它们的概念，并分析得出
ｖｉｅｅｖＲａｉ（；ｏｄｒｃｉｅｄｏ）
｝
３）定义类ＲａｉＰｎ继承Ｐｎ并ｄｏｅｅ
ｃａｓＲａｏｎｅｅｌｓｄｉＰｅｘｔｎｄｓＰｅｎ

Java语言中抽象类和接口的应用探究

关键词：Ｊａｖａ，抽象，接口
中图分类号：ＴＰ３９９文献标识码：Ａ
ＲｅｓｅａｒｃｈｏｎＡｂｓｔｒａｃｔＣｌａｓｓａｎｄＩｎｔｅｒｆａｃｅｉｎＪａｖａＬａｎｇｕａｇｅ
很模糊。在实际项目设计过程中，到底是要选择抽象类还是接口呢？其实，两者之间是有很大区别的，对
义。而动物类又要能被子类化，这就要求使用抽象类
（ａｂｓｔｒａｃｔｃｌａｓｓ）来解决这个问题。Ｊａｖａ中用ａｂｓｔｒａｃｔ修饰的类称为抽象类。抽象类中可以包含构造方法、成
ＺＨＡＮＧＣｈａｏ
（ＮａｎｊｉｎｇＣｏｍｍｕｎｉｃａｔｉｏｎＩｎｓｔｉｔｕｔｅｏｆＴｅｃｈｎｏｌｏｇｙ，Ｎａｎｊｉｎｇ２１１１８８，Ｃｈｉｎａ）
类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。譬如有时候，可能想要构造一个很抽象的父类对象，它可能仅仅代表一个分类或抽象
概念，它的实例没有任何意义，因此，不希望它能被实例化。例如：有一个父类 “ 动物（Ａｎｉｍａ１） ” ，它有几个子类“ 猫（Ｃａｔ） ” 、 “ 狗（Ｄｏｇ） ” 、 “ 猪（Ｐｉｇ） ” 等。动物在这里仅仅只是作为一个分类，显然动物的实例没有什么意

第四讲 java类与对象

Circular bottom:Circle Circle名 Radius:double getArea():double
方法重载
访问权限
类和对象
对象表示现实世界中某个具体的事物。抽象是从特定的实例中抽取共同的性质以形成一般化
概念的过程。对象具有两方面的含义：
在现实世界中：

是客观世界中的一个实体是一个可标识的存储区域
在计算机世界中：

类
类是用来描述一组具有共同状态和行为的对象的原型，
//App4_10.java Public class App4_10{ Pulbic static void main(String[] args){ Circle circle=［代码１］ //创建circle对象［代码２］ Circular circular= /*创建circular对象，并将circle引用传递给构造方法的参数c。*/ System.out.print(“圆锥的体积：%5.5f\n”,circular.getVolme); Circular.bottom.radius =100; System.out.printf(“圆锥的面积： %5.5f\n”,circular.getVolme); } } 执行［代码１］： Circle circle=new Circle(); 执行［代码］： Circular circular=new Circular(circle,20);
对象的组合
一个类的成员变量可以是某个类声明的变量，即可以是对象。当A类把B类的对象作为自已的成员时，称A类的对象组合了B类的对象。比如：公司组合了员工，收音机组合了电池 //Circle.java Public class Circle{ Double radius; Circle(double r){ Radius=r; } Double getArea(){ return 3.14*radius*radius; } }

JAVA篇：修饰符与接口、类、方法、成员变量、局部变量、方法块

JAVA篇：修饰符与接⼝、类、⽅法、成员变量、局部变量、⽅法块或许这是⼀个⽐较轻松简单的知识点，因为只是简单地做⼀个总览对⽐⽽已。

这周⽐较忙，祝我⾃⼰好运。

有关接⼝(interface)的修饰符，其实⼀般⽤public，也可以不加修饰词（default），或者是使⽤private修饰的声明在类的内部的内部接⼝。

不存在protected修饰的接⼝。

⽽接⼝内部可以有⽤public static final修饰的静态常量，除此之外只存在public修饰的⽅法（接⼝中⽆修饰词的⽅法也默认是public）了。

⽆论是接⼝还是接⼝中的⽅法的abstract修饰词都是隐含的，不必显式地修饰在接⼝或者⽅法前⾯。

类的访问限制修饰词与接⼝⼀样，但是还可以有⾮访问限制修饰词abstract(抽象类)和final(不可继承的类)。

类的成员变量可以被四种访问修饰词修饰，同时也可以被static(静态变量),final(常量),transtient(有关序列化特殊标识变量,具体还需要进⾏了解), volatie(线程共享变量)。

类⽅法除了访问限制修饰符，还可使⽤static（静态⽅法）,final(不可改变的⽅法),abstract(抽象的),native(⾮java实现的),synchronized(线程同步),类构造⽅法只可使⽤访问限制修饰符修饰，局部变量只能使⽤final定义常量,⽅法块可以使⽤static定义静态⽅法块和使⽤synchronized 定义线程同步的⽅法块。

java的接⼝、类1、接⼝(interface) 在java中，接⼝是⼀个抽象类型，是抽象⽅法的集合，接⼝通常以interface来声明，接⼝只能包含抽象⽅法和以static\final修饰的变量，⼀个接⼝可以继承（extends）另⼀个接⼝。

接⼝只包含要实现的⽅法，⽽类描述对象的属性和⽅法，两者实现类似但是概念不同。

java提供了类和接⼝之间的实现机制，接⼝不可被实例化，只能被实现（implements），实现接⼝的类必须实现接⼝中全部的抽象⽅法，否则该类必须使⽤abstract声明为抽象类。

实验报告

实验四类，对象和接口一.实验目的（1）掌握类的声明，对象的创建以及方法的定义和调用。

（2）掌握打包机制。

（3）掌握类的继承。

（4）掌握类接口的使用。

二、实验方案（1）//Father.java;package tom.jiafei;public class Father{int height;protected int money;public int weight;public Father(int m){money=m;}protected int getMoney(){return money;}void setMoney(int newMoney){money=newMoney;}}//Jerry.java:import tom.jiafei.Father;public class Jerry extends Father{public Jerry(){super(20);}public static void main(String args[]){Jerry jerry=new Jerry();jerry.weight=200;jerry.money=800;int m=jerry.getMoney();System.out.println("m="+m);}}（2）interface ShowMessage{void 显示商标(String s);}class TV implements ShowMessage{public void 显示商标(String s){System.out.println(s);}}class PC implements ShowMessage{public void 显示商标(String s){System.out.println(s);}}public class Example4_28{public static void main(String args[]){ShowMessage sm;sm=new TV();sm.显示商标("长城牌电视机");sm=new PC();sm.显示商标("联想奔月5008PC");}}（3）求50以内的素数//Number.javapackage sushu;//将Number.java打包到文件夹sushu中public class Number{public void prn()//创建方法prn（）{boolean flag ;for (int i=2;i<50;i++){flag = true ;//将flag初始化for (int j=2 ;j <= i/2 ; j++){ //只需对2到i/2之间取余，因为假如i/2到i有某个数x被i整除，则在2到i/2必定能找到一个数y（y*x=i）被i整除if (i%j == 0 ){flag = false ;break;//假如2到i/2有某个数被i整除，则跳出，执行下一次循环}}if (flag == true ){System.out.print(i+"\t");}//若flag为真，则i为素数，输出i的值}}}//Num.javaimport sushu.Number;//引用定义的包public class Num extends Number{public static void main(String args[]){Number num=new Number();num.prn();}}三、实验结果和数据处理（1）（2）（3）实验五数组与字符串一.实验目的（1）掌握一维数组的概念、定义和使用。

Java面向对象之接口interface入门实例

Java⾯向对象之接⼝interface⼊门实例⼀、基础概念（⼀）接⼝可以简单的理解为，是⼀个特殊的抽象类,该抽象类中的⽅法都是抽象的。

接⼝中的成员有两种：1.全局常量 2.抽象⽅法定义接⼝⽤关键字interface，接⼝中的成员都⽤固定的修饰符public来修饰。

（⼆）接⼝的特点： 1、接⼝不可以实例化。

2、接⼝的⼦类必须覆盖接⼝中的所有抽象⽅法后，才可以实例化。

否则该⼦类是抽象类。

3、接⼝是⽤来被实现的。

（三）接⼝解决的问题： 1.因为多继承调⽤的不确定性，java中是不直接⽀持多继承的，但可以通过接⼝来解决，将多继承转换成多实现。

2.因为⼦类具备所属的⽗类体系的基本功能后，还想扩展⼀些其他功能。

可以通过接⼝来完成。

3.避免单继承的局限性。

⼀个类继承另⼀个类的同时，还可以实现多个接⼝。

（四）接⼝的思想： 1.接⼝的出现扩展了功能。

2.接⼝的出现其实就是暴露出来的规则。

3.接⼝的出现降低了耦合性。

(⽤于解耦) 4.接⼝的出现，⼀⽅在使⽤接⼝，⼀⽅在实现接⼝。

（五）类与接⼝的区别： 1.类与类之间的关系是继承关系。

2.类与接⼝之间的关系是实现关系。

3.接⼝与接⼝的关系是继承关系，⽽且可以多继承。

4.抽象类中可以定义抽象和⾮抽象⽅法。

⼦类可以直接使⽤，或者覆盖使⽤。

接⼝中定义都是抽象⽅法，必须实现后才能使⽤。

5.类⽤于描述是事物的共性基本功能，接⼝⽤于定义的是事物的额外功能。

⼆、实例代码（⼀） 1.定义接⼝⼦类SubInter_1，进⾏接⼝InterA的实现 2.定义接⼝⼦类SubInter_2，进⾏接⼝InterA接⼝和InterB的多实现 3.定义接⼝⼦类SubInter_3，继承Fu类还进⾏接⼝InterA的实现 3.定义接⼝⼦类SubInter_4，继承Fu类还进⾏接⼝InterA和InterB的多实现1//定义⽗类Fu2class Fu3 {4public void show1()5 {6 System.out.println("Fu show1 ......");7 }8 }910//定义接⼝InterA11interface InterA12 {13public static final int num1 = 4; //全局常量14public abstract void show2(); //抽象⽅法15 }1617//定义接⼝InterB18interface InterB19 {20public static final int num2 = 6;21public abstract void show3();21public abstract void show3();22 }2324//定义接⼝⼦类SubInter_1，进⾏实现25class SubInter_1 implements InterA//⼦类SubInter1实现 InterA接⼝26 {27public void show2()28 {29 System.out.println("SubInter_1 InterA show2 ......");30 }31 }3233//定义接⼝的⼦类SubInter_2，进⾏多实现34class SubInter_2 implements InterA,InterB//⽤⼦类SubInter2 多实现 InterA接⼝和Inter接⼝ 35 {36public void show2()37 {38 System.out.println("SubInter_2 InterA show2 ......");39 }40public void show3()41 {42 System.out.println("SubInter_2 InterB show3 ......");43 }44 }454647//SubInter_3类继承了Fu类的基本功能，还实现了InterA接⼝的基本功能。

Java的对象、类、方法和接口

1.1什么叫对象？什么叫方法？什么叫面向对象的程序设计？面向过程的程序设计语言最重要的特点是按照解决问题的一个一个步骤来设计程序。

这种语言是与解决相对比较简单的问题，当程序规模较大时，将显得纷繁复杂。

“对象”原来是描述自然界时使用的一个词语。

比如，现在我正在写讲义，桌上的稿纸、手中的笔、案头的参考书、身后的电脑以及窗外的鸟都可以成为对象面向对象，就是将世界看成由许多彼此之间能联络的对象组成。

不少程序设计语言借用了对象这个词语作为一个专用名词，此时，对象也是具有状态和行为两个特征。

在程序设计中，对象的状态时相对处于静态的，用变量来描述和表达；而对象的行为时动态的，他们通过“方法”来实现和完成，所以方法一定是实现对象行为的语句块。

从功能上讲，方法和子程序、函数很相似。

变量和方法是彼此有关、相互依赖的。

当然，计算机都是用数据来表示对象的状态的，也是通过对数据的操作和修改来体现某个方法的功能的。

1.2 Java作为面向对象的程序设计语言有什么特点？Java是面向对象的程序设计语言，从面向对象这个角度看，体现了如下三个特点：a：封装性—面向对象的程序设计语言都是把数据和处理数据的操作结合在一起而构成一个整体，这就是对象。

对象的使用者只能看到对象的外部特性，比如，其主要功能、如何调用等，而看不到内部如何实现这些功能。

作为面向对象的程序设计语言，程序中的数据就是变量，程序对数据作处理则成为方法。

变量和方法都被封装在对象中。

所以，一个对象就是变量和方法的集合，其中变量表明这个对象的状态，方法实现这个对象所具有的行为，而且在程序中将这些变量和方法进行封装，使它们成为一个模块，再用一个名字来代表这个模块。

这样，以后得更高层的程序设计中，就不必关心某个对象的行为到底是怎样实现的。

可见，将对象封装就是为了使模块尽可能少地展现其内部细节，而只是以一种界面来面向外部。

对象的封装性减少了程序各部分之间的依赖，使程序的复杂性降低，而可靠性提高，并便于修改。

javaoop的理解

面向对象编程（Object-Oriented Programming，OOP）是一种计算机编程范式，它将程序设计看作是对象的集合，每个对象都有其自身的属性（数据）和方法（函数），对象之间可以通过消息传递进行通信和互动。

以下是关于Java中面向对象编程（Java OOP）的基本理解：类和对象：在Java中，一切都是对象，每个对象都是一个类的实例。

类是对象的模板，它定义了对象的属性和方法。

对象是类的具体实例，它包含了类中定义的属性的具体值。

封装：封装是面向对象编程的一个重要概念，它指的是将数据和操作数据的方法封装在一个类中，并对外部隐藏类的内部实现细节。

这通过访问修饰符（如public、private、protected）来实现，以确保数据的安全性和完整性。

继承：继承允许一个类继承另一个类的属性和方法，从而可以重用已有类的代码。

子类继承父类的特性，并可以添加新的属性和方法，或者重写父类的方法以满足特定需求。

多态：多态是指不同的对象可以对同一消息做出不同的响应。

它通过方法的重写和方法的重载来实现。

多态性允许你编写通用的代码，可以适用于多种不同的对象。

抽象类和接口：抽象类和接口是Java中实现抽象和多态的方式。

抽象类是不能被实例化的类，它可以包含抽象方法（没有具体实现的方法），需要子类实现。

接口是一种完全抽象的类，它只包含方法的签名，需要实现类来提供具体的方法实现。

构造函数和析构函数：在Java中，构造函数用于初始化对象的属性，析构函数（在Java中没有显式的析构函数）用于释放对象的资源。

构造函数与类同名，没有返回值，当对象创建时会自动调用。

类的关系：在面向对象编程中，类之间可以有不同的关系，包括关联、聚合和继承。

关联表示两个类之间有关系，聚合表示一个类包含了另一个类的对象，继承表示一个类从另一个类继承了属性和方法。

设计原则：面向对象编程中有一些设计原则，如单一职责原则、开闭原则、依赖倒置原则等，它们帮助开发者编写可维护、可扩展和高质量的代码。

Java程序设计精编教程5-8章知识点

b) 如果变量名由多个单词组成，从第 2 个单词开始的每个单词的首字母要大写。
方法
方法的定义包括两部分：方法声明和方法体。一般格式为：
方法声明部分 {
方法体的内容
}
方法声明
方法声明包括返回值类型、方法名和参数。
double getArea() { //返回值类型为 double，无参数。
…
}
方法的返回值类型可以是 Java 中的任意数据类型。如果一个方法不返回数据，返回值类型必须是 void。
2. 有一个类 Singleton，为该类设计单例模式（该类只能有一个实例，且不能在类的外部 new 对象），只能通过该类的静态方法 getInstance()获取该类的唯一对象。在主类 Homework2 中测试单例模式的有效性。
b) 在实例方法中，不仅可以调用实例方法，也可以调用类方法。 2) 类名调用类方法
a) 在类方法中，只能调用类方法、操作类变量。 b) 也可以通过对象调用类方法。 c) 如果一个方法不需要操作实例变量就可以实现某种功能，可以考虑将其声明为类方法。（例 5-8） 5.7 方法重载与多态 Java 中有两种多态：重载（overload）和重写（override）。方法重载（overload）：一个类中可以有多个名字相同的方法，但这些方法的参数必须不同，或者参数的个数不同，或者参数的类型不同。方法的返回值类型与重载无关。
5.8 this 关键字 this 只能出现在实例方法和构造方法（也属于实例方法）中，表示调用该方法的当前对象。一般情况下，方法中 this.实例变量的 this 可省略、类名.类变量的类名可省略，但当局部变量与成员变量同名时，
this 或类名不能省略。 5.9 包
包是 Java 语言管理类的一种机制，类似于操作系统中的目录，使用包名可以有效区分名字相同的类。包语句

java类和对象的应用实验总结

Java类和对象的应用实验总结在Java编程语言中，类（Class）和对象（Object）是两个核心的概念。

类是对象的模板或蓝图，而对象则是类的实例。

通过使用类和对象，我们可以创建具有共享属性和方法的实体，也可以创建具有独特属性和行为的实体。

以下是我对Java类和对象应用实验的一些总结：类的定义和使用：在Java中，我们使用class关键字来定义一个类。

例如，我们可以创建一个名为Person的类，该类具有name、age 和height等属性，以及eat()和sleep()等方法。

我们可以通过创建类的实例（即对象）来使用类。

对象的创建和使用：我们使用new关键字来创建一个类的实例，这个实例就是一个对象。

例如，我们可以创建一个Person类的对象，并通过调用对象的方法来执行特定的行为。

我们也可以通过访问对象的属性来获取或修改对象的状态。

继承：Java中的类可以继承其他类的属性和方法。

通过继承，我们可以创建一个新的类，该类继承了父类的所有属性和方法，并可以添加自己的属性和方法。

这个过程被称为类的扩展或继承。

多态：在Java中，一个对象可以被引用为多种类型。

例如，我们可以有一个父类类型的引用指向一个子类对象。

当调用这个对象的方法时，会根据对象的实际类型来调用相应的方法。

这就是多态性的体现。

封装：封装是Java中一个重要的面向对象编程概念。

通过封装，我们可以将数据（属性）和处理数据的方法（方法）绑定在一起，形成一个独立的实体。

封装的目的是增加安全性和简化性，用户只知道对象提供哪些方法，至于内部的具体实现细节则一概不知。

通过这些实验，我深入理解了Java的类和对象的概念，以及它们在面向对象编程中的重要性。

这些实验也帮助我理解了如何使用类和对象来设计和实现复杂的系统。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

InterfaceTest Project —Animal/Dog/Cat

通过接口可以实现多重继承，一个类只能继承（ extends）一个父类，但可以实现（implements ）多个接口 “接口”和“实现”之间是一种“特殊的继承关系” public class 类名 extends 父类 implements 接口1,接口2…
多态示例II
问题需求
开发一个DogHouse,里面有
各种类型的Dog，设计一个方法可以依次听到所有 Dog 的叫声
ObjectTest Project— DogHouse/DogHouseTest

多态现象的产生，除了通过创建对象时父类对象引用指向具体子类对象之外，还可以通过方法参数和方法返回值的形式：
接口的使用形式：
▪ 声明时采用接口，指向实现该接口的具体类对象 ▪ 方法参数为接口类型，可以传递任意实现该接口的具体类对象 ▪ 方法返回值为接口类型，可以返回任意实现该接口的具体类对象

示例
InterfaceTest Project —AnimalShouter/AnimalShouterTest
animal = new Cat();
animal.shout(); //调用Cat对象的shout方法
运行时，判断指向Dog类对象 public class Dog implements Animal{ 调用Dog类对象shout方法
public void shout(){
}
System.out.println(“汪汪汪….”); Animal animal = new Dog();} animal.shout();
Java类、对象与接口
本篇内容

回顾Java类和对象回顾面向对象三个特征
Java接口概念
Java接口与多态的关系面向接口编程
一回顾Java类和对象

在Java世界里，万物皆对象
▪ Everything is Object

面向对象程序的思维方式
▪ 尽量按照人类的自然思维方式来看待和解决问题
3.3 接口与多态

多态：
▪ 同样一个方法调用，可以有不同的具体表现形态 ▪ 多态的实现：通过将父类对象引用变量指向子类对象，来实现动态的方法调用

通过接口，是Java程序中实现多态的常见形式
▪ 接口是一种“特殊的父类”
▪ 接口中的方法都没有实现，强制要求在实现了接口的具体子类中必须重写
四、面向接口编程

使用接口：
▪ 声明时采用接口类型，其指向为具体实现类对象 ▪ 运行时，根据其指向的具体对象类型，动态调用相应方法 InterfaceTest Project —AnimalTest
Animal animal = new Dog(); animal.shout(); // 调用Dog对象的shout方法
dog = new BoltDog();
dog.bark();
此时，指向BoltDog类对象调用BoltDog类对象重写的 bark方法
public class BoltDog extends Dog{
public void bark(){ System.out.println(“吱吱~”); } }
public class Cat implements Animal{ Cat实现
Animal接口 } } public void shout(){ System.out.println(“喵喵喵….”);
接口与实现
Animal shout()
Dog shout()
Cat
shout()

接口和实现示例
1.1 自然世界中的“类”和“对象 ”
自然世界中的“类”
类
基本解释：
拼音：部首：
lèi 米
笔划： 9 五笔输入法：odu
Байду номын сангаас
类（類）很多相似事物的综合：类型，种类，类别，类群，分类笔画数：9 部首：米笔顺编号：431234134
自然世界“类”的产生

2300多年前，古希腊亚里士多德经过长期的科学实验观察，对世界上的500多种动物进行了详细分类 “鸟类”、“鱼类”等这样的 “类型”概念和词汇第一次出现在人类历史长河之中
自然世界
人类
张三、李四 …
个体
Java世界
Person class
Person
对象
二、面向对象的三个特征

面向对象程序设计的三大特征：
▪ 封装
▪ 继承
▪ 多态
2.1特征I——封装（Encapsulation）

“破坏封装”示例 ObjectTest Project——BagDog类/BagDogTest测试类
▪ 多态示例I ObjectTest —DogTest3
运行时判断指向HuskyDog类 public class HuskyDog extends Dog{ 对象,调用HuskyDog类对象重写的bark方法 public void bark(){
System.out.println(“嗷呜~”); } Dog dog = new HuskyDog(); } dog.bark();
▪ 存取权限设置不当，直接暴露信息，破坏了类的封装原则

“遵循封装”示例 ObjectTest ——Dog类/DogTest测试类
▪ 创建存取方法，并强制程序必须通过方法进行数据访问
存取方法的命名习惯：setter和getter方法

封装实现了“数据隐藏”
封装基本原则
1
将成员变量标记为私有private 提供setter和getter存取方法，标记为公开public
}
public class Dog implements Animal{ Dog实现 Animal接口 }
public void shout(){
System.out.println(“汪汪汪….”);
public Interface Animal{ }
public void shout(); }

“类”是抽象的概念，“对象”是具体的个
1.2 程序世界中的类和对象

Java程序世界用一种复合数据类型class来表示“ 类”
public class Person{ private int age; public void eat() 方法体 }; }
成员方法，代表可以执行的动作
private String name;

“面向接口编程”是一项重要的面向对象设计原则，遵循“面向接口编程”原则，可以增强程序（系统）的灵活性和扩展性程序（系统）采用接口，可以通过更换接口的实现类，以达到“灵活更换程序（系统）实现”的目的

理解面向接口编程—回顾Servlet API

Servlet API：Sun公司定义了一套专门用于开发 Servlet程序的Java类和接口，这些类和接口提供 Servlet程序开发所涉及的各种功能，统称为Servlet API.
▪ 支持Servlet的Web服务器软件都自带Servlet API具体实现的JAR包
Tomcat自带Servlet API的JAR包：安装目录\lib目录 \servlet-api.jar
不同服务器软件提供各自不同的Servlet API实现

查看Servlet API文档中响应客户请求方法
2
2.2特征II——继承（inheritance）

继承的定义：继承是一个类可以获得另一个类的特性的机制
▪ 存在继承关系时，现有类称为“父类”（基类、超类），从其继承而来的新类称为“子类”（派生类）

“子类继承(extends)父类”
▪ 子类自动继承了父类的成员变量和方法
▪ 子类可以增加自己的成员变量和方法 ▪ 子类可以覆盖（重写）继承的方法
public Interface Animal{ void shout(); }
Animal animal = new Animal();

由具体类实现(implements)接口，并实现接口中定义的方法
public class 具体类 implements 接口名{ 实现接口中定义的具体方法；
3.2 接口的声明与使用

Java接口采用Interface来定义
▪ 以下定义一个名字叫“Animal”的接口，接口中只声明了一个shout()方法原型，无具体实现 public Interface Animal{ public void shout();
}

程序中不能像使用具体类那样直接使用（实例化）接口

“继承”的这种特点导致了面向对象最具威力的特征——多态——的产生
2.3特征III——多态（Polymorphism）

多态：
▪ 同样一个方法调用，可以有不同的具体表现形态

多态的实现：
▪ 通过将父类对象引用变量指向子类对象，来实现动态的方法调用

一般的对象创建形式（如创建PekingDog类）
▪ 当方法参数为父类型时，可以传递子类型对象 ▪ 当方法返回值为父类型时，可以返回任意子类型对象

示例
ObjectTest —DogBarker/DogBarkerTest
三、Java接口
3.1 Java接口的定义

一个Java接口是一组方法的声明，但没有方法的具体实现，其实现是由实现了该接口的具体类来完成
PekingDog dog = new PekingDog();