UntypedAbstractActor

java.lang.Object
- akka.actor.AbstractActor
- - akka.actor.UntypedAbstractActor

All Implemented Interfaces:

Actor
```
public abstract class UntypedAbstractActor
extends AbstractActor
```
If the validation of the ReceiveBuilder match logic turns out to be a bottleneck for some of your actors you can consider to implement it at lower level by extending UntypedAbstractActor instead of AbstractActor. The partial functions created by the ReceiveBuilder consist of multiple lambda expressions for every match statement, where each lambda is referencing the code to be run. This is something that the JVM can have problems optimizing and the resulting code might not be as performant as the untyped version. When extending UntypedAbstractActor each message is received as an untyped Object and you have to inspect and cast it to the actual message type in other ways (instanceof checks).

Nested Class Summary
- Nested classes/interfaces inherited from class akka.actor.AbstractActor
  AbstractActor.ActorContext, AbstractActor.Receive
- Nested classes/interfaces inherited from interface akka.actor.Actor
  Actor.emptyBehavior$, Actor.ignoringBehavior$

Constructor Summary

Constructors
Constructor Description

UntypedAbstractActor()

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`AbstractActor.Receive`	`createReceive()`	An actor has to define its initial receive behavior by implementing the `createReceive` method.
`abstract void`	`onReceive(java.lang.Object message)`	To be implemented by concrete UntypedAbstractActor, this defines the behavior of the actor.
`scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>`	`receive()`	Scala API: This defines the initial actor behavior, it must return a partial function with the actor logic.
`void`	`unhandled(java.lang.Object message)`	Recommended convention is to call this method if the message isn't handled in `onReceive(java.lang.Object)` (e.g.

Methods inherited from class akka.actor.AbstractActor
akka$actor$Actor$_setter_$context_$eq, akka$actor$Actor$_setter_$self_$eq, context, emptyBehavior, getContext, getSelf, getSender, postRestart, postStop, preRestart, preRestart, preStart, receiveBuilder, self, supervisorStrategy

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface akka.actor.Actor
aroundPostRestart, aroundPostStop, aroundPreRestart, aroundPreStart, aroundReceive, sender

- Constructor Detail
  - UntypedAbstractActor
```
public UntypedAbstractActor()
```
- Method Detail
  - createReceive
```
public final AbstractActor.Receive createReceive()
```
    Description copied from class: AbstractActor
    
    An actor has to define its initial receive behavior by implementing the createReceive method.
    
    Specified by:
    
    createReceive in class AbstractActor
  - onReceive
```
public abstract void onReceive(java.lang.Object message)
                        throws java.lang.Throwable
```
    To be implemented by concrete UntypedAbstractActor, this defines the behavior of the actor.
    
    Throws:
    
    java.lang.Throwable
  - receive
```
public scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> receive()
```
    Description copied from interface: Actor
    
    Scala API: This defines the initial actor behavior, it must return a partial function with the actor logic.
    
    Specified by:
    
    receive in interface Actor
    
    Overrides:
    
    receive in class AbstractActor
  - unhandled
```
public void unhandled(java.lang.Object message)
```
    Recommended convention is to call this method if the message isn't handled in onReceive(java.lang.Object) (e.g. unknown message type). By default it fails with either a DeathPactException (in case of an unhandled Terminated message) or publishes an UnhandledMessage to the actor's system's EventStream.