ReflectionClass::hasMethod

Parent methods (regardless of visibility) are also available to a ReflectionObject. E.g.,
<?php
class ParentObject {
 public function parentPublic( ) {
 }
 private function parentPrivate( ) {
 }
}
class ChildObject extends ParentObject {
}
$Instance = new ChildObject();
$Reflector = new ReflectionObject($Instance);
var_dump($Reflector->hasMethod('parentPublic')); // true
var_dump($Reflector->hasMethod('parentPrivate')); // true
?>

Trait methods can be seen by both actual and alias names
<?php
trait Sauce
{
 public function getSpicy()
 {
 return 'Cayenne';
 }
}
class Sandwich
{
 use Sauce {
 Sauce::getSpicy as getSweet;
 }
}
$class = new \ReflectionClass('Sandwich');
var_dump($class->hasMethod('getSweet'));
var_dump($class->hasMethod('getSpicy'));
?>
bool(true)
bool(true)

Annotated methods that are implemented using PHP magic methods are not recognized by "hasMethod".
<?php
/**
 * @method void annotatedMethod()
 */
class SomeClass
{
 public function __call($name, $arguments)
 {
 echo "this is magic method: $name.\n";
 }
 public function codedMethod()
 {
 echo "this is coded method.\n";
 }
}
$obj = new \SomeClass();
$obj->codedMethod();
$obj->annotatedMethod();
$ref = new ReflectionClass(\SomeClass::class);
echo "SomeClass has 'codedMethod': " . json_encode($ref->hasMethod('codedMethod')) . ".\n";
echo "SomeClass has 'annotatedMethod': " . json_encode($ref->hasMethod('annotatedMethod')) . ".\n";
?>

Output:
this is coded method.
this is magic method: annotatedMethod.
SomeClass has 'codedMethod': true.
SomeClass has 'annotatedMethod': false.

note that even if private method will also be 'has'.

It might be interesting to know that this is the only method to determine if a trait has a specific method:
 trait a{
 function __wakeup(){}
 }
 class b{}
 class c{
 use a;
 }
 var_dump((new ReflectionClass('a'))->hasMethod('__wakeup')); // true
 var_dump((new ReflectionClass('b'))->hasMethod('__wakeup')); // false
 var_dump((new ReflectionClass('c'))->hasMethod('__wakeup')); // true

A way to check if you can call an method over a class:
<?php
function is_public_method(
 /* string */$className,
 /* string */$method
){
 $classInstance = new ReflectionClass($className);
 if ($classInstance->hasMethod($method)) {
 return false;
 }
 $methodInstance = $instance->getMethod($method);
 return $methodInstance->isPublic();
}
?>