精华内容
下载资源
问答
  • JAVA_API1.6文档(中文)

    万次下载 热门讨论 2010-04-12 13:31:34
    java.security.acl 此包中的类和接口已经被 java.security 包中的类取代。 java.security.cert 提供用于解析管理证书、证书撤消列表 (CRL) 证书路径的类接口。 java.security.interfaces 提供的接口用于生成...
  • 一、模块简介二、Perl中的类三、创建类四、构造函数实例变量五、方法六、方法的输出七、方法的调用八、重载九、析构函数十、继承十一、方法的重载十二、Perl类对象的一些注释本章介绍如何使用Perl的面向对象编程...
    一、模块简介
    二、Perl中的类
    三、创建类
    四、构造函数 实例变量
    五、方法
    六、方法的输出
    七、方法的调用
    八、重载
    九、析构函数
    十、继承
    十一、方法的重载
    十二、Perl类和对象的一些注释
    本章介绍如何使用Perl的面向对象编程(OOP)特性及如何构建对象,还包括继承、方法重载和数据封装等内容。
    一、模块简介
        模块(module)就是Perl包(pachage)。Perl中的对象基于对包中数据项的引用。(引用见第x章引用)。
    详见http
    ://www.metronet.com的perlmod和perlobj。
        在用其它语言进行面向对象编程时,先声明一个类然后创建该类的对象(实例),特定类所有对象的行为方式是相同的,由类方法确定,可以通过定义新类或从现存类继承来创建类。已熟悉面向对象编程的人可以在此遇到许多熟悉的术语。Perl一直是一个面向对象的语言,在Perl5中,语法略有变动,更规范化了对象的使用。
        下面三个定义对理解对象、类和方法在Perl中如何工作至关重要。
        
    .类是一个Perl包,其中含提供对象方法的类。
        
    .方法是一个Perl子程序,类名是其第一个参数。
        
    .对象是对类中数据项的引用。
    二、Perl中的类
        再强调一下,一个Perl类是仅是一个包而已。当你看到Perl文档中提到“类”时,把它看作“包”就行了。Perl5的语法可以创建类,如果你已熟悉C
    ++,那么大部分语法你已经掌握了。与Perl4不同的概念是用双冒号(::)来标识基本类和继承类(子类)。
        面向对象的一个重要特性是继承。Perl中的继承特性与其它面向对象语言不完全一样,它只继承方法,你必须用自己的机制来实现数据的继承。
        因为每个类是一个包,所以它有自己的名字空间及自己的符号名关联数组(详见第x章关联数组),每个类因而可以使用自己的独立符号名集。与包的引用结合,可以用单引号(
    ')操作符来定位类中的变量,类中成员的定位形式如:$class'$member。在Perl5中,可用双冒号替代单引号来获得引用,如:$class'$member与$class::$member相同。
    三、创建类。
        本节介绍创建一个新类的必要步骤。下面使用的例子是创建一个称为Cocoa的简单的类,其功能是输出一个简单的Java应用的源码的必要部分。放心,这个例子不需要你有Java的知识,但也不会使你成为Java专家,其目的是讲述创建类的概念。
        首先,创建一个名为Cocoa.pm的包文件(扩展名pm是包的缺省扩展名,意为Perl Module)。一个模块就是一个包,一个包就是一个类。在做其它事之前,先加入“1;”这样一行,当你增加其它行时,记住保留“1;”为最后一行。这是Perl包的必需条件,否则该包就不会被Perl处理。下面是该文件的基本结构。
    package Cocoa;

    #
    # Put "require" statements in for all required,imported packages
    #

    #
    # Just add code here
    #

    1; # terminate the package with the required 1;
        接下来,我们往包里添加方法使之成为一个类。第一个需添加的方法是new(),它是创建对象时必须被调用的,new()方法是对象的构造函数。
    四、构造函数
        构造函数是类的子程序,它返回与类名相关的一个引用。将类名与引用相结合称为“祝福”一个对象,因为建立该结合的函数名为bless(),其语法为:
        bless YeReference [,classname]
        YeReference是对被“祝福”的对象的引用,classname是可选项,指定对象获取方法的包名,其缺省值为当前包名。
        创建一个构建函数的方法为返回已与该类结合的内部结构的引用,如:
    sub new {
      my $this = {}; # Create an anonymous hash, and #self points to it.
      bless $this; # Connect the hash to the package Cocoa.
      return $this; # Return the reference to the hash.
    }

    1;
        {}创建一个对不含键/值对的哈希表(即关联数组)的引用,返回值被赋给局域变量$this。函数bless()取出该引用,告诉对象它引用的是Cocoa,最后返回该引用。函数的返回值现在指向这个匿名哈希表。
        从new()函数返回后,$this引用被销毁,但调用函数保存了对该哈希表的引用,因此该哈希表的引用数不会为零,从而使Perl在内存中保存该哈希表。创建对象可如下调用:
        $cup = new Cocoa;
        下面语句为使用该包创建对象的例子:
    1 #!/usr/bin/perl
    2 push (@INC,
    'pwd');
    3 use Cocoa;
    4 $cup = new Cocoa;
        第一行指出Perl解释器的位置,第二行中,将当前目录加到路径寻找列表@INC中供寻找包时使用。你也可以在不同的目录中创建你的模块并指出该绝对路径。例如,如果在/home/test/scripts/创建包,第二行就应该如下:
        push (@INC , "/home/test/scripts");
        在第三行中,包含上包Cocoa.pm以获取脚本中所需功能。use语句告诉Perl在@INC路径寻找文件Cocoa.pm并包含到解析的源文件拷贝中。use语句是使用类必须的。第四行调用new函数创建对象,这是Perl的妙处,也是其易混淆之处,也是其强大之处。创建对象的方法有多种,可以这样写:
        $cup = cocoa->new();
        如果你是C程序员,可以用双冒号强制使用Cocoa包中的new()函数,如:
        $cup = Cocoa::new();
        可以在构造函数中加入更多的代码,如在Cocoa.pm中,可以在每个对象创建时输出一个简单声明,还可以用构造函数初始化变量或设置数组或指针。
    注意:
    1、一定要在构造函数中初始化变量;
    2、一定要用my函数在方法中创建变量;
    3、一定不要在方法中使用local,除非真的想把变量传递给其它子程序;
    4、一定不要在类模块中使用全局变量。
        加上声明的Cocoa构造函数如下:
    sub new {
      my $this = {};
      print "\n /* \n ** Created by Cocoa.pm \n ** Use at own risk";
      print "\n ** Did this code even get pass the javac compiler? ";
      print "\n **/ \n";
      bless $this;
      return $this;
    }
        也可以简单地调用包内或包外的其它函数来做更多的初始化工作,如:
    sub new {
      my $this = {}
      bless $this;
      $this->doInitialization();
      return $this;
    }
        创建类时,应该允许它可被继承,应该可以把类名作为第一个参数来调用new函数,那么new函数就象下面的语句:
    sub new {
      my $class = shift; # Get the request class name
      my $this = {};
      bless $this, $class # Use class name to bless() reference
      $this->doInitialization(); return $this; 
    }
        此方法使用户可以下列三种方式之一来进行调用:
    Cocoa::new()
    Cocoa->new()
    new Cocoa
        可以多次bless一个引用对象,然而,新的将被bless的类必然把对象已被bless的引用去掉,对C和Pascal程序员来说,这就象把一个指针赋给分配的一块内存,再把同一指针赋给另一块内存而不释放掉前一块内存。总之,一个Perl对象每一时刻只能属于一个类。
        对象和引用的真正区别是什么呢?Perl对象被bless以属于某类,引用则不然,如果引用被bless,它将属于一个类,也便成了对象。对象知道自己属于哪个类,引用则不属于任何类。

    实例变量


        作为构造函数的new()函数的参数叫做实例变量。实例变量在创建对象的每个实例时用于初始化,例如可以用new()函数为对象的每个实例起个名字。
        可以用匿名哈希表或匿名数组来保存实例变量。
        用哈希表的代码如下:
    sub new {
    my $type = shift;
    my %parm = @_;
    my $this = {};
    $this->{
    'Name'} = $parm{'Name'};
    $this->{
    'x'} = $parm{'x'};
    $this->{
    'y'} = $parm{'y'};
    bless $this, $type;
    }
        用数组保存的代码如下:
    sub new {
    my $type = shift;
    my %parm = @_;
    my $this = [];
    $this->[0] = $parm{
    'Name'};
    $this->[1] = $parm{
    'x'};
    $this->[2] = $parm{
    'y'};
    bless $this, $type;
    }
        构造对象时,可以如下传递参数:
        $mug = Cocoa::new( 
    'Name' => 'top','x' => 10,'y' => 20 );
        操作符=>与逗号操作服功能相同,但=>可读性好。访问方法如下:
        print "Name=$mug->{
    'Name'}\n";
        print "x=$mug->{
    'x'}\n";
        print "y=$mug->{
    'y'}\n";
    五、方法
        Perl类的方法只不过是一个Perl子程序而已,也即通常所说的成员函数。Perl的方法定义不提供任何特殊语法,但规定方法的第一个参数为对象或其被引用的包。Perl有两种方法:静态方法和虚方法。
        静态方法第一个参数为类名,虚方法第一个参数为对象的引用。方法处理第一个参数的方式决定了它是静态的还是虚的。静态方法一般忽略掉第一个参数,因为它们已经知道自己在哪个类了,构造函数即静态方法。虚方法通常首先把第一个参数shift到变量self或this中,然后将该值作普通的引用使用。如:
    1. sub nameLister {
    2.     my $this = shift;
    3.     my ($keys ,$value );
    4.     while (($key, $value) = each (%$this)) {
    5.         print "\t$key is $value.\n";
    6.     }
    7. }
    六、方法的输出
        如果你现在想引用Cocoa.pm包,将会得到编译错误说未找到方法,这是因为Cocoa.pm的方法还没有输出。输出方法需要Exporter模块,在包的开始部分加上下列两行:
        require Exporter;
        @ISA = qw (Exporter);
        这两行包含上Exporter.pm模块,并把Exporter类名加入@ISA数组以供查找。接下来把你自己的类方法列在@EXPORT数组中就可以了。例如想输出方法closeMain和declareMain,语句如下:
        @EXPORT = qw (declareMain , closeMain);
        Perl类的继承是通过@ISA数组实现的。@ISA数组不需要在任何包中定义,然而,一旦它被定义,Perl就把它看作目录名的特殊数组。它与@INC数组类似,@INC是包含文件的寻找路径。@ISA数组含有类(包)名,当一个方法在当前包中未找到时就到@ISA中的包去寻找。@ISA中还含有当前类继承的基类名。
        类中调用的所有方法必须属于同一个类或@ISA数组定义的基类。如果一个方法在@ISA数组中未找到,Perl就到AUTOLOAD()子程序中寻找,这个可选的子程序在当前包中用sub定义。若使用AUTOLOAD子程序,必须用use Autoload;语句调用autoload.pm包。AUTOLOAD子程序尝试从已安装的Perl库中装载调用的方法。如果AUTOLOAD也失败了,Perl再到UNIVERSAL类做最后一次尝试,如果仍失败,Perl就生成关于该无法解析函数的错误。
    七、方法的调用
        调用一个对象的方法有两种方法,一是通过该对象的引用(虚方法),一是直接使用类名(静态方法)。当然该方法必须已被输出。现在给Cocoa类增加一些方法,代码如下:
    package Cocoa;
    require Exporter;
    @ISA = qw(Exporter);
    @EXPORT = qw(setImports, declareMain, closeMain);
    #
    # This routine creates the references for imports in Java functions
    #
    sub setImports{
      my $class = shift @_;
      my @names = @_;
      foreach (@names) {
        print "import " . $_ . ";\n";
      } 
    }
    #
    # This routine declares the main function in a Java script
    #
    sub declareMain{
      my $class = shift @_;
      my ( $name, $extends, $implements) = @_;
      print "\n public class $name";
      if ($extends) {
        print " extends " . $extends;
      }
      if ($implements) {
        print " implements " . $implements;
      }
      print " { \n";
    }
    #
    # This routine declares the main function in a Java script
    #
    sub closeMain{
      print "} \n";
    }
    #
    # This subroutine creates the header for the file.
    #
    sub new {
      my $this = {};
      print "\n /* \n ** Created by Cocoa.pm \n ** Use at own risk \n */ \n";
      bless $this;
      return $this;
    }

    1;
        现在,我们写一个简单的Perl脚本来使用该类的方法,下面是创建一个Java applet源代码骨架的脚本代码:
    #!/usr/bin/perl
    use Cocoa;
    $cup = new Cocoa;
    $cup->setImports( 
    'java.io.InputStream''java.net.*');
    $cup->declareMain( "Msg" , "java.applet.Applet", "Runnable");
    $cup->closeMain();
        这段脚本创建了一个叫做Msg的Java applet,它扩展(extend)了java.applet.Applet小应用程序并使之可运行(runnable),其中最后三行也可以写成如下:
    Cocoa::setImports($cup, 
    'java.io.InputStream''java.net.*');
    Cocoa::declareMain($cup, "Msg" , "java.applet.Applet", "Runnable");
    Cocoa::closeMain($cup);
        其运行结果如下:
    /*
    ** Created by Cocoa.pm
    ** Use at own risk 
    */
    import java.io.InputStream;
    import java.net.*;

    public class Msg extends java.applet.Applet implements Runnable {
    }
        注意:如果用->操作符调用方法(也叫间接调用),参数必须用括号括起来,如:$cup->setImports( 
    'java.io.InputStream''java.net.*');而双冒号调用如:Cocoa::setImports($cup, 'java.io.InputStream''java.net.*');也可去掉括号写成:Cocoa::setImports $cup, 'java.io.InputStream''java.net.*' ;
    八、重载
        有时需要指定使用哪个类的方法,如两个不同的类有同名方法的时候。假设类Espresso和Qava都定义了方法grind,可以用::操作符指定使用Qava的方法:
        $mess = Qava::grind("whole","lotta","bags");
        Qava::grind($mess, "whole","lotta","bags");
        可以根据程序的运行情况来选择使用哪个类的方法,这可以通过使用符号引用去调用来实现:
        $method = $local ? "Qava::" : "Espresso::";
        $cup->{$method}grind(@args);
    九、析构函数
        Perl跟踪对象的链接数目,当某对象的最后一个应用释放到内存池时,该对象就自动销毁。对象的析构发生在代码停止后,脚本将要结束时。对于全局变量而言,析构发生在最后一行代码运行之后。
        如果你想在对象被释放之前获取控制权,可以定义DESTROY()方法。DESTROY()在对象将释放前被调用,使你可以做一些清理工作。DESTROY()函数不自动调用其它DESTROY()函数,Perl不做内置的析构工作。如果构造函数从基类多次bless,DESTROY()可能需要调用其它类的DESTROY()函数。当一个对象被释放时,其内含的所有对象引用自动释放、销毁。
        一般来说,不需要定义DESTROY()函数,如果需要,其形式如下:
    sub DESTROY {
    #
    # Add code here.
    #
    }
        因为多种目的,Perl使用了简单的、基于引用的垃圾回收系统。任何对象的引用数目必须大于零,否则该对象的内存就被释放。当程序退出时,Perl的一个彻底的查找并销毁函数进行垃圾回收,进程中的一切被简单地删除。在UNIX类的系统中,这像是多余的,但在内嵌式系统或多线程环境中这确实很必要。
    十、继承
        类方法通过@ISA数组继承,变量的继承必须明确设定。下例创建两个类Bean.pm和Coffee.pm,其中Coffee.pm继承Bean.pm的一些功能。此例演示如何从基类(或称超类)继承实例变量,其方法为调用基类的构造函数并把自己的实例变量加到新对象中。
        Bean.pm代码如下:
    package Bean;
    require Exporter;
    @ISA = qw(Exporter);
    @EXPORT = qw(setBeanType);

    sub new {
      my $type = shift;
      my $this = {};
      $this->{
    'Bean'} = 'Colombian';
      bless $this, $type;
      return $this;
    }

    #
    # This subroutine sets the class name
    sub setBeanType{
      my ($class, $name) = @_;
      $class->{
    'Bean'} = $name;
      print "Set bean to $name \n";
    }
    1;
        此类中,用$this变量设置一个匿名哈希表,将
    'Bean'类型设为'Colombian'。方法setBeanType()用于改变'Bean'类型,它使用$class引用获得对对象哈希表的访问。
        Coffee.pm代码如下:
    1  #
    2  # The Coffee.pm file to illustrate inheritance.
    3  #
    4  package Coffee;
    5  require Exporter;
    6  require Bean;
    7  @ISA = qw(Exporter, Bean);
    8  @EXPORT = qw(setImports, declareMain, closeMain);
    9  #
    10 # set item
    11 #
    12 sub setCoffeeType{
    13   my ($class,$name) = @_;
    14   $class->{
    'Coffee'} = $name;
    15   print "Set coffee type to $name \n";
    16   }
    17 #
    18 # constructor
    19 #
    20 sub new {
    21   my $type = shift;
    22   my $this = Bean->new(); ##### <- LOOK HERE!!! ####
    23   $this->{
    'Coffee'} = 'Instant'; # unless told otherwise
    24   bless $this, $type;
    25   return $this;
    26   }
    27 1;
        第6行的require Bean;语句包含了Bean.pm文件和所有相关函数,方法setCoffeeType()用于设置局域变量$class->{
    'Coffee'}的值。在构造函数new()中,$this指向Bean.pm返回的匿名哈希表的指针,而不是在本地创建一个,下面两个语句分别为创建不同的哈希表从而与Bean.pm构造函数创建的哈希表无关的情况和继承的情况:
        my $this = {}; #非继承
        my $this = $theSuperClass->new(); #继承
        下面代码演示如何调用继承的方法:
    1  #!/usr/bin/perl
    2  push (@INC,
    'pwd');
    3  use Coffee;
    4  $cup = new Coffee;
    5  print "\n -------------------- Initial values ------------ \n";
    6  print "Coffee: $cup->{
    'Coffee'} \n";
    7  print "Bean: $cup->{
    'Bean'} \n";
    8  print "\n -------------------- Change Bean Type ---------- \n";
    9  $cup->setBeanType(
    'Mixed');
    10 print "Bean Type is now $cup->{
    'Bean'} \n";
    11 print "\n ------------------ Change Coffee Type ---------- \n";
    12 $cup->setCoffeeType(
    'Instant');
    13 print "Type of coffee: $cup->{
    'Coffee'} \n";
        该代码的结果输出如下:
    -------------------- Initial values ------------
    Coffee: Instant
    Bean: Colombian
    -------------------- Change Bean Type ----------
    Set bean to Mixed
    Bean Type is now Mixed 
    ------------------ Change Coffee Type ----------
    Set coffee type to Instant
    Type of coffee: Instant
        上述代码中,先输出对象创建时哈希表中索引为
    'Bean''Coffee'的值,然后调用各成员函数改变值后再输出。
        方法可以有多个参数,现在向Coffee.pm模块增加函数makeCup(),代码如下:
    sub makeCup {
      my ($class, $cream, $sugar, $dope) = @_;
      print "\n================================== \n"; 
      print "Making a cup \n";
      print "Add cream \n" if ($cream);
      print "Add $sugar sugar cubes\n" if ($sugar);
      print "Making some really addictive coffee ;-) \n" if ($dope);
      print "================================== \n";
    }
        此函数可有三个参数,不同数目、值的参数产生不同的结果,例如:
    1  #!/usr/bin/perl
    2  push (@INC,
    'pwd');
    3  use Coffee;
    4  $cup = new Coffee;
    5  #
    6  # With no parameters
    7  #
    8  print "\n Calling with no parameters: \n";
    9  $cup->makeCup;
    10 #
    11 # With one parameter
    12 #
    13 print "\n Calling with one parameter: \n";
    14 $cup->makeCup(
    '1');
    15 #
    16 # With two parameters
    17 #
    18 print "\n Calling with two parameters: \n";
    19 $cup->makeCup(1,
    '2');
    20 #
    21 # With all three parameters
    22 #
    23 print "\n Calling with three parameters: \n";
    24 $cup->makeCup(
    '1',3,'1');
        其结果输出如下:
    Calling with no parameters:
    ==================================
    Making a cup
    ==================================
    Calling with one parameter:
    ==================================
    Making a cup
    Add cream
    ==================================
    Calling with two parameters:
    ==================================
    Making a cup
    Add cream
    Add 2 sugar cubes
    ==================================
    Calling with three parameters:
    ==================================
    Making a cup
    Add cream
    Add 3 sugar cubes
    Making some really addictive coffee ;-)
    ==================================
        在此例中,函数makeCup()的参数既可为字符串也可为整数,处理结果相同,你也可以把这两种类型的数据处理区分开。在对参数的处理中,可以设置缺省的值,也可以根据实际输入参数值的个数给予不同处理。
    十一、子类方法的重载
        继承的好处在于可以获得基类输出的方法的功能,而有时需要对基类的方法重载以获得更具体或不同的功能。下面在Bean.pm类中加入方法printType(),代码如下:
    sub printType {
      my $class = shift @_;
      print "The type of Bean is $class->{
    'Bean'} \n";
    }
        然后更新其@EXPORT数组来输出:
        @EXPORT = qw ( setBeanType , printType );
        现在来调用函数printType(),有三种调用方法:
    $cup->Coffee::printType();
    $cup->printType();
    $cup->Bean::printType();
        输出分别如下:
    The type of Bean is Mixed
    The type of Bean is Mixed
    The type of Bean is Mixed
        为什么都一样呢?因为在子类中没有定义函数printType(),所以实际均调用了基类中的方法。如果想使子类有其自己的printType()函数,必须在Coffee.pm类中加以定义:
    #
    # This routine prints the type of $class->{
    'Coffee'}
    #
    sub printType {
      my $class = shift @_;
      print "The type of Coffee is $class->{
    'Coffee'} \n";
    }
        然后更新其@EXPORT数组:
        @EXPORT = qw(setImports, declareMain, closeMain, printType);
        现在输出结果变成了:
    The type of Coffee is Instant
    The type of Coffee is Instant
    The type of Bean is Mixed
        现在只有当给定了Bean::时才调用基类的方法,否则直接调用子类的方法。
        那么如果不知道基类名该如何调用基类方法呢?方法是使用伪类保留字SUPER::。在类方法内使用语法如:$this->SUPER::function(...argument list...); ,它将从@ISA列表中寻找。刚才的语句用SUPER::替换Bean::可以写为$cup->SUPER::printType(); ,其结果输出相同,为:
    The type of Bean is Mixed
    十二、Perl类和对象的一些注释
        OOP的最大好处就是代码重用。OOP用数据封装来隐藏一些复杂的代码,Perl的包和模块通过my函数提供数据封装功能,但是Perl并不保证子类一定不会直接访问基类的变量,这确实减少了数据封装的好处,虽然这种动作是可以做到的,但却是个很坏的编程风格。
    注意:
    1、一定要通过方法来访问类变量。
    2、一定不要从模块外部直接访问类变量。
        当编写包时,应该保证方法所需的条件已具备或通过参数传递给它。在包内部,应保证对全局变量的访问只用通过方法传递的引用来访问。对于方法要使用的静态或全局数据,应该在基类中用local()来定义,子类通过调用基类来获取。有时,子类可能需要改变这种数据,这时,基类可能就不知道怎样去寻找新的数据,因此,这时最好定义对该数据的引用,子类和基类都通过引用来改变该数据。
        最后,你将看到如下方式来使用对象和类:
        use coffee::Bean;
        这句语句的含义是“在@INC数组所有目录的Coffee子目录来寻找Bean.pm”。如果把Bean.pm移到./Coffee目录,上面的例子将用这一use语句来工作。这样的好处是有条理地组织类的代码。再如,下面的语句:
        use Another::Sub::Menu;
        意味着如下子目录树:
        ./Another/Sub/Menu.pm

     

     

    转载于:https://www.cnblogs.com/fpga/archive/2009/12/08/1619767.html

    展开全文
  • 11.3.3 protected:仅对子类包的类可见 300 11.3.4 默认控制符:仅在本包中可见 301 11.3.5 private:仅对本类可见 303 11.3.6 理解4个访问控制符 304 11.3.7 访问控制符可见性汇总 306 11.3.8 访问控制符...
  • 11.3.3 protected:仅对子类包的类可见 300 11.3.4 默认控制符:仅在本包中可见 301 11.3.5 private:仅对本类可见 303 11.3.6 理解4个访问控制符 304 11.3.7 访问控制符可见性汇总 306 11.3.8 访问控制符...
  • 11.3.3 protected:仅对子类包的类可见 300 11.3.4 默认控制符:仅在本包中可见 301 11.3.5 private:仅对本类可见 303 11.3.6 理解4个访问控制符 304 11.3.7 访问控制符可见性汇总 306 11.3.8 访问控制符...
  • 22.4.3 包和依赖关系举例 22.5 包识别 22.6 层和划分 22.7 两个包中类之间可见性 22.8 服务包接口--虚包模式 22.9 窗口不直接对外可见--模型一视图分离模式 22.9.1 模型一视图分离意义 22.9...
  • java api最新7.0

    千次下载 热门讨论 2013-10-26 17:34:06
    java.security.acl 此包中的类和接口已经被 java.security 包中的类取代。 java.security.cert 提供用于解析管理证书、证书撤消列表 (CRL) 证书路径的类接口。 java.security.interfaces 提供的接口用于生成 ...
  • JDK_1_6 API

    2017-03-04 23:06:21
    java.security.acl 此包中的类和接口已经被 java.security 包中的类取代。 java.security.cert 提供用于解析管理证书、证书撤消列表 (CRL) 证书路径的类接口。 java.security.interfaces 提供的接口用于生成 ...
  • Java 1.6 API 中文 New

    2013-10-26 14:08:22
    java.security.acl 此包中的类和接口已经被 java.security 包中的类取代。 java.security.cert 提供用于解析管理证书、证书撤消列表 (CRL) 证书路径的类接口。 java.security.interfaces 提供的接口用于生成 ...
  • JavaAPI1.6中文chm文档 part1

    热门讨论 2011-08-19 08:33:34
    java.security.acl 此包中的类和接口已经被 java.security 包中的类取代。 java.security.cert 提供用于解析管理证书、证书撤消列表 (CRL) 证书路径的类接口。 java.security.interfaces 提供的接口用于生成...
  • JavaAPI中文chm文档 part2

    2011-08-19 08:58:42
    java.security.acl 此包中的类和接口已经被 java.security 包中的类取代。 java.security.cert 提供用于解析管理证书、证书撤消列表 (CRL) 证书路径的类接口。 java.security.interfaces 提供的接口用于生成...
  • AICJava课程7-12章

    2007-07-29 20:55:11
    学会创建包包中定义,包外使用。  掌握package(又称默认,友元)控制符,系统掌握4种访问控制符 第6章 面向对象(多态) 4课时  理解多态概念,不关心具体细节,以抽象一般思维方式考虑问题...
  • 介绍如何使用Perl面向对象编程(OOP)特性及如何构建对象,还包括继承、方法重载数据封装等内容。 一、模块简介模块(module)就是Perl(pachage)。Perl中对象基于对包中数据项的引用。(引用见第x章引用。详见...

     

    介绍如何使用Perl的面向对象编程(OOP)特性及如何构建对象,还包括继承、方法重载和数据封装等内容。


    一、模块简介
    模块(module)就是Perl包(pachage)。Perl中的对象基于对包中数据项的引用。(引用见第x章引用。
    详见http://www.metronet.com/的perlmod和perlobj。

    在用其它语言进行面向对象编程时,先声明一个类然后创建该类的对象(实例),特定类所有对象的行为方式是相同的,由类方法确定,可以通过定义新类或从现存类继承来创建类。

    已熟悉面向对象编程的人可以在此遇到许多熟悉的术语。Perl一直是一个面向对象的语言,在Perl5中,语法略有变动,更规范化了对象的使用。

    下面三个定义对理解对象、类和方法在Perl中如何工作至关重要。

    .类是一个Perl包,其中含提供对象方法的类。
    .方法是一个Perl子程序,类名是其第一个参数。
    .对象是对类中数据项的引用。

    二、Perl中的类
    再强调一下,一个Perl类是仅是一个包而已。当你看到Perl文档中提到“类”时,把它看作“包”就行了。Perl5的语法可以创建类,如果你 已熟悉C++,那么大部分语法你已经掌握了。与Perl4不同的概念是用双冒号(::)来标识基本类和继承类(子类)。

    面向对象的一个重要特性是继承。Perl中的继承特性与其它面向对象语言不完全一样,它只继承方法,你必须用自己的机制来实现数据的继承。
    因为每个类是一个包,所以它有自己的名字空间及自己的符号名关联数组(详见第x章关联数组),每个类因而可以使用自己的独立符号名集。与包的引用结合,可以用单引号(')操作符来定位类中的变量,类中成员的定位形式如:$class'$member。在Perl5中,可用双冒号替代单引号来获得引用,如:$class'$member与$class::$member相同。

    三、创建类。
    本节介绍创建一个新类的必要步骤。下面使用的例子是创建一个称为Cocoa的简单的类,其功能是输出一个简单的Java应用的源码的必要部分。放心,这个例子不需要你有Java的知识,但也不会使你成为Java专家,其目的是讲述创建类的概念。
    首先,创建一个名为Cocoa.pm的包文件(扩展名pm是包的缺省扩展名,意为Perl Module)。一个模块就是一个包,一个包就是一个类。在做其它事之前,先加入“1;”这样一行,当你增加其它行时,记住保留“1;”为最后一行。这是 Perl包的必需条件,否则该包就不会被Perl处理。下面是该文件的基本结构。

    package Cocoa;

    #
    # Put "require" statements in for all required,imported packages
    #

    #
    # Just add code here
    #

    1; # terminate the package with the required 1;

         接下来,我们往包里添加方法使之成为一个类。第一个需添加的方法是new(),它是创建对象时必须被调用的,new()方法是对象的构造函数。

    四、构造函数
    构造函数是类的子程序,它返回与类名相关的一个引用。将类名与引用相结合称为“祝福”一个对象,因为建立该结合的函数名为bless(),其语法为:
    bless YeReference [,classname]
    YeReference是对被“祝福”的对象的引用,classname是可选项,指定对象获取方法的包名,其缺省值为当前包名。

    创建一个构建函数的方法为返回已与该类结合的内部结构的引用,如:

    sub new {
    my $this = {}; # Create an anonymous hash, and #self points to it.
    bless $this; # Connect the hash to the package Cocoa.
    return $this; # Return the reference to the hash.
    }

    1;

         {}创建一个对不含键/值对的哈希表(即关联数组)的引用,返回值被赋给局域变量$this。函数bless()取出该引用,告诉对象它引用的是Cocoa,最后返回该引用。函数的返回值现在指向这个匿名哈希表。从new()函数返回后,$this引用被销毁,但调用函数保存了对该哈希表的引用,因此该哈希表的引用数不会为零,从而使Perl在内存中保存该哈希表。创建对象可如下调用:
    $cup = new Cocoa;

    下面语句为使用该包创建对象的例子:

    1 #!/usr/bin/perl
    2 push (@INC,'pwd');
    3 use Cocoa;
    4 $cup = new Cocoa;

    第一行指出Perl解释器的位置,
    第二行中,将当前目录加到路径寻找列表@INC中供寻找包时使用。你也可以在不同的目录中创建你的模块并指出该绝对路径。例如,如果在/home/test/scripts/创建包,第二行就应该如下:
    push (@INC , "/home/test/scripts");
    在第三行中,包含上包Cocoa.pm以获取脚本中所需功能。use语句告诉Perl在@INC路径寻找文件Cocoa.pm并包含到解析的源文件拷贝中。use语句是使用类必须的。
    第四行调用new函数创建对象,这是Perl的妙处,也是其易混淆之处,也是其强大之处。创建对象的方法有多种,可以这样写:
    $cup = cocoa->new();

    如果你是C程序员,可以用双冒号强制使用Cocoa包中的new()函数,如:
    $cup = Cocoa::new();
    可以在构造函数中加入更多的代码,如在Cocoa.pm中,可以在每个对象创建时输出一个简单声明,还可以用构造函数初始化变量或设置数组或指针。
    注意:

    1、一定要在构造函数中初始化变量;
    2、一定要用my函数在方法中创建变量;
    3、一定不要在方法中使用local,除非真的想把变量传递给其它子程序;
    4、一定不要在类模块中使用全局变量。

         加上声明的Cocoa构造函数如下:

    sub new {
    my $this = {};
    print "\n /* \n ** Created by Cocoa.pm \n ** Use at own risk";
    print "\n ** Did this code even get pass the javac compiler? ";
    print "\n **/ \n";
    bless $this;
    return $this;
    }

         也可以简单地调用包内或包外的其它函数来做更多的初始化工作,如:

    sub new {
    my $this = {}
    bless $this;
    $this->doInitialization();
    return $this;
    }

         创建类时,应该允许它可被继承,应该可以把类名作为第一个参数来调用new函数,那么new函数就象下面的语句:

    sub new {
    my $class = shift; # Get the request class name
    my $this = {};
    bless $this, $class # Use class name to bless() reference
    $this->doInitialization(); return $this;
    }

         此方法使用户可以下列三种方式之一来进行调用:

    Cocoa::new()Cocoa->new()new Cocoa

         可以多次bless一个引用对象,然而,新的将被bless的类必然把对象已被bless的引用去掉,对C和Pascal程序员来说,这就象把一个指针赋给分配的一块内存,再把同一指针赋给另一块内存而不释放掉前一块内存。总之,一个Perl对象每一时刻只能属于一个类。对象和引用的真正区别是什么呢?Perl对象被bless以属于某类,引用则不然,如果引用被bless,它将属于一个类,也便成了对象。对象知道自己属于哪个类,引用则不属于任何类。

    实例变量

    作为构造函数的new()函数的参数叫做实例变量。实例变量在创建对象的每个实例时用于初始化,例如可以用new()函数为对象的每个实例起个名字。
    可以用匿名哈希表或匿名数组来保存实例变量。
    用哈希表的代码如下:

    sub new {

    my $type = shift;
    my %parm = @_;
    my $this = {};
    $this->{'Name'} = $parm{'Name'};
    $this->{'x'} = $parm{'x'};
    $this->{'y'} = $parm{'y'};
    bless $this, $type;

    }

         用数组保存的代码如下:

    sub new {

    my $type = shift;
    my %parm = @_;
    my $this = [];
    $this->[0] = $parm{'Name'};
    $this->[1] = $parm{'x'};
    $this->[2] = $parm{'y'};
    bless $this, $type;

    }

         构造对象时,可以如下传递参数:
    $mug = Cocoa::new( 'Name' => 'top','x' => 10,'y' => 20 );
    操作符=>与逗号操作服功能相同,但=>可读性好。访问方法如下:
    print "Name=$mug->{'Name'}\n";
    print "x=$mug->{'x'}\n";
    print "y=$mug->{'y'}\n";

    五、方法
    Perl类的方法只不过是一个Perl子程序而已,也即通常所说的成员函数。Perl的方法定义不提供任何特殊语法,但规定方法的第一个参数为对象或其被引用的包。Perl有两种方法:静态方法和虚方法。
    静态方法第一个参数为类名,虚方法第一个参数为对象的引用。方法处理第一个参数的方式决定了它是静态的还是虚的。静态方法一般忽略掉第一个参数, 因为它们已经知道自己在哪个类了,构造函数即静态方法。虚方法通常首先把第一个参数shift到变量self或this中,然后将该值作普通的引用使用。 如:

    1. sub nameLister {
    2.     my $this = shift;
    3.     my ($keys ,$value );
    4.     while (($key, $value) = each (%$this)) {
    5.         print "\t$key is $value.\n";
    6.     }
    7. }

    六、方法的输出
    如果你现在想引用Cocoa.pm包,将会得到编译错误说未找到方法,这是因为Cocoa.pm的方法还没有输出。输出方法需要Exporter模块,在包的开始部分加上下列两行:
    require Exporter;
    @ISA = qw (Exporter);
    这两行包含上Exporter.pm模块,并把Exporter类名加入@ISA数组以供查找。接下来把你自己的类方法列在@EXPORT数组中就可以了。例如想输出方法closeMain和declareMain,语句如下:
    @EXPORT = qw (declareMain , closeMain);
    Perl类的继承是通过@ISA数组实现的。@ISA数组不需要在任何包中定义,然而,一旦它被定义,Perl就把它看作目录名的特殊数组。它与 @INC数组类似,@INC是包含文件的寻找路径。@ISA数组含有类(包)名,当一个方法在当前包中未找到时就到@ISA中的包去寻找。@ISA中还含 有当前类继承的基类名。
    类中调用的所有方法必须属于同一个类或@ISA数组定义的基类。如果一个方法在@ISA数组中未找到,Perl就到AUTOLOAD()子程序中 寻找,这个可选的子程序在当前包中用sub定义。若使用AUTOLOAD子程序,必须用use Autoload;语句调用autoload.pm包。AUTOLOAD子程序尝试从已安装的Perl库中装载调用的方法。如果AUTOLOAD也失败 了,Perl再到UNIVERSAL类做最后一次尝试,如果仍失败,Perl就生成关于该无法解析函数的错误。

    七、方法的调用
    调用一个对象的方法有两种方法,一是通过该对象的引用(虚方法),一是直接使用类名(静态方法)。当然该方法必须已被输出。现在给Cocoa类增加一些方法,代码如下:

    package Cocoa;
    require Exporter;
    @ISA = qw(Exporter);
    @EXPORT = qw(setImports, declareMain, closeMain);
    #
    # This routine creates the references for imports in Java functions
    #
    sub setImports{
    my $class = shift @_;
    my @names = @_;
    foreach (@names) {
    print "import " . $_ . ";\n";
    }
    }
    #
    # This routine declares the main function in a Java script
    #
    sub declareMain{
    my $class = shift @_;
    my ( $name, $extends, $implements) = @_;
    print "\n public class $name";
    if ($extends) {
    print " extends " . $extends;
    }
    if ($implements) {
    print " implements " . $implements;
    }
    print " { \n";
    }
    #
    # This routine declares the main function in a Java script
    #
    sub closeMain{
    print "} \n";
    }
    #
    # This subroutine creates the header for the file.
    #
    sub new {
    my $this = {};
    print "\n /* \n ** Created by Cocoa.pm \n ** Use at own risk \n */ \n";
    bless $this;
    return $this;
    }

    1;

         现在,我们写一个简单的Perl脚本来使用该类的方法,下面是创建一个Java applet源代码骨架的脚本代码:

    #!/usr/bin/perl
    use Cocoa;
    $cup = new Cocoa;
    $cup->setImports( 'java.io.InputStream', 'java.net.*');
    $cup->declareMain( "Msg" , "java.applet.Applet", "Runnable");
    $cup->closeMain();

         这段脚本创建了一个叫做Msg的Java applet,它扩展(extend)了java.applet.Applet小应用程序并使之可运行(runnable),其中最后三行也可以写成如下:

    Cocoa::setImports($cup, 'java.io.InputStream', 'java.net.*');
    Cocoa::declareMain($cup, "Msg" , "java.applet.Applet", "Runnable");
    Cocoa::closeMain($cup);

         其运行结果如下:

    /*
    ** Created by Cocoa.pm
    ** Use at own risk
    */
    import java.io.InputStream;
    import java.net.*;

    public class Msg extends java.applet.Applet implements Runnable {
    }

         注意:如果用->操作符调用方法(也叫间接调用),参数必须用括号括起来,如:$cup->setImports( 'java.io.InputStream', 'java.net.*');而双冒号调用如:Cocoa::setImports($cup, 'java.io.InputStream', 'java.net.*');也可去掉括号写成:Cocoa::setImports $cup, 'java.io.InputStream', 'java.net.*' ;

    八、重载
    有时需要指定使用哪个类的方法,如两个不同的类有同名方法的时候。假设类Espresso和Qava都定义了方法grind,可以用::操作符指定使用Qava的方法:
    $mess = Qava::grind("whole","lotta","bags");
    Qava::grind($mess, "whole","lotta","bags");
    可以根据程序的运行情况来选择使用哪个类的方法,这可以通过使用符号引用去调用来实现:
    $method = $local ? "Qava::" : "Espresso::";
    $cup->{$method}grind(@args);

    九、析构函数
    Perl跟踪对象的链接数目,当某对象的最后一个应用释放到内存池时,该对象就自动销毁。对象的析构发生在代码停止后,脚本将要结束时。对于全局变量而言,析构发生在最后一行代码运行之后。
    如果你想在对象被释放之前获取控制权,可以定义DESTROY()方法。DESTROY()在对象将释放前被调用,使你可以做一些清理工作。 DESTROY()函数不自动调用其它DESTROY()函数,Perl不做内置的析构工作。如果构造函数从基类多次bless,DESTROY()可能 需要调用其它类的DESTROY()函数。当一个对象被释放时,其内含的所有对象引用自动释放、销毁。
    一般来说,不需要定义DESTROY()函数,如果需要,其形式如下:

    sub DESTROY {
    #
    # Add code here.
    #
    }

         因为多种目的,Perl使用了简单的、基于引用的垃圾回收系统。任何对象的引用数目必须大于零,否则该对象的内存就被释放。当程序退出时,Perl的一个 彻底的查找并销毁函数进行垃圾回收,进程中的一切被简单地删除。在UNIX类的系统中,这像是多余的,但在内嵌式系统或多线程环境中这确实很必要。

    十、继承
    类方法通过@ISA数组继承,变量的继承必须明确设定。下例创建两个类Bean.pm和Coffee.pm,其中Coffee.pm继承 Bean.pm的一些功能。此例演示如何从基类(或称超类)继承实例变量,其方法为调用基类的构造函数并把自己的实例变量加到新对象中。
    Bean.pm代码如下:

    package Bean;
    require Exporter;
    @ISA = qw(Exporter);
    @EXPORT = qw(setBeanType);

    sub new {
    my $type = shift;
    my $this = {};
    $this->{'Bean'} = 'Colombian';
    bless $this, $type;
    return $this;
    }

    #
    # This subroutine sets the class name
    sub setBeanType{
    my ($class, $name) = @_;
    $class->{'Bean'} = $name;
    print "Set bean to $name \n";
    }
    1;

         此类中,用$this变量设置一个匿名哈希表,将'Bean'类型设为'Colombian'。方法setBeanType()用于改变'Bean'类型,它使用$class引用获得对对象哈希表的访问。
    Coffee.pm代码如下:

    1 #
    2 # The Coffee.pm file to illustrate inheritance.
    3 #
    4 package Coffee;
    5 require Exporter;
    6 require Bean;
    7 @ISA = qw(Exporter, Bean);
    8 @EXPORT = qw(setImports, declareMain, closeMain);
    9 #
    10 # set item
    11 #
    12 sub setCoffeeType{
    13 my ($class,$name) = @_;
    14 $class->{'Coffee'} = $name;
    15 print "Set coffee type to $name \n";
    16 }
    17 #
    18 # constructor
    19 #
    20 sub new {
    21 my $type = shift;
    22 my $this = Bean->new(); ##### <- LOOK HERE!!! ####
    23 $this->{'Coffee'} = 'Instant'; # unless told otherwise
    24 bless $this, $type;
    25 return $this;
    26 }
    27 1;

         第6行的require Bean;语句包含了Bean.pm文件和所有相关函数,方法setCoffeeType()用于设置局域变量$class-> {'Coffee'}的值。在构造函数new()中,$this指向Bean.pm返回的匿名哈希表的指针,而不是在本地创建一个,下面两个语句分别为创 建不同的哈希表从而与Bean.pm构造函数创建的哈希表无关的情况和继承的情况:
    my $this = {}; #非继承
    my $this = $theSuperClass->new(); #继承
    下面代码演示如何调用继承的方法:

    1 #!/usr/bin/perl
    2 push (@INC,'pwd');
    3 use Coffee;
    4 $cup = new Coffee;
    5 print "\n -------------------- Initial values ------------ \n";
    6 print "Coffee: $cup->{'Coffee'} \n";
    7 print "Bean: $cup->{'Bean'} \n";
    8 print "\n -------------------- Change Bean Type ---------- \n";
    9 $cup->setBeanType('Mixed');
    10 print "Bean Type is now $cup->{'Bean'} \n";
    11 print "\n ------------------ Change Coffee Type ---------- \n";
    12 $cup->setCoffeeType('Instant');
    13 print "Type of coffee: $cup->{'Coffee'} \n";

         该代码的结果输出如下:

    -------------------- Initial values ------------
    Coffee: Instant
    Bean: Colombian
    -------------------- Change Bean Type ----------
    Set bean to Mixed
    Bean Type is now Mixed
    ------------------ Change Coffee Type ----------
    Set coffee type to Instant
    Type of coffee: Instant

         上述代码中,先输出对象创建时哈希表中索引为'Bean'和'Coffee'的值,然后调用各成员函数改变值后再输出。
    方法可以有多个参数,现在向Coffee.pm模块增加函数makeCup(),代码如下:

    sub makeCup {
    my ($class, $cream, $sugar, $dope) = @_;
    print "\n================================== \n";
    print "Making a cup \n";
    print "Add cream \n" if ($cream);
    print "Add $sugar sugar cubes\n" if ($sugar);
    print "Making some really addictive coffee ;-) \n" if ($dope);
    print "================================== \n";
    }

         此函数可有三个参数,不同数目、值的参数产生不同的结果,例如:

    1 #!/usr/bin/perl
    2 push (@INC,'pwd');
    3 use Coffee;
    4 $cup = new Coffee;
    5 #
    6 # With no parameters
    7 #
    8 print "\n Calling with no parameters: \n";
    9 $cup->makeCup;
    10 #
    11 # With one parameter
    12 #
    13 print "\n Calling with one parameter: \n";
    14 $cup->makeCup('1');
    15 #
    16 # With two parameters
    17 #
    18 print "\n Calling with two parameters: \n";
    19 $cup->makeCup(1,'2');
    20 #
    21 # With all three parameters
    22 #
    23 print "\n Calling with three parameters: \n";
    24 $cup->makeCup('1',3,'1');

         其结果输出如下:

    Calling with no parameters:
    ==================================
    Making a cup
    ==================================
    Calling with one parameter:
    ==================================
    Making a cup
    Add cream
    ==================================
    Calling with two parameters:
    ==================================
    Making a cup
    Add cream
    Add 2 sugar cubes
    ==================================
    Calling with three parameters:
    ==================================
    Making a cup
    Add cream
    Add 3 sugar cubes
    Making some really addictive coffee ;-)
    ==================================

         在此例中,函数makeCup()的参数既可为字符串也可为整数,处理结果相同,你也可以把这两种类型的数据处理区分开。在对参数的处理中,可以设置缺省的值,也可以根据实际输入参数值的个数给予不同处理。

    十一、子类方法的重载
    继承的好处在于可以获得基类输出的方法的功能,而有时需要对基类的方法重载以获得更具体或不同的功能。下面在Bean.pm类中加入方法printType(),代码如下:

    sub printType {
    my $class = shift @_;
    print "The type of Bean is $class->{'Bean'} \n";
    }

         然后更新其@EXPORT数组来输出:
    @EXPORT = qw ( setBeanType , printType );
    现在来调用函数printType(),有三种调用方法:

    $cup->Coffee::printType();
    $cup->printType();
    $cup->Bean::printType();

         输出分别如下:

    The type of Bean is Mixed
    The type of Bean is Mixed
    The type of Bean is Mixed

         为什么都一样呢?因为在子类中没有定义函数printType(),所以实际均调用了基类中的方法。如果想使子类有其自己的printType()函数,必须在Coffee.pm类中加以定义:

    #
    # This routine prints the type of $class->{'Coffee'}
    #
    sub printType {
    my $class = shift @_;
    print "The type of Coffee is $class->{'Coffee'} \n";
    }

         然后更新其@EXPORT数组:
    @EXPORT = qw(setImports, declareMain, closeMain, printType);
    现在输出结果变成了:

    The type of Coffee is Instant
    The type of Coffee is Instant
    The type of Bean is Mixed

         现在只有当给定了Bean::时才调用基类的方法,否则直接调用子类的方法。
    那么如果不知道基类名该如何调用基类方法呢?方法是使用伪类保留字SUPER::。在类方法内使用语法 如:$this->SUPER::function(...argument list...); ,它将从@ISA列表中寻找。刚才的语句用SUPER::替换Bean::可以写为$cup->SUPER::printType(); ,其结果输出相同,为:

    The type of Bean is Mixed

     

    转载于:https://www.cnblogs.com/licheng/archive/2009/11/01/1594237.html

    展开全文
  •  声明方法的存在而不去实现它的类被叫做抽象类(abstract class),它用于要创建一个体现某些基本行为的类,并为该类声明方法,但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量,...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    使用Visio创建图表可以使信息形象化,能够以更为直观有效方式进行信息交流,这是单纯文字数字无法比拟。 软件工程课程设计 考核方式: 课程设计(附设计说明文档,正文字数不少于1000字)(60%)+平时作业及实验...
  • Java代码实例

    2016-06-21 22:44:51
    7.1.1 声明创建包 100 7.1.2 引入包内资源 102 7.1.3 静态引入 104 7.2 类的访问控制 105 7.2.1 公有访问级别 105 7.2.2 默认访问级别 106 7.2.3 与源代码文件搭配 106 7.3 成员访问控制 ...
  • Java SE 6.0编程指南 源码

    热门讨论 2012-05-18 13:40:45
    7.1.1 声明创建包 100 7.1.2 引入包内资源 102 7.1.3 静态引入 104 7.2 类的访问控制 105 7.2.1 公有访问级别 105 7.2.2 默认访问级别 106 7.2.3 与源代码文件搭配 106 7.3 成员访问控制 ...
  • 6.2.3如何访问包中的类 6.3使用访问控制修饰符 6.3.1什么是访问控制修饰符 6.3.2类的访问控制修饰符 6.3.3成员的访问控制修饰符 6.4使用类中类 6.5小结 第7章继承多态 7.1使用继承 7.1.1为什么需要继承 ...
  • Java开发技术大全(500个源代码).

    热门讨论 2012-12-02 19:55:48
    notInPack.java 用前缀引用包中的类 onlyShow.java 一个简单的接口 Outer_1.java 外部类示例1 Outer_2.java 外部类示例2 Outer_3.java 外部类示例3 Outer_4.java 外部类示例4 Outer_5.java 外部类示例5 ...
  • java 面试题 总结

    2009-09-16 08:45:34
    声明方法的存在而不去实现它的类被叫做抽象类(abstract class),它用于要创建一个体现某些基本行为的类,并为该类声明方法,但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量,其...
  • Perl 实例精解(第三版).pdf

    热门讨论 2010-11-06 09:08:02
    练习10 将所有Perl都放入包中 练习11 压缩并放入库中 第12章 这个工作要求引用吗 12.1 什么是引用 12.1.1 符号引用与硬引用 12.1.2 硬引用 12.1.3 引用和匿名变量 12.1.4 嵌套数据结构 12.1.5 ...
  • 说明:Oracle中需要创建用户一定是要具有dba(数据库管理员)权限用户才能创建,而且创建的新用户不具备任何权限,连登录都不可以。 用法:create user 新用户名 identified by 密码 例子: 2. 修改密码 说明:...
  • ExtAspNet是一组专业Asp.net控件库,拥有原生AJAX支持丰富UI效果, 目标是创建没有JavaScript,没有CSS,没有UpdatePanel,没有WebServicesWeb应用程序。 支持浏览器: IE 7.0+, Firefox 3.0+, Chrome ...
  • ExtAspNet_v2.3.2_dll

    2010-09-29 14:37:08
    ExtAspNet是一组专业Asp.net控件库,拥有原生AJAX支持丰富UI效果, 目标是创建没有ViewState,没有JavaScript,没有CSS,没有UpdatePanel,没有WebServicesWeb应用程序。 支持浏览器: IE 7.0+, Firefox...
  • JSTL详细标签库介绍

    2010-11-01 16:37:44
    首步我们一般在程序中先处理我们完成异常处理的类,完成异常处理的功能,因为可能除数为0是会出现异常,我们查找java.lang包中各个Exception类,发现RuntimeException类集合中的ArithmeticException可以处理运算异常...

空空如也

空空如也

1 2
收藏数 27
精华内容 10
关键字:

如何创建包和引用包中的类