Exactly.

use Factory;
use Fruit;
my $apple = Factory->newObject("Apple");
$apple->doSomethingAnyGenericFruitCanDo();

Mind you, it's so easy to create objects by package name in Perl that the Factory pattern is often unnecessary. You should only use it when it would be inconvenient to specifically use Apple. Usually this is because new class types may be created even after the program's engine code is finished, such as class types created by the application's user.

I don't think so. I think you just want something like

# Initialize a new Z object for each element of @inits
my @obj_array = map {$z->new($_)} @inits;

or if $z is an object of the desired type rather than a class name,

# Initialize a new Z object for each element of @inits
my @obj_array = map {ref($z)->new($_)} @inits;

Factories are usually used by objects to create child objects. The purpose of the factory is to avoid having to hardcode a class name. For example,

package Tree;

sub add_item {
   my ($self, $item) = @_;
   my $parent_node = ...;
   $parent_node->add(new Node($item));
}

would be transfored into the following when using a factory:

package Tree;

sub add_item {
   my ($self, $item) = @_;
   my $node_factory = $self->{node_factory};
   my $parent_node = ...;
   $parent_node->add($node_factory->create($item));
}

sub set_node_factory {
   my ($self, $node_factory) = @_;
   $self->{node_factory} = $node_factory;
}

package NodeFactory;

# Overridable
sub create {
   shift(@_);
   return Node->new(@_);
}

But that's pretty useless in Perl, since it lacks the typing of Java. In Perl, you could just pass a class name ('Node') instead of a factory.

To provide a counterpoint to the "Perl doesn't usually need factories" replies, I use a factory in [cpan://PDF::Template] to manage the nodename-to-classname mapping. This way, I can do something like:

my $obj = $factory->create_element( $node_name, @args );

# Check to see if $obj represents a 'foobar' node
if ( $obj->isa( 'foobar' ) ) {
    # Do something
}

This is important to me for three reasons:

1. My users can register new nodenames and the factory manages that
2. I have some classes that can handle more than one nodename. For example, IF and CONDITIONAL are aliases to each other and are both handled by PDF::Template::Element::Conditional.
3. In most of the code, I need to differentiate what's a container (can have children) and what's an element (can't have children). However, in the parsing code, I don't care about that (because validation is handled somewhere else).

Does that help?