In computer science, a dynamic programming language is a kind of programming language in which programs can change their structure as they run: functions may be introduced or removed, new classes of objects may be created, new modules may appear.

# Обертка вокруг теста для того, чтобы не вылетать по исключению.
def execute_test_case( message )
    begin
        puts "-- #{message} --"
        yield
    rescue Exception => x
        puts "!!! caught: #{x} !!!"
    end
end

# Исходный класс и его методы.
class Test
    def hello; puts "hello"; end
    def bye; puts "bye"; end
end

# Тестируемый объект. Важно отметить, что все последующие модификации
# класса Test будут отражаться на уже существующем объекте.
t = Test.new

execute_test_case "Original Test class" do t.hello; t.bye end

# Теперь метод bye нам не нужен.
class Test
    remove_method :bye
end

execute_test_case "Test class without bye method" do t.hello; t.bye end

# Теперь заменяем метод hello и возвращаем метод bye
class Test
    def hello; puts "Hello, world"; end
    def bye; puts "Bye, world"; end
end

execute_test_case "Modified Test class" do t.hello; t.bye end

-- Original Test class --
hello
bye
-- Test class without bye method --
hello
!!! caught: undefined method `bye' for #<Test:0x2777040> !!!
-- Modified Test class --
Hello, world
Bye, world

// SomeClass.java

public class SomeClass
{
    public void hello()
        {
            // трам-пам-пам...
        }
}

public class SomeClass
{
    public void bye()
        {
            // трам-пам-пам...
        }
}

public class SomeClassTest
{
    static public void main( string args[] )
        {
            SomeClass s = new SomeClass();
            s.hello();
            s.bye();
        }
}

E>Можно ли в Java вводить новые методы в уже существующие классы?

Да. На том построена туча фрэймворков.

class CSharpTriangle
{
  public Node[] nodes = new Node[3]; // все приехали, можете закрывать свою лавочку
}

class A
{
    public void hello() { System.out.println( "original hello!" ); }
}

class Test
{
    private static void use( A a )
    {
        Class s = a.getClass().getSuperclass();
        System.out.println( "use object of: " + a.getClass().getName() +
            ", with superclass: " + s.getName() );

        a.hello();
    }

    public static void main( String args[] )
    {
        A a;
        use( a = new A() {
                public void bye() { say_bye(); }
                private void say_bye() { System.out.println( "bye!" ); }
            }
        );

        A b;
        use( b = new A() {
                public void hello() { System.out.println( "another hello!" ); bye(); }
                public void bye() { say_bye(); }
                private void say_bye() { System.out.println( "another bye!" ); }
            }
        );
    }
}

use object of: Test$1, with superclass: A
original hello!
use object of: Test$2, with superclass: A
another hello!
another bye!

K>>class CSharpTriangle
K>>{
K>>  public Node[] nodes = new Node[3]; // все приехали, можете закрывать свою лавочку
K>>}
K>>

struct Triangle
{
   Node  *nodes[3];
};

class Triangle
{
   public Node A, B, C; // вместо массива переменные
}

Node* node_at( int idx )
{
   static const int imap[] = { 1, 2, 0, 1, 2, 0, 1 };
   return nodes[imap[idx+2]]; // транслируем колецевой индекс в обычный
}
// юзается очень удобно, пример вычисление всех углов:
void angles(Triangle &t)
{
   double angs[3];
   for ( int i = 0; i < 3; i++ )
      angs[i] = angle( t.node_at(i-1), t.node_at(i), t.node_at(i+1) );
    
}

просто новые технологии с рынка не уходят — они его расширяют

struct CSharpTriangle
{
  public fixed Node nodes[3];
}

K>>struct Triangle
K>>{
K>>   Node  *nodes[3];
K>>};
K>>

GZ>А зачем указатели? Это оверхед.

K>>class Triangle
K>>{
K>>   public Node A, B, C; // вместо массива переменные
K>>}
K>>

Node node_at( int idx )
{
   switch ( idx )
   {
      case 0: return A;
      case 1: return B;
      // понеслась 
   }
}

K>Node node_at( int idx )
K>{
K>   switch ( idx )
K>   {
K>      case 0: return A;
K>      case 1: return B;
K>      // понеслась 
K>   }
K>}
K>

Node next_node()
{
  yeald return A;
    yeald return B;
    yeald return C;
}