What is the default layout manager for a `Scene` in JavaFX?

Here is my version of the example code shown in the Javadoc for TableView in JavaFX/OpenJFX. (The Person class is a record, read-only.)

package work.basil.example.jfxexample;

import javafx.application.Application;
import javafx.beans.property.SimpleStringProperty;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Scene;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.stage.Stage;

import java.util.List;

public class HelloApplication extends Application
{
    @Override
    public void start ( Stage stage )
    {
        TableView < Person > tableViewPersons = new TableView <> ( );
        ObservableList < Person > persons = FXCollections.observableArrayList ( this.fetchPersons ( ) );
        tableViewPersons.setItems ( persons );

        TableColumn < Person, String > firstNameCol = new TableColumn <> ( "First Name" );
        firstNameCol.setCellValueFactory (   ( TableColumn.CellDataFeatures < Person, String > p ) -> new SimpleStringProperty (p.getValue().getFirstName ()));

        TableColumn < Person, String > lastNameCol = new TableColumn <> ( "Last Name" );
        lastNameCol.setCellValueFactory (   ( TableColumn.CellDataFeatures < Person, String > p ) -> new SimpleStringProperty (p.getValue().getLastName ()));

        List < TableColumn < Person, ? > > columns = List.of ( firstNameCol , lastNameCol );  // <--- Adding this line to make explicit the parameterized type of `TableColumn` to resolve the "Unchecked generics" warning.
        tableViewPersons.getColumns ( ).setAll ( columns );

        Scene scene = new Scene ( tableViewPersons , 320 , 240 );
        stage.setTitle ( "JavaFX Example" );
        stage.setScene ( scene );
        stage.show ( );
    }

    private List < Person > fetchPersons ( )
    {
        return List.of (
                new Person ( "William" , "Reed" ) ,
                new Person ( "James" , "Michaelson" ) ,
                new Person ( "Julius" , "Dean" ) );
    }

    public static void main ( String[] args )
    {
        launch ( );
    }
}

This app presents a window filled with the table view. Resizing the window results in the TableView control being resized as well, to continue filling the window.

👉🏼 What is the default layout manager of the Scene in this example?

There are no layout managers in JavaFX.
The Scence API documentation states how Scene behaves on resizing:
> If a Group is used as the root, the contents of the scene graph will be clipped by the scene's width and height and changes to the scene's size (if user resizes the stage) will not alter the layout of the scene graph. If a resizable node (layout Region or Control) is set as the root, then the root's size will track the scene's size, causing the contents to be relayed out as necessary.

Since TableView is a Control, the latter behavior is what you get and what you see.

As pointed out in another answer, JavaFX does not have explicit layout managers (as AWT, and consequently Swing, does), and the behavior when resizing a Scene (for example, when the user resizes the window containing it) is described in the API documentation.

Taking the question

> What is the default layout manager of the Scene in this example?

to more generally mean "how does a Scene perform layout by default", what actually happens when a scene changes size is that it invokes resize(...) on the root node, passing in its new width and height.

(Note that while this is the "default" behavior, it is also the only behavior: it cannot be changed.)

The actual implementation of resize(...) defined in Node is a no-op, and this is inherited by both Parent and Group. So if the root node is an instance of Group, nothing actually happens.

Region, on the other hand, overrides resize(...) to set its width and height to the values passed in, thereby causing the size of a root that is an instance of Region to track the size of the scene. Changing the size triggers a call to layout() on the next rendering pulse.

layout(), which is a final method, is defined to first call layoutChildren() (which is overridable and should resize and position the child nodes), and then iteratively call layout() on any child nodes which are instances of Parent.

So the actual effect of resizing the Scene whose root is an instance of Region is determined by the implementation of layoutChildren() for that root. In the case of a Control, such as TableView, it is delegated to the skin. Skin additionally defines a layoutChildren() method whose implementation determines how the various components of the control are laid out in the new width and height.

Consequently in your example, the size of the TableView is set to the size of the control (by the implementation of resize() in Region), and the table view is then laid out according to the implementation of TableViewSkin.