在JavaFX中调整窗口大小时动态调整图形大小

我有一个任务，我想创建4个圆圈，里面有4个三角形，像一个扇子，创建一个时钟，它会随机改变程序每次运行的时间，并创建一个刽子手图形。我已经完成了所有这些图形，但我的最后一步是使我创建的所有图形随着窗口大小的调整而动态调整大小。我不确定如何实现这种动态调整大小，但我相信它处理的是绑定，而我并不真正了解如何实现绑定。如果有人能帮助我，我将不胜感激。下面是我的代码

import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.geometry.*;
import javafx.scene.layout.*;
import javafx.scene.shape.*;
import javafx.scene.paint.*;
import java.util.*;
import javafx.scene.text.*;
import javafx.scene.control.*;
import java.lang.*;
import javafx.beans.binding.*;

public class test2 extends Application{

   @Override
   public void start(Stage primoStage){

      GridPane gridCircles = new GridPane();
      gridCircles.setPadding(new Insets(10));
      gridCircles.setHgap(5);
      gridCircles.setVgap(5);
      CirclePane cPane1 = new CirclePane();
      CirclePane cPane2 = new CirclePane();
      CirclePane cPane3 = new CirclePane();
      CirclePane cPane4 = new CirclePane();

      gridCircles.add(cPane1, 0, 0);
      gridCircles.add(cPane2, 1, 0);
      gridCircles.add(cPane3, 0, 1);
      gridCircles.add(cPane4, 1, 1);

      GridPane gridClock = new GridPane();
      gridClock.setPadding(new Insets(10));
      gridClock.setHgap(5);
      gridClock.setVgap(5);
      ClockPane clock = new ClockPane();
      String timeString = clock.getHour() + ":" + clock.getMinute() + ":" + clock.getSecond() + clock.getMeridiem();
      Label randomTime = new Label(timeString);
      gridClock.add(clock, 0, 0);
      GridPane.setHalignment(clock, HPos.CENTER);
      GridPane.setValignment(clock, VPos.CENTER);
      gridClock.add(randomTime, 0, 1);
      GridPane.setHalignment(randomTime, HPos.CENTER);
      GridPane.setValignment(randomTime, VPos.CENTER);

      GridPane gridHangMan = new GridPane();
      gridHangMan.setPadding(new Insets(10));
      gridHangMan.setHgap(5);
      gridHangMan.setVgap(5);
      hangingManPane hangMan = new hangingManPane();
      gridHangMan.add(hangMan, 0, 0);
      gridHangMan.setHalignment(hangMan, HPos.CENTER);
      gridHangMan.setValignment(hangMan, VPos.CENTER);

      GridPane gridPane = new GridPane();
      gridPane.setPadding(new Insets(10));
      gridPane.setHgap(5);
      gridPane.setVgap(5);
      gridPane.add(gridCircles, 0, 0);
      gridPane.add(gridClock, 1, 0);
      gridPane.add(gridHangMan, 2, 0);

      Scene scene = new Scene(gridPane, 1500, 500);
      primoStage.setTitle("Assignment 6 Test");
      primoStage.setScene(scene);
      primoStage.show();
   }

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

class CirclePane extends Pane {
  private Circle circle = new Circle(100,100,100);
  private Arc arc1 = new Arc(100,100,85,85,30,30);
  private Arc arc2 = new Arc(100,100,85,85,120,30);
  private Arc arc3 = new Arc(100,100,85,85,210,30);
  private Arc arc4 = new Arc(100,100,85,85,300,30);

   public CirclePane(){
      circle.setStroke(Color.BLACK);
      circle.setFill(Color.WHITE);
      arc1.setFill(Color.BLACK);
      arc1.setType(ArcType.ROUND);
      arc2.setFill(Color.BLACK);
      arc2.setType(ArcType.ROUND);
      arc3.setFill(Color.BLACK);
      arc3.setType(ArcType.ROUND);
      arc4.setFill(Color.BLACK);
      arc4.setType(ArcType.ROUND);
      getChildren().addAll(circle,arc1,arc2,arc3,arc4);
   }
}

class ClockPane extends Pane {
  private int hour;
  private int minute;
  private int second;
  private String meridiem;
  private double w = 400;
  private double h = 400;
  Random rand = new Random();

  public ClockPane(){
    setRandomTime();
  }

  public ClockPane(int hour, int minute, int second){
    this.hour = hour;
    this.minute = minute;
    this.second = second;
    paintClock();
  }

  public String getHour() {
    if (this.hour < 10){
      return "0"+hour;
    }
    return String.valueOf(hour);
  }

  public String getMinute() {
    if (this.minute <10){
      return "0"+minute;
    }
    return String.valueOf(minute);
  }

  public String getSecond() {
    if (this.second < 10){
      return "0"+second;
    }
    return String.valueOf(second);
  }

  public void setMinute(int minute) {
    this.minute = minute;
    paintClock();
  }

  public void setSecond(int second) {
    this.second = second;
  }

  public void setHour(int hour) {
    this.hour = hour;
  }

  public double getW() {
    return w;
  }

  public void setW(double w) {
    this.w = w;
    paintClock();
  }

  public double getH() {
    return h;
  }

  public void setH(double h) {
    this.h = h;
    paintClock();
  }

  public String getMeridiem() {
    if (Integer.valueOf(this.meridiem) > 12){
      return "pm";
    }
    return "am";
  }

  public void setMeridiem(String meridiem) {
    this.meridiem = meridiem;
  }

  public void setRandomTime() {
    Calendar calendar = new GregorianCalendar();

    this.hour = rand.nextInt(12 - 0 + 1) + 0;
    this.minute = rand.nextInt(60 - 0 + 1) + 0;
    this.second = rand.nextInt(60 - 0 + 1) + 0;
    this.meridiem = String.valueOf(rand.nextInt(24 - 0 +1) + 0);

    paintClock();
  }

  protected void paintClock() {
    double clockRadius = Math.min(w,h) * 0.8 * 0.5;
    double centerX = w/2;
    double centerY = h/2;

    Circle circle = new Circle(centerX, centerY, clockRadius);
    circle.setFill(Color.WHITE);
    circle.setStroke(Color.BLACK);
    Text t1 = new Text(centerX - 5, centerY - clockRadius + 14, "12");
    Text t2 = new Text(centerX - clockRadius + 3, centerY + 5, "9");
    Text t3 = new Text(centerX + clockRadius - 10, centerY + 3, "3");
    Text t4 = new Text(centerX - 3, centerY + clockRadius - 3, "6");

    double sLength = clockRadius * 0.8;
    double secondX = centerX + sLength * Math.sin(second * (2 * Math.PI / 60));
    double secondY = centerY - sLength * Math.cos(second * (2 * Math.PI / 60));
    Line sLine = new Line(centerX, centerY, secondX, secondY);
    sLine.setStroke(Color.RED);

    double mLength = clockRadius * 0.65;
    double xMinute = centerX + mLength * Math.sin(minute * (2 * Math.PI / 60));
    double minuteY = centerY - mLength * Math.cos(minute * (2 * Math.PI / 60));
    Line mLine = new Line(centerX, centerY, xMinute, minuteY);
    mLine.setStroke(Color.BLUE);

    double hLength = clockRadius * 0.5;
    double hourX = centerX + hLength * Math.sin((hour % 12 + minute / 60.0) * (2 * Math.PI / 12));
    double hourY = centerY - hLength * Math.cos((hour % 12 + minute / 60.0) * (2 * Math.PI / 12));
    Line hLine = new Line(centerX, centerY, hourX, hourY);
    hLine.setStroke(Color.GREEN);

    getChildren().clear();
    getChildren().addAll(circle, t1, t2, t3, t4, sLine, mLine, hLine);
  }
}

class hangingManPane extends Pane {
  private Arc arc1 = new Arc(100, 450, 100, 100, 45, 90);
  private Line line1 = new Line(100, 50, 100 ,350);
  private Line line2 = new Line(100, 50, 300, 50);
  private Line line3 = new Line(300, 50, 300, 100);
  private Circle circle = new Circle(300, 130, 30);
  private Line line4 = new Line(285, 160, 225, 250);
  private Line line5 = new Line(315, 160, 375, 250);
  private Line line6 = new Line(300, 160, 300, 280);
  private Line line7 = new Line(300, 280, 250, 360);
  private Line line8 = new Line(300, 280, 350, 360);

  public hangingManPane() {
    arc1.setFill(Color.TRANSPARENT);
    arc1.setType(ArcType.OPEN);
    arc1.setStroke(Color.BLACK);
    arc1.setStrokeWidth(5);
    line1.setStroke(Color.BLACK);
    line1.setStrokeWidth(5);
    line2.setStroke(Color.BLACK);
    line2.setStrokeWidth(5);
    line3.setStroke(Color.BLACK);
    line3.setStrokeWidth(5);
    circle.setStroke(Color.BLACK);
    circle.setFill(Color.TRANSPARENT);
    circle.setStrokeWidth(5);
    line4.setStroke(Color.BLACK);
    line4.setStrokeWidth(5);
    line5.setStroke(Color.BLACK);
    line5.setStrokeWidth(5);
    line6.setStroke(Color.BLACK);
    line6.setStrokeWidth(5);
    line7.setStroke(Color.BLACK);
    line7.setStrokeWidth(5);
    line8.setStroke(Color.BLACK);
    line8.setStrokeWidth(5);
    getChildren().addAll(arc1, line1, line2, line3, circle, line4, line5, line6, line7, line8);
  }
}

导入javafx.application.*；
导入javafx.stage.*；
导入javafx.scene.*；
导入javafx.geometry.*；
导入javafx.scene.layout.*；
导入javafx.scene.shape.*；
导入javafx.scene.paint.*；
导入java.util.*；
导入javafx.scene.text.*；
导入javafx.scene.control.*；
导入java.lang.*；
导入javafx.beans.binding.*；
公共类test2扩展了应用程序{
@凌驾
公共无效开始（阶段初始）{
GridPane gridCircles=新建GridPane（）；
设置填充（新插图（10））；
网格圆。setHgap（5）；
网格圆。setVgap（5）；
圆环烷cPane1=新圆环烷（）；
圆环烷cPane2=新圆环烷（）；
圆环烷cPane3=新圆环烷（）；
CirclePane cPane4=新的CirclePane（）；
add（cPane1，0，0）；
add（cPane2，1，0）；
add（cPane3,0,1）；
添加（cPane4,1,1）；
GridPane gridClock=新的GridPane（）；
设置填充（新插图（10））；
gridClock.setHgap（5）；
gridClock.setVgap（5）；
时钟窗格时钟=新的时钟窗格（）；
String timeString=clock.getHour（）+“：”+clock.getMinute（）+“：”+clock.getSecond（）+clock.getMeridiem（）；
标签随机时间=新标签（时间串）；
添加（时钟，0，0）；
GridPane.setHalignment（时钟，HPos.CENTER）；
GridPane.setValignment（时钟、VPos.CENTER）；
gridClock.add（随机时间，0,1）；
GridPane.setHalignment（随机时间，HPos.CENTER）；
GridPane.setValignment（随机时间，VPos.CENTER）；
GridPane gridHangMan=新的GridPane（）；
设置填充（新插图（10））；
gridHangMan.setHgap（5）；
gridHangMan.setVgap（5）；
hangingManPane hangMan=新的hangingManPane（）；
添加（hangMan，0,0）；
gridHangMan.setHalignment（hangMan，HPos.CENTER）；
gridHangMan.setValignment（hangMan，VPos.CENTER）；
GridPane GridPane=新建GridPane（）；
设置填充（新插图（10））；
网格窗格。setHgap（5）；
gridPane.setVgap（5）；
添加（gridCircles，0,0）；
添加（gridClock，1,0）；
添加（gridHangMan，2,0）；
场景=新场景（网格窗格，1500500）；
初始状态设置标题（“任务6测试”）；
原始场景（场景）；
primostate.show（）；
}
公共静态void main（字符串[]args）{
发射（args）；
}
}
类CirclePane扩展窗格{
私人圈子=新圈子（100100）；
专用电弧arc1=新电弧（100100,85,85,30,30）；
专用电弧arc2=新电弧（100100,85,85120,30）；
专用电弧arc3=新电弧（100100,85,85210,30）；
专用电弧arc4=新电弧（100100,85,85300,30）；
公共环烷（）{
圆整定行程（颜色为黑色）；
圆形。设置填充（颜色。白色）；
arc1.设置填充（颜色：黑色）；
arc1.setType（ArcType.ROUND）；
arc2.设置填充（颜色：黑色）；
arc2.setType（ArcType.ROUND）；
arc3.设置填充（颜色：黑色）；
arc3.setType（ArcType.ROUND）；
arc4.设置填充（颜色：黑色）；
arc4.setType（ArcType.ROUND）；
getChildren（）.addAll（圆、arc1、arc2、arc3、arc4）；
}
}
类时钟窗格扩展窗格{
私人整数小时；
私人整数分钟；
二等兵；
私有字符串梅里迪安；
私人双w=400；
私人双h=400；
Random rand=新的Random（）；
公共时钟面板（）{
setRandomTime（）；
}
公共时钟窗格（整数小时、整数分钟、整数秒）{
这个小时=小时；
this.minute=分钟；
这个秒=秒；
油漆钟（）；
}
公共字符串getHour（）{
如果（本小时<10）{
返回“0”+小时；
}
返回字符串.valueOf（小时）；
}
公共字符串getMinute（）{
如果（本节第12分钟）{
返回“pm”；
}
返回“am”；
}
公共无效集合meridiem（字符串meridiem）{
this.meridiem=meridiem；
}
公共无效设置随机时间（）{
日历=新的公历日历（）；
this.hour=rand.nextInt（12-0+1）+0；
this.minute=rand.nextInt（60-0+1）+0；
this.second=rand.nextInt（60-0+1）+0；
this.meridiem=String.valueOf（rand.nextInt（24-0+1）+0）；
油漆钟（）；
}
受保护的空paintClock（）{
双时钟半径=数学最小值（宽、高）*0.8*0.5；
双中心X=w/2；
双中心Y=h/2；
圆=新圆（中心X、中心Y、时钟半径）；
圆形。设置填充（颜色。白色）；
圆整定行程（颜色为黑色）；
文本t1=新文本（centerX-5，centerY-clockRadius+14，“12”）；
文本t2=新文本（中心X-时钟半径+3，中心Y+5，“9”）；
文本t3=新文本（中心X+时钟半径-10，中心Y+3，“3”）；
文本t4=新文本（centerX-3，centerY+时钟半径-3，“6”）；
双倍长度=时钟半径*0.8；
双秒x=centerX+sLength*Math.sin（秒*（2*Math.PI/60））；
双secondY=centerY-sLength*Math.cos（second*（2*Math.PI/60））；
行sLine=新行（centerX、centerY、secondX、secondY）；
调整行程（颜色：红色）；
双最大长度=时钟半径*0.65；
double xMinute=centerX+mllength*Math.sin（分钟*（2*Math.PI/60））；
双分钟=centerY-mllength*Math.cos（分钟*（2*Math.PI/60））；
直线mLine=新线（中心X、中心Y、X分钟、分钟）；
多线设定行程（颜色为蓝色）；
双波长=时钟半径*0.5；
双小时x=centerX+hLength*Math.sin（（小时%12+分钟/60.0）*（2*Math.PI/1）
GridPane gridPane = new GridPane();
      gridPane.setPadding(new Insets(10));
      gridPane.setHgap(5);
      gridPane.setVgap(5);
      gridPane.add(gridCircles, 0, 0);
      gridPane.add(gridClock, 1, 0);
      gridPane.add(gridHangMan, 2, 0);

      Scene scene = new Scene(gridPane, 1500, 500);
      primoStage.setTitle("Assignment 6 Test");
      primoStage.setScene(scene);
      primoStage.show();

ScalableContentPane scale = new ScalableContentPane();
    GridPane gridPane = new GridPane();
    gridPane.setPadding(new Insets(10));
    gridPane.setHgap(5);
    gridPane.setVgap(5);
    gridPane.add(gridCircles, 0, 0);
    gridPane.add(gridClock, 1, 0);
    gridPane.add(gridHangMan, 2, 0);
    scale.setContent(gridPane);
    Scene scene = new Scene(scale, 1650, 500);
    primoStage.setTitle("Assignment 6 Test");
    primoStage.setScene(scene);
    primoStage.show();

    WebView advertising = new WebView();
    WebEngine webEngine = advertising.getEngine();
    webEngine.load(urlAdvertising);

    advertising.minHeightProperty().bind(view.widthProperty());
    advertising.minWidthProperty().bind(view.widthProperty());

// keep gridPane at original size
gridPane.setMinSize(1500, 500);
gridPane.setMaxSize(1500, 500);

StackPane root = new StackPane(gridPane);
// root.setAlignment(Pos.TOP_LEFT);

// use gridPane size to determine the factor to scale by
NumberBinding maxScale = Bindings.min(root.widthProperty().divide(1500),
                                      root.heightProperty().divide(500));
gridPane.scaleXProperty().bind(maxScale);
gridPane.scaleYProperty().bind(maxScale);

Scene scene = new Scene(root, 1500, 500);