面向对象特性

转载 2007年10月14日 21:19:00

面向对象特性

  java语言中有三个典型的面向对象的特性:封装性、继承性和多态性,下面将详细阐述。

  1. 封装性

  2. 继承性

  3. 多态性

  4. 其它

1. 封装性

  java语言中,对象就是对一组变量和相关方法的封装,其中变量表明了对象的状态,方法表明了对象具有的行为。通过对象的封装,实现了模块化和信息隐藏。通过对类的成员施以一定的访问权限,实现了类中成员的信息隐藏。

  ◇ 类体定义的一般格式:

  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} //成员方法
  }

  ◇ java类中的限定词
  java语言中有四种不同的限定词,提供了四种不同的访问权限。

  1) private
  类中限定为private的成员,只能被这个类本身访问。
  如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。

  2) default
  类中不加任何访问权限限定的成员属于缺省的(default)访问状态,可以被这个类本身和同一个包中的类所访问。

  3) protected
  类中限定为protected的成员,可以被这个类本身、它的子类(包括同一个包中以及不同包中的子类)和同一个包中的所有其他的类访问。

  4) public
  类中限定为public的成员,可以被所有的类访问。

  表3-1列出了这些限定词的作用范围。

【表3-1】 java中类的限定词的作用范围比较

同一个类
同一个包
不同包的子类
不同包非子类
private
*
default
*
*
protected
*
*
*
public
*
*
*
*

  2. 继承性

  通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类,被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法,及命名与父类同名的成员变量。但Java不支持多重继承,即一个类从多个超类派生的能力。

   创建子类
  格式:
  class SubClass extends SuperClass {
  …
  }

   成员变量的隐藏和方法的重写
  子类通过隐藏父类的成员变量和重写父类的方法,可以把父类的状态和行为改变为自身的状态和行为。

  例如:
  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():用于多线程处理中的同步。


 

关于面向对象以及三大特征的解释

第一次写,想想就有点小激动。个人理解有不全的地方
  • super_xiaoY
  • super_xiaoY
  • 2016-12-06 10:39:19
  • 3450

面向对象具有哪些特性以及对这些特性的理解

面向对象具有哪些特性以及对这些特性的理解
  • ThatBoys
  • ThatBoys
  • 2016-07-14 18:53:37
  • 2888

面向对象的四大基本特性

面向对象的四大基本特性 面向对象的核心概念就是封装、抽象、继承、多态这四大基本特性,在这里先解释一下它们的定义: 封装:是一种隐藏信息的特性。找到变化并且把它封装起来,你就可以在不影响其它...
  • u012968272
  • u012968272
  • 2015-02-21 23:26:33
  • 1949

Java面向对象特性

Java面向对象特性1.继承(Inheritance)继承是面向对象编程的核心机制之一,其作用是在已有类型基础之上进行扩充或改造,得到新的数据类型,以满足新的需要.语法格式如下:[] class  [...
  • johnston678
  • johnston678
  • 2009-05-27 21:58:00
  • 973

C#面向对象三大特性

想要学好面向对象编程,除了掌握语法结构外最重要的就是熟悉面向对象三大特性,这三大特性不是相互独立的而是相互关联、你中有我我中有你的关系,想要真正了解三大特性必须把这三部分当做一个整体来考虑。 封...
  • xiaouncle
  • xiaouncle
  • 2016-11-23 21:02:09
  • 3536

PHP---面向对象的3个特性

面向对象有3个特性, 1是封装 2是继承 3是多态 封装 就是类中的属性,一般不直接被类外调用,使用get和set方法调用,封装后使用。封装后安全性高,属性和方法有访问3个修饰符  ...
  • huyishero
  • huyishero
  • 2016-11-22 23:04:14
  • 334

面向对象三大特性,五大原则

以前一直认为程序中的类有使用到封装继承多态就是面向对象设计,其实不然 封装,继承,多态只是面向对象的三大特性,但是在设计程序的时候并不是说类的结构使用到了(或是体现出了)这三个特性就是面向对象, ...
  • xtzmm1215
  • xtzmm1215
  • 2015-07-18 22:28:28
  • 7390

OC面向对象的三大特性

三大特性: 封装,继承,多态 封装: 当类中的属性加 @public 为公共对象是 传入的实参可能是不合理的,这时可以提供一个方法给外界设置属性值,这种方法一般叫做set方法。 set...
  • Gaooof
  • Gaooof
  • 2016-01-03 13:35:48
  • 581

Java 面向对象的四大特征

计算机软件系统是现实生活中的业务在计算机中的映射,而现实生活中的业务其实就是一个个对象协作的过程。面向对象编程就是按现实业务一样的方式将程序代码按一个个对象进行组织和编写,让计算机系统能够识别和理解用...
  • u014285979
  • u014285979
  • 2016-03-01 13:59:39
  • 1891

java面向对象思想和三大特性

面向对象:    1、面向对象 面向对象是一种程序设计思想,计算机程序的设计实质上就是将现实中的一些事物的特征抽离出来描述成一些计算机事件的过程,这种抽象的过程中,我们把具体的事物...
  • liupengfeix
  • liupengfeix
  • 2015-05-27 07:25:50
  • 11716
收藏助手
不良信息举报
您举报文章:面向对象特性
举报原因:
原因补充:

(最多只允许输入30个字)