Java的面向对象程序设计

agenda 第一节 面向对象程序设计的基本概念 第二节 类的创建 第三节 对象的创建和使用 第四节 类的封装 第五节 类的继承 第一节 面向对象程序设计的基本概念 第二节 类的创建 第三节 对象的创建和使用 第四节 类的封装 第五节 类的继承 第六节 类的多态性 第七节 接 口 第八节 包

面向对象程序设计的基本概念

第一节 面向对象程序设计的基本概念 一、 面向对象的程序设计方法  对象是客观世界中的某个事物  事物的特性就是数据  事物的行为就是方法（过程或函数）  面向对象的程序设计方法就是将客观事物抽象成为“类”，并通过类的“继承”实现软件的可扩充性和可重用性

二、 类和对象  类是具有共同特性和行为的事物的抽象，是一种特殊数据类型。在类中包含了数据和与数据有关的操作（方法）  对象是类的实例 三、面向对象程序设计的核心技术  面向对象程序设计的核心技术是封装、继承和多态性

 通过封装可以隐藏类的实现细节，也可以避免对类中数据的直接操作。类是封装的基本单元  继承是对类的功能的重用和扩充  多态性是指方法的名字相同，但实现不同四、Java的面向对象技术  Java是一种完全面向对象的程序设计语言。它继承了C++的优点。Java，降低了程序的复杂性，实现了代码的可重用性，提高了运行效率。

第二节 类的创建 一、Java类的声明格式 <类首声明> {<类主体>} 第二节 类的创建 一、Java类的声明格式 <类首声明> {<类主体>}  类首声明定义了类的名字、访问权限与其它类的关系等  类主体定义了类的成员，包括变量（数据）和函数（方法）

1、类首声明: [<修饰符>] class <类名> [extends <超类名>] [implements <接口名>]  class: 类定义的关键字；  extends: 表示类和另外一些类（超类）的继承关系；  implements: 表示类实现了某些接口；  修饰符: 表示类访问权限（public、默认）和一些其它特性（abstract、final等）；

2、类主体 例如： public class Date1 声明Date1类，访问权限为Public，表示类Date1可以被该类所属的包之外的类使用。 2、类主体 类主体的结构如下 <类首声明>　//类首，以下为类主体 {<成员变量的声明> <成员方法的声明及实现>}  成员变量即类的数据，反映了类的属性和状态  成员方法即类的行为（对数据的操作）

例如4-1：声明一个日期类Date1 public class Date1 { int year,month,day; //成员变量 public void today( ) //成员方法 {System.out.println(“Date is”+year+”/”+month+”/” +day);} }

二、成员变量 类的成员变量的声明格式如下: [<修饰符>] [static] [final] <变量类型> <变量名>  static: 表示是一个类成员变量（静态变量）  final: 表示是一个常量  修饰符: 表示变量的访问权限（缺省访问、public、protected和private）

三、成员方法 类的成员方法的声明格式如下： [<修饰符>] <返回类型> <方法名>([<参数表列>]) [throws <异常类>] { 方法体 }  修饰符： 方法的访问权限(缺省的、public、protected和private) static: 类方法（静态方法） abstract: 抽象方法（无方法体的方法） final: 最终方法（不能覆盖）  throws: 表示抛出异常

例如4-2 : 日期类的改进版，增加了一些方法，便于对数据的操作 public class Date2 {int year,month,day; //设置某一天的日期的方法 public void setdate(int y,int m,int d) {year=y; month=m; day=d;} void today( ) //打印某一天的日期的方法 { System.out.println("The date of today is "+year+"/“ +month+"/"+day);} boolean isleap(int y) //判断某年是否是闰年的方法 {return (y%4==0&&y%100!=0)||y%400==0 ;} //计算并打印某天后面一天的日期的方法

void tomorrow( ) { int d,m,y; d=day+1;m=month;y=year; if((d>28)&&month==2) {if(!isleap(year)||d>29) {d=1;m=m+1;}} else if(d>30&&(month<7&&month%2==0||month>7&&month%2==1)) {d=1;m=m+1;} else if(d>31) {d=1;m=m+1; if(m==13){y=y+1;m=1;}} System.out.println("The date of tomorrow is "+y+"/"+m+"/"+d);}

public static void main(String args[ ]) {Date2 de=new Date2(); de.setdate(2000,2,29); if(de.isleap(de.year))System.out.println(de.year+" is a leap year"); de.today(); de.tomorrow();}}

重点内容回顾 字符串处理 成员变量的声明 方法的声明 类的声明

第三节 对象的创建和使用 一、创建对象  创建对象的方式有两种： 第一种形式的创建步骤如下： 第一步： 声明对象 按照下面格式声明一个对象 第三节 对象的创建和使用 一、创建对象  创建对象的方式有两种： 第一种形式的创建步骤如下： 第一步： 声明对象 按照下面格式声明一个对象 <类名> <对象名> 第二步： 实例化对象 用运算符new来实例化对象 如：Date1 a; //声明对象 a=new Date1( ); //实例化对象

实例化就是为对象分配存储空间，并同时对对象进行初始化。这些工作分别用new运算符和类的构造方法来完成。 第二种创建对象的形式是在声明对象的同时，将它实例化 如：Date2 de=new Date2( ); 实例化就是为对象分配存储空间，并同时对对象进行初始化。这些工作分别用new运算符和类的构造方法来完成。

二、构造方法和对象的初始化 类的构造方法使我们可以在创建对象时进行初始化（对成员变量赋初值）。 如：Date2 de=new Date2( 1999,12,31); 调用了的构造方法，对类的成员变量year、month和day分别赋初值1999、12和31。  如何创建构造方法 类的构造方法的名字应该和这个类的名字一样；构造方法没有返回值（在构造方法名字前连void也不要加）

例如4-3：增加了自己创建的构造方法的类Date2 public class Date2 {int year,month,day; Date2(int y,int m,int d) //创建构造函数 {year=y; month=m; day=d;} Date2() //缺省构造函数 {　} //以下同例4.2 ………… //以下在main 方法中，调用构造函数对对象进行初始化

public static void main(String args[]) {Date2 de1,de2; de1=new Date2(1999,3,31); //调用构造函数进行初始化 de2=new Date2(); //调用缺省构造函数 System.out.println("The first object:"); if(de1.isleap(de1.year))System.out.println(de1.year+" is a leap year"); de1.today(); de1.tomorrow(); System.out.println("The second object:"); de2.setdate(2000,2,29); if(de2.isleap(de2.year))System.out.println(de2.year+” is a leap year”); de2.today(); de2.tomorrow();} }

 无参数的构造函数 如果有自己创建的构造函数，而创建某些对象时又不想进行初始化，一定要在类中创建无参数的构造函数，因为此时已没有缺省的构造函数了。  构造函数是可以重载的

三、 对象的使用 引用成员变量或成员方法时要用 ”.” 运算符  成员变量的引用格式如下： <对象名>.<变量名>  成员方法的调用格式如下： <对象名>.<方法名([参数])>

四、 对象的销毁  对象的生命周期 对象的生命周期是指对象的创建、使用和销毁这一过程。  对象的销毁是指当对象使用完毕后，释放对象所占有的资源（如分配给它的内存）。  对象销毁的方法 Java能自动判断对象是否在使用，并自动销毁不再使用的对象，收回对象所占的资源。

第四节 类的封装 一、封装的目的 类的封装的目的，就是限制在类的外部对类内部成员进行访问。并通过公共接口来访问类的成员数据。 第四节 类的封装 一、封装的目的 类的封装的目的，就是限制在类的外部对类内部成员进行访问。并通过公共接口来访问类的成员数据。 封装的另一目的是细节屏蔽，这是程序设计的基本思想方法。便于程序功能的扩展和程序的维护。

二、访问权限的设置  访问权限 权 限 同一类 同一包 不同包的子类 所有类 public 允许 protected 不允许 默 认 权　限 同一类 同一包 不同包的子类 所有类 public 允许 protected 不允许 默　认 private

 类的访问权限的设置 类的权限有两种：默认和public。如果在一个源程序文件中，声明了若干个类的话，只能有一个类的权限关键字是public。这个类的名字应该和程序文件同名，main方法也应该在这个类中。  类的成员的访问权限设置 用权限关键字设置类的成员的权限，可以决定是否允许其类外部的代码访问这些成员。

三、类成员（静态成员） 类中有一种特殊的成员，它不属于某个对象。这种成员在声明时前面要加上关键字static。  类变量 　类变量可以被所有的对象共享。它的存在和对象的生命周期无关，在一个对象也没有被创建时，类变量就存在了。当程序运行结束，类变量才被撤消。 作为一种静态成员，在一个对象中对类变量的操作，会影响到同一类的其它对象。用类名引用类变量。  类方法 类方法中不属于类的某个对象，类方法只能引用类变量。类方法能用类名调用，也能用对象名调用。

例4-4 创建一个类Melon，其中成员数据total_weight和total_number声明为static。当创建一个Melon的对象， total_weight和total_number就增加一次，每调用一次类的reduce方法， total_weight和total_number就减去一次。 Melon_ex 例4-5 将Melon的类变量total_weight和total_number的访问权限设为private，要创建类方法get_total_weight和get_total_number来访问两个类变量。 Melon1_ex

第五节 类的继承 继承就是对已有代码的重用，同时增加新的代码来进行功能的扩展。 一、继承的基本概念 第五节 类的继承 继承就是对已有代码的重用，同时增加新的代码来进行功能的扩展。 一、继承的基本概念  被继承的类称超类。从超类派生出来（继承超类）的新类称子类。  如果类Sub是类Super的子类，则类Sub继承了超类Super的变量和方法。

 子类Sub中，包括两部分的内容：从超类Super中继承下来的变量和方法，自己新增加的变量和方法。  在Java中，只支持单重继承，不支持多重继承，所以一个类只能有一个超类。

二、子类的创建  声明子类 在声明类的同时，声明类的超类 [<修饰符>] class <子类名> extends <超类名> { 子类体 } 如：class Sub extends Super 声明了类Sub，它的超类是Super。  子类的每个对象也是超类的对象。超类的对象不一定是子类的对象。

子类不能继承超类的private成员变量 子类能继承超类的public和protected成员变量  子类继承超类的成员变量 继承原则： 子类不能继承超类的private成员变量 子类能继承超类的public和protected成员变量 子类能继承同一包中，有默认权限修饰符的成员变量 隐藏(Hiding)原则： 类的成员变量和超类的成员变量同名时，超类的成员变量被隐藏（不能继承）。 Student_ex

子类不能继承超类的private成员方法 子类不能继承超类的构造方法 子类能继承超类的public和protected成员方法  子类继承超类的成员方法 继承原则： 子类不能继承超类的private成员方法 子类不能继承超类的构造方法 子类能继承超类的public和protected成员方法 子类能继承同一包中，有默认权限修饰符的成员方法 覆盖(Override)原则： 子类的成员方法和超类的成员方法同名时，超类的成员方法被子类的成员方法覆盖（不能继承）。 Student1_ex

 子类的构造函数 创建该子类对象，首先要创建超类的对象。 在调用子类的构造方法时，先要调用超类的构造方法。子类构造方法的参数的前面几个，是给超类的构造方法的。 在子类构造方法的方法体中，用super调用超类的构造方法，并要将此调用语句写在方法体的最前面。

 null  this引用 三、null、this、super对象运算符 表示空对象，即没有创建类的任何实例。 this表示某对象自己，在对象的非static方法中，可以用this来引用对象的成员。this引用的使用方法如下： 用this指代对象本身； 访问本类的成员： this.<变量名> this.<方法名>

 super引用 调用本类的构造函数 this([参数列表]) super表示对某个类的超类的引用。 如子类和超类有同名的成员变量或方法，则： super.<成员变量名> super.<成员方法名> 表示引用超类的成员（如无super则表示子类中的同名成员） 用super调用超类的构造方法 super([参数列表]) Student2_ex

四、最终类和抽象类  最终类和最终方法 不能被继承的类称最终类。用final将类说明为最终类，如 final class Last; //Last 为最终类 可以将非最终类中的成员方法用final说明为最终方法，这样此方法不会在子类中被覆盖（即子类中不能有和此方法同名的方法）。如 public final void printsuper( ) //此方法为最终方法

 抽象类和抽象方法 抽象方法是必须被子类覆盖的方法。在声明方法时，用关键字abstract将方法说明为抽象方法，如： protected abstract void write() //此方法为抽象方法 含有抽象方法的类称抽象类，它是不能实例化的类，也用abstract说明。 对于成员方法，不能同时用static和abstract说明。对于类，不能同时用final和abstract说明。

重点内容回顾 构造方法 类的封装 类的继承

第六节 类的多态性  一个类中，有若干个方法名字相同，但方法的参数不同，称为方法的重载。在调用时，根据参数的不同来决定执行那个方法。 第六节 类的多态性 多态性是指同一个名字的若干个方法，有不同的实现（即方法体中的代码不一样）。可以通过方法的重载(overloading)和覆盖(override)来实现多态性。 一、方法的重载  一个类中，有若干个方法名字相同，但方法的参数不同，称为方法的重载。在调用时，根据参数的不同来决定执行那个方法。  重载的关键是参数必须不同 ：

 正确的方法重载  不正确的方法重载 public void funover(int a) public void funover(int a,float b) public void funover(float a,int b)  不正确的方法重载 public int funover(int a,float b) Shapearea

 在子类和超类中有同名的方法（参数也相同），子类中的方法覆盖超类的方法。 二、方法的覆盖  在子类和超类中有同名的方法（参数也相同），子类中的方法覆盖超类的方法。  如果超类和子类有同名且参数相同的方法，那么超类的对象调用超类的方法，子类的对象调用子类的方法。这就是覆盖。  通过覆盖可以使同名的方法在不同层次的类中有不同的实现。 Shapecc_ex

 对于方法的重载，在程序编译时，根据调用语句中给出的参数，就可以决定在程序执行时调用同名方法的版本。这称为编译时的绑定（前期绑定）。 三、前期绑定和后期绑定  对于方法的重载，在程序编译时，根据调用语句中给出的参数，就可以决定在程序执行时调用同名方法的版本。这称为编译时的绑定（前期绑定）。  对于方法的覆盖，要在程序执行时，才能决定调用同名方法的版本。这称为运行时的绑定（后期绑定）。  当子类对象赋给超类对象或作为参数传递给超类对象时，超类对象调用子类中的同名方法。 Shapeccd_ex

第七节 接 口 在Java中，一个类只能有一个超类。但Java提供了接口用于实现多重继承，一个类可以有一个超类和多个接口。 一、接口的声明 第七节 接 口 在Java中，一个类只能有一个超类。但Java提供了接口用于实现多重继承，一个类可以有一个超类和多个接口。 一、接口的声明 接口(interface)是方法和变量的集合： [修饰符] interface <接口名> {接口体} 修饰符：可以是public或默认访问控制。

接口体中的变量隐含为public、final和static，它们必须被赋初值。 接口体中的方法没有方法体，都是公共的、抽象的方法。由于接口所有成员均具有这些属性，相关的修饰符可以省略。 二、接口的实现 一个接口可以被一个或多个类实现。当一个类实现了一个接口，它必须实现接口中所有的方法，这些方法都要被说明为public。用关键字implements实现接口。 Studentint_ex

第八节 包 包(package)是类的逻辑组织形式。通过包可以对类的访问权限进行控制。包是有等级的。 第八节 包 包(package)是类的逻辑组织形式。通过包可以对类的访问权限进行控制。包是有等级的。 Java提供的用于程序开发的类就放在各种包中。也可以自己创建包。 一、Java的类和包 java常用的包有： java.lang 语言包 java.util　 实用包 java.awt 抽象窗口工具包 java.text 文本包

 语言包 java.io 输入输出流的文件包 java.applet Applet应用程序 java.net 网络功能 java.lang提供了Java最基础的类 Object类是Java类层次的根，所有其它类都是由Object类派生的。常用方法有：clone方法用于复制对象，equals方法可以比较两个对象是否相等，getClass用来获取对象的类。 数据类型类 对应Java的8个基本数据类型

字符串类String和StringBuffer 数学类Math Math提供了一组常量和数学函数，如常数E和PI，数学方法sin和cos等。Math是最终类，其中的数据和方法都是静态的（直接用类名引用）。 系统和运行时的类System，Runtime System类提供访问系统资源和标准输入输出流的方法。 Runtime类可以直接访问运行时的资源。

 实用包 错误和异常处理类Throwable、Exception和Error。 线程类。 java.util包提供了实现各种实用功能的类，如日期类、集合类等。 日期类包括Date、Calendar和GregorianCalendar类 集合类包括多种集合接口：Collection（无序集合）、Set（不重复集合）、List（有序不重复集合）和Enumeration（枚举）。 还有和数据结构有关的类：Linklist（链表）、Vector（向量）、Stack（栈）、Hashtable（散列表）和Treeset（数）。

二、 引用Java定义的包  导入包 如果要使用Java类中的包，要在源程序中用import语句导入。格式如下： “*”表示包中所有的类。如： import java.applet.Applet; //导入Java.applet包中的 Applet类 import java.awt.* //导入Java.awt包中所有的类

 Java包的路径 用环境变量classpath设置对Java包的搜索路径。在windows98下，切换到MS_DOS方式，用下面命令： Set classpath =.; d:\j2sdk1.4.2_02\lib 三、自定义包 如果在程序中没有声明包，类就放在默认的包中，这个包是没有名字的。默认包适用于小的程序，如果程序比较大，就需要创建自己的包。  声明一个包的格式 package <包名>; 声明一个包的语句要写在源程序文件的第一行。

 设置包的路径  引用包中的类  包路径的层次结构 创建一个和包同名的文件夹（字母大小写也一样），将包含包的源程序文件(.java)和编译产生的.class文件放到此文件夹中，设置环境变量classpath  引用包中的类 如果引用其它包中的类，可用import语句  包路径的层次结构 包对应于一个文件夹，而类则是文件夹中的一个文件。包路径也可以有层次结构，如：

 Java源程序文件的结构  包的声明语句  包的导入语句  类的声明 package Firstpackage.package1用“.”将包的名字分开，形成包路径的层次，package1是Firstpackage文件夹的子文件夹。  Java源程序文件的结构 一个Java的源程序文件依次有以下部分  包的声明语句  包的导入语句  类的声明 Person_ex

 public类的成员  默认访问权限类的成员 四、包和访问权限 在不同包中类成员的访问权限。  public类的成员 public类的public成员可以被其它包的代码访问。它的protected成员可以被由它派生的其它包中的子类访问。  默认访问权限类的成员 默认访问权限类的成员，不能被其它包的代码访问

Thanks!

BACK 类的图 形符号 Circle radius findArea new Circle() new Circle() 对象的 图形符号 circle1 : Circle circlen : Circle ... radius = 2 radius = 5 BACK

问 题 解 答 老师你好： 　　我是苗雨盛。请你帮我看看我的程序存在的问题。 import java.io.*; public class inputnum {    public void input() throws IOException      {         int num;         String str;         BufferedReader buf;         buf =BufferedReader(new InputStreamReader(System.in));         System.out.println("enter number: ");         str=buf.readLine();         num=Integer.parseInt(str);        } }  

public class And {    public static void main(String args[] )          {            Inputnum num1=Inputnum();            Inputnum num2=Inputnum();            num1.input();            num2.input();           System.out.println(num1.num+"+"+num2.num+"="+num1.num+num2.num);          } } 1、输入函数不在主函数中行吗？ 2、这个程序的思想对吗？不能通过编译为什么？

import java.io.*; class Inputnum{ int num; public void input() throws IOException { String str; BufferedReader buf; buf =new BufferedReader(new InputStreamReader(System.in)); System.out.println("enter number: "); str=buf.readLine(); num=Integer.parseInt(str); }

public class And { public static void main(String args[])throws IOException Inputnum num1=new Inputnum(); Inputnum num2=new Inputnum(); num1.input(); num2.input(); System.out.println(num1.num+"+"+num2.num+"="+(num1.num+num2.num)); } And