 |
|
|
 首页 |
名片设计 CorelDRAW Illustrator AuotoCAD Painter 其他软件 Photoshop Fireworks Flash |
|
【课前思索】 1． 什么是对象？什么是类？什么是包？什么是接口？什么是内部类？ 2． 面向对象编程的特性有哪三个？它们各自又有哪些特性？ 3． 你知道java语言在面向对象编程方面有何独特的特点吗？ 难点： 1． 理解方式重载和方式重写，不要混淆了两者的使用。 2． 类变量和类方式的使用。 3． 接口的使用。 3．1 面向对象技术基础 3．1．1 面向对象的基本概念 面向对象的基本思想 面向对象是一种新兴的程序设计方式,或者是一种新的程序设计规范(paradigm),其基本思想是使用对象、类、继续、封装、消息等基本概念来进行程序设计。从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方法。开发一个软件是为了解决某些问题，这些问题所涉及的业务范围称作该软件的问题域。其应用领域不仅仅是软件，还有计算机体系结构和人工智能等。 1． 对象的基本概念 对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。 主动对象是一组属性和一组服务的封装体，其中至少有一个服务不需要接收消息就能主动执行（称作主动服务）。 2． 类的基本概念 类是具有一样属性和服务的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和服务两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性说明和服务说明两个主要部分。 3． 消息 消息就是向对象发出的服务哀求，它应该包含下述信息：提供服务的对象标识、服务标识、输入信息和回答信息。服务通常被称为方式或函数。 3．1．2 面向对象的基本特征 1．封装性 封装性就是把对象的属性和服务结合成一个独立的一样单位，并尽可能隐蔽对象的内部细节，包含两个含义： ◇ 把对象的全部属性和全部服务结合在一起，形成一个不可分割的独立单位（即对象）。 ◇ 信息隐蔽，即尽可能隐蔽对象的内部细节，对形状成一个边界〔或者说形成一道屏障〕，只保留有限的对外接口使之与外部发生联系。 封装的原则在软件上的反映是：要求使对象以外的部分不能随意存取对象的内部数据（属性），从而有效的避免了外部错误对它的"交叉感染"，使软件错误能够局部化，大大减少查错和排错的难度。 2．继续性 特别类的对象拥有其一般类的全部属性与服务，称作特别类对一般类的继续。 一个类可以是多个一般类的特别类，它从多个一般类中继续了属性与服务，这称为多继续。 在java语言中，通常我们称一般类为父类（superclass,超类），特别类为子类(subclass)。 3．多态性 对象的多态性是指在一般类中定义的属性或服务被特别类继续之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或服务在一般类及其各个特别类中具有不同的语义。例如："几何图形"的"绘图"方式，"椭圆"和"多边形"都是"几何图"的子类，其"绘图"方式功能不同。 3．1．3 面向对象程序设计方式 OOA－Object Oriented Analysis 面向对象的分析 OOD－Object Oriented Design 面向对象的设计 OOI－Object Oriented Implementation 面向对象的实现 3．2 Java语言的面向对象特性 3．2．1 类 类是java中的一种重要的复合数据类型，是组成java程序的基本要素。它封装了一类对象的状态和方式，是这一类对象的原形。一个类的实现包括两个部分：类声明和类体 1．类声明： [public][abstract|final] class className [extends superclassName] [implements interfaceNameList] {……} 其中，修饰符public,abstract,final 说明了类的属性，className为类名，superclassName为类的父类的名字，interfaceNameList为类所实现的接口列表。 2．类体 类体定义如下： class className {[public | protected | private ] [static] [final] [transient] [volatile] type variableName; //成员变量 [public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList] {statements} //成员方式 } 3．成员变量 成员变量的声明方法如下： [public | protected | private ] [static] [final] [transient] [volatile] type variableName; //成员变量 其中， static: 静态变量（类变量）；相对于实例变量 final: 常量 transient: 暂时性变量，用于对象存档，用于对象的串行化，见对象的串行化一节 volatile: 贡献变量，用于并发线程的共享 4．成员方式 方式的实现包括两部分内容：方式声明和方式体。 [public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList] //方式声明 {statements} //方式体 方式声明中的限定词的含义： static: 类方式，可通过类名直接调用 abstract: 抽象方式，没有方式体 final: 方式不能被重写 native: 集成其它语言的代码 synchronized: 控制多个并发线程的访问 ◇ 方式声明 方式声明包括方式名、返回类型和外部参数。其中参数的类型可以是简朴数据类型，也可以是复合数据类型（又称引用数据类型）。 对于简朴数据类型来说，java实现的是值传递，方式接收参数的值，但不能改变这些参数的值。假如要改变参数的值，则用引用数据类型，因为引用数据类型传递给方式的是数据在内存中的地址，方式中对数据的操作可以改变数据的值。 例3-1说明了简朴数据类型与引用数据的区别。 【例3-1】 import java.io.*; public class PassTest{ float ptValue; public static void main(String args[]) { int val; PassTest pt=new PassTest(); val=11; System.out.println("Original Int Value is:"+val); pt.changeInt(val); //值参数 System.out.println("Int Value after Change is:" +val); /*值参数 值的修改，没有影响值参数的值*/ pt.ptValue=101f; System.out.println("Original ptValue is:"+pt.ptValue); pt.changeObjValue(pt); //引用类型的参数 System.out.println("ptValue after Change is:"+pt.ptValue);/* 引用参数值的修改，改变了引用参数的值*/ } public void changeInt(int value){ value=55; //在方式内部对值参数进行了修改 } public void changeObjValue(PassTest ref){ ref.ptValue=99f; //在方式内部对引用参数进行了修改 } } ◇ 方式体 方式体是对方式的实现，它包括局部变量的声明以及所有合法的Java指令。方式体中声明的局部变量的作用域在该方式内部。若局部变量与类的成员变量同名，则类的成员变量被隐藏。 为了区别参数和类的成员变量，我们必须使用this。this-----用在一个方式中引用当前对象，它的值是调用该方式的对象。返回值须与返回类型一致，或者完全一样，或是其子类。当返回类型是接口时，返回值必须实现该接口。 5．方式重载 方式重载是指多个方式享有一样的名字，但是这些方式的参数必须不同，或者是参数的个数不同，或者是参数类型不同。返回类型不能用来区分重载的方式。 参数类型的区分度一定要足够，例如不能是同一简朴类型的参数，如int与long。编译器会根据参数的个数和类型来决定当前所使用的方式。 6． 构造方式 ◇ 构造方式是一个特别的方式。Java 中的每个类都有构造方式，用来初始化该类的一个对象。 ◇ 构造方式具有和类名一样的名称，而且不返回任何数据类型。 ◇ 重载常常用于构造方式。 ◇ 构造方式只能由new运算符调用 3．2．2 对象 类实例化可生成对象，对象通过消息传递来进行交互。消息传递即激活指定的某个对象的方式以改变其状态或让它产生一定的行为。一个对象的生命周期包括三个阶段：生成、使用和消除。 对象的清除 当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。 System.gc( ); System.exit();//terminate the current JVM 当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。 3．2．3 面向对象特性 java语言中有三个典型的面向对象的特性：封装性、继续性和多态性。 1． 封装性 java语言中，对象就是对一组变量和相关方式的封装，其中变量表明了对象的状态，方式表明了对象具有的行为。通过对象的封装，实现了模块化和信息隐藏。通过对类的成员施以一定的访问权限，实现了类中成员的信息隐藏。 ◇ java类中的限定词 java语言中有四种不同的限定词，提供了四种不同的访问权限。 1） private 类中限定为private的成员，只能被这个类本身访问。 假如一个类的构造方式声明为private,则其它类不能生成该类的一个实例。 2） default 类中不加任何访问权限限定的成员属于缺省的（default）访问状态：friend，可以被这个类本身和同一个包中的类所访问。 3） protected 类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。 4） public 类中限定为public的成员，可以被所有的类访问。 【表3-1】 java中类的限定词的作用范围比较 同一个类 同一个包 不同包的子类 不同包非子类 private * default * * protected * * * public * * * * 2． 继续性 通过继续实现代码复用。Java中所有的类都是通过直接或间接地继续java.lang.Object类得到的。继续而得到的类称为子类，被继续的类称为父类。子类不能继续父类中访问权限为private的成员变量和方式。子类可以重写父类的方式，及命名与父类同名的成员变量。但Java不支持多重继续，即一个类从多个超类派生的能力。 ◇ 成员变量的隐藏和方式的重写 子类通过隐藏父类的成员变量和重写父类的方式，可以把父类的状态和行为改变为自身的状态和行为。 例如： class SuperClass{ int x; … void setX( ){ x=0; } … } class SubClass extends SuperClass{ int x; //隐藏了父类的变量x … void setX( ) { //重写了父类的方式 setX() x=5; } …. } 注重：子类中重写的方式和父类中被重写的方式要具有一样的名字，一样的参数表和一样的返回类型，只是函数体不同。 ◇ super java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。Super 的使用有三种情况： 1）访问父类被隐藏的成员变量，如： super.variable; 2）调用父类中被重写的方式，如： super.Method([paramlist]); 3）调用父类的构造函数，如： super([paramlist]); 【例3-5】 import java.io.*; class SuperClass{ int x; SuperClass( ) { x=3; System.out.println("in SuperClass : x=" +x); } void doSomething( ) { System.out.println("in SuperClass.doSomething()"); } } class SubClass extends SuperClass { int x; SubClass( ) { super( ); //调用父类的构造方式 x=5; //super( ) 要放在方式中的第一句 System.out.println("in SubClass :x="+x); } void doSomething( ) { super.doSomething( ); //调用父类的方式 System.out.println("in SubClass.doSomething()"); System.out.println("super.x="+super.x+" sub.x="+x); } } public class Inheritance { public static void main(String args[]) { SubClass subC=new SubClass(); subC.doSomething(); } } 3． 多态性 在java语言中，多态性体现在两个方面：由方式重载实现的静态多态性（编译时多态）和方式重写实现的动态多态性（运行时多态）。 1） 编译时多态 在编译阶段，详细调用哪个被重载的方式，编译器会根据参数的不同来静态确定调用相应的方式。 2） 运行时多态 由于子类继续了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方式。 ◇ 重写方式的调用原则：java运行时系统根据调用该方式的实例，来决定调用哪个方式。对子类的一个实例，假如子类重写了父类的方式，则运行时系统调用子类的方式；假如子类继续了父类的方式（未重写），则运行时系统调用父类的方式。 在例3-6中，父类对象a引用的是子类的实例，所以，java运行时调用子类B的callme方式。 【例3-6】 import java.io.*; class A{ void callme( ) { System.out.println("Inside A\\\'s callme()method"); } } class B extends A{ void callme( ) { System.out.println("Inside B\\\'s callme() Method"); } } public class Dispatch{ public static void main(String args[]) { A a=new B(); a.callme( ); } } ◇ 方式重写时应遵循的原则： 1）改写后的方式不能比被重写的方式有更严格的访问权限（可以一样）。 2）改写后的方式不能比重写的方式产生更多的例外。 4． 其它 ◇ final 要害字 final 要害字可以修饰类、类的成员变量和成员方式，但final 的作用不同。 1） final 修饰成员变量： final修饰变量,则成为常量，例如 final type variableName; 修饰成员变量时，定义时同时给出初始值，且以后不能被修改，而修饰局部变量时不做要求。 2） final 修饰成员方式： final修饰方式，则该方式不能被子类重写 final returnType methodName(paramList){ … } 3） final 类： final修饰类，则类不能被继续 final class finalClassName{ … } ◇ 实例成员和类成员 用static 要害字可以声明类变量和类方式，其格式如下： static type classVar; static returnType classMethod({paramlist}) { … } 假如在声明时不用static 要害字修饰，则声明为实例变量和实例方式。 1） 实例变量和类变量 每个对象的实例变量都分配内存，通过该对象来访问这些实例变量，不同的实例变量是不同的。 类变量仅在生成第一个对象时分配内存，所有实例对象共享同一个类变量，每个实例对象对类变量的改变都会影响到其它的实例对象。类变量可通过类名直接访问，无需先生成一个实例对象，也可以通过实例对象访问类变量。 2） 实例方式和类方式 实例方式可以对当前对象的实例变量进行操作，也可以对类变量进行操作，实例方式由实例对象调用。 但类方式不能访问实例变量，只能访问类变量。类方式可以由类名直接调用，也可由实例对象进行调用。类方式中不能使用this或super要害字。 例3-7 是关于实例成员和类成员的例子。 【例3-7】 class Member { static int classVar; int instanceVar; static void setClassVar(int i) { classVar=i; // instanceVar=i; // 类方式不能访问实例变量 } static int getClassVar() { return classVar; } void setInstanceVar(int i) { classVar=i; //实例方式不但可以访问类变量，也可以实例变量 instanceVar=i; } int getInstanceVar( ) { return instanceVar; } } public class MemberTest{ public static void main(String args[]) { Member m1=new member(); Member m2=new member(); m1.setClassVar(1); m2.setClassVar(2); System.out.println("m1.classVar="+m1.getClassVar()+" m2.ClassVar="+m2.getClassVar()); m1.setInstanceVar(11); m2.setInstanceVar(22); System.out.println("m1.InstanceVar="+m1.getInstanceVar ()+" m2.InstanceVar="+m2.getInstanceVar()); } } ◇ 类java.lang.Object 类java.lang.Object处于java开发环境的类层次的根部，其它所有的类都是直接或间接地继续了此类。该类定义了一些最基本的状态和行为。下面，我们介绍一些常用的方式。 equals() ：比较两个对象(引用)是否一样。 getClass()：返回对象运行时所对应的类的表示，从而可得到相应的信息。 toString()：用来返回对象的字符串表示。 finalize()：用于在垃圾收集前清除对象。 notify(),notifyAll(),wait()：用于多线程处理中的同步。 3．2．4抽象类和接口 1． 抽象类 java语言中，用abstract 要害字来修饰一个类时，这个类叫做抽象类，用abstract 要害字来修饰一个方式时，这个方式叫做抽象方式。格式如下： abstract class abstractClass{ …} //抽象类 abstract returnType abstractMethod([paramlist]) //抽象方式 抽象类必须被继续，抽象方式必须被重写。抽象方式只需声明，无需实现；抽象类不能被实例化，抽象类不一定要包含抽象方式。若类中包含了抽象方式，则该类必须被定义为抽象类。 若一个类继续了一个抽象类，则抽象类的抽象方式必须被实现，否则子类必须声明为abstract. 2． 接口 接口是抽象类的一种，只包含常量和方式的定义，而没有变量和方式的实现，且其方式都是抽象方式。它的用处体现在下面几个方面： ◇ 通过接口实现不相关类的一样行为,而无需考虑这些类之间的关系。 ◇ 通过接口指明多个类需要实现的方式。 ◇ 通过接口了解对象的交互界面,而无需了解对象所对应的类。 1）接口的定义 接口的定义包括接口声明和接口体。 接口声明的格式如下： [public] interface interfaceName[extends listOfSuperInterface] { … } extends 子句与类声明的extends子句基本一样，不同的是一个接口可有多个父接口，用逗号隔开，而一个类只能有一个父类。 接口体包括常量定义和方式定义 常量定义格式为：type NAME=value; 该常量被实现该接口的多个类共享; 具有public ,final, static的属性。在接口中只能声明常量，不可以声明变量。 方式体定义格式为：(具有 public和abstract属性，不能声明为protected) returnType methodName([paramlist])； 注重：在接口的实现类中，实现的接口方式必须声明为public ，因为接口中定义的方式为public（默认）。所以其实现必须声明为public.否则编译不会通过。 2）接口的实现 在类的声明中用implements子句来表示一个类使用某个接口，在类体中可以使用接口中定义的常量，而且必须实现接口中定义的所有方式。一个类可以实现多个接口,在implements子句中用逗号分开。 3） 接口类型的使用 接口作为一种引用类型来使用。任何实现该接口的类的实例都可以存储在该接口类型的变量中，通过这些变量可以访问类所实现的接口中的方式。 3．2．5 内部类 1． 内部类的定义和使用： 内部类是在一个类的内部嵌套定义的类，它可以是其它类的成员，也可以在一个语句块的内部定义，还可以在表达式内部匿名定义。 内部类有如下特性： ◇ 一般用在定义它的类或语句块之内,在外部引用它时必须给出完整的名称.名字不能与包含它的类名一样。 ◇ 可以使用包含它的类的静态和实例成员变量,也可以使用它所在方式的局部变量。 ◇ 可以定义为abstract。 ◇ 可以声明为private或protected。 ◇ 若被声明为static,就变成了顶层类,不能再使用局部变量。 ◇ 若想在Inner Class中声明任何static成员,则该Inner Class必须声明为static。 例3-8】 import java.awt.*; import java.awt.event.*; public class TwoListenInner { private Frame f; private TextField tf; public static void main(String args[]) { TwoListenInner that=new TwoListenInner(); that.go(); } public void go() { f=new Frame("Two listeners example"); f.add("North",new Label("Click and drag the mouse")); tf=new TextField(30); f.add("South",tf); f.addMouseMotionListener(new MouseMotionHandler()); f.addMouseListener(new MouseEventHandler()); f.setSize(300,300); f.setVisible(true); } public class MouseMotionHandler extends MouseMotionAdapter { public void mouseDragged(MouseEvent e){ String s="Mouse dragging:X="+e.getX()+"Y="+e.getY(); tf.setText(s); } } public class MouseEventHandler extends MouseAdapter { public void mouseEntered(MouseEvent e){ String s="The mouse entered"; tf.setText(s); } public void mouseExited(MouseEvent e){ String s="The mouse left the building"; tf.setText(s); } } } 说明：Frame类的add方式来自于其祖先类Container类，addMouseMotionListener和addMouseListener方式来自于其祖先类Component, addMouseListener方式的参数为MouseListener接口，MouseAdapter类是实现了MouseListener接口的类。可见图形界面对于外部事件的响应是通过添加listener实现的 2． 匿名类的定义和使用： 匿名类是一种特别的内部类，它是在一个表达式内部包含一个完整的类定义。通过对例6-7中go()部分语句的修改，我们可以看到匿名类的使用情况。 public void go() { f=new Frame("Two listeners example"); f.add("North",new Label("Click and drag the mouse")); tf=new TextField(30); f.add("South",tf); f.addMouseMotionListener(new MouseMotionHandler(){ /*定义了一个匿名类，类名没有显式地给出，只是该类是 MouseMotionHandler类的子类*/ public void mouseDragged(MouseEvent e){ String s="Mouse dragging:X="+e.getX()+"Y ="+e.getY(); tf.setText(s); } }); f.addMouseListener(new MouseEventHandler()); f.setSize(300,300); f.setVisible(true); } 3． 内部类的优缺点： ◇ 长处:节省编译后产生的字节码文件的大小 ◇ 缺点:使程序结构不清晰 习题： 1 ：造型不可以从父类向子类造型，只能从子类向父类造型。否则编译 时可以通过，执行时会报错 如：SubClass sc = new SubClass(); BaseClass bc = (BaseClass)sc ;---是准确的 而 BaseClass bc = new BaseClass(); SubClass sc = (SubClass)bc ;---是错误的 BaseClass bc = new SubClass()也是准确的，并且在调用bc中的方式时执行的方式体是子类的方式体，但该方式必须同时在子类，父类中同时存在，若子类中有，而父类中没有，则不可以这样调用bc.subMethod(); 若两个类都继续于同一个类(必须是直接继续，否则不对)，则这两个类可以互相赋值，如：Panel和Frame 同继续于Container，所以Panel p = new Frame() ；和Frame f = new Panel()都是准确的， 返回类别: 教程 上一教程: Java中类型转变的特例 下一教程: 在Java中操作Zip文件，压缩/解压 您可以阅读与"第三讲 Java语言中的面向对象特性"相关的教程: · Java 语言中的 return 语句 · JAVA 语言中的 RETURN 语句 · JAVA程序员必读：基础篇（2）面向对象编程概念 · Java语言中字符的处理 · Java1.5语言新特性简朴总结 |
  |
| 快精灵印艺坊 版权所有 |
首页 会员中心在线印刷在线编辑付款方式索取样品设计指南连锁门店
|
||
