Java 交点以什么比例分割线段？

我所做的：

• 我画了X轴和Y轴以及我的线段
• 我写了一个代码，如果线段相交，它将返回true
• 我写了一个代码，返回交点的坐标

但是如何计算交点分割线段的比率呢

非常感谢你的帮助^^

我的代码是：

package com.staaankey;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class Cartesian {
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                CartesianFrame frame = new CartesianFrame();
                frame.showUI();
            }
        });
    }

}

class CartesianFrame extends JFrame {
    CartesianPanel panel;

    public CartesianFrame() {
        panel = new CartesianPanel();
        add(panel);
    }

    public void showUI() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setTitle("Main");
        setSize(700, 700);
        setVisible(true);
    }
}

class CartesianPanel extends JPanel {
    // x-axis coord constants
    public static final int X_AXIS_FIRST_X_COORD = 50;
    public static final int X_AXIS_SECOND_X_COORD = 600;
    public static final int X_AXIS_Y_COORD = 600;

    // y-axis coord constants
    public static final int Y_AXIS_FIRST_Y_COORD = 50;
    public static final int Y_AXIS_SECOND_Y_COORD = 600;
    public static final int Y_AXIS_X_COORD = 50;

    //arrows of axis are represented with "hipotenuse" of
    //triangle
    // now we are define length of cathetas of that triangle
    public static final int FIRST_LENGHT = 10;
    public static final int SECOND_LENGHT = 5;

    // size of start coordinate lenght
    public static final int ORIGIN_COORDINATE_LENGHT = 6;

    // distance of coordinate strings from axis
    public static final int AXIS_STRING_DISTANCE = 20;


    public void paintComponent(Graphics g) {

        super.paintComponent(g);

        Graphics2D g2 = (Graphics2D) g;

        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);

        // x-axis
        g2.drawLine(X_AXIS_FIRST_X_COORD, X_AXIS_Y_COORD,
                X_AXIS_SECOND_X_COORD, X_AXIS_Y_COORD);
        // y-axis
        g2.drawLine(Y_AXIS_X_COORD, Y_AXIS_FIRST_Y_COORD,
                Y_AXIS_X_COORD, Y_AXIS_SECOND_Y_COORD);

        // x-axis arrow
        g2.drawLine(X_AXIS_SECOND_X_COORD - FIRST_LENGHT,
                X_AXIS_Y_COORD - SECOND_LENGHT,
                X_AXIS_SECOND_X_COORD, X_AXIS_Y_COORD);
        g2.drawLine(X_AXIS_SECOND_X_COORD - FIRST_LENGHT,
                X_AXIS_Y_COORD + SECOND_LENGHT,
                X_AXIS_SECOND_X_COORD, X_AXIS_Y_COORD);

        // y-axis arrow
        g2.drawLine(Y_AXIS_X_COORD - SECOND_LENGHT,
                Y_AXIS_FIRST_Y_COORD + FIRST_LENGHT,
                Y_AXIS_X_COORD, Y_AXIS_FIRST_Y_COORD);
        g2.drawLine(Y_AXIS_X_COORD + SECOND_LENGHT,
                Y_AXIS_FIRST_Y_COORD + FIRST_LENGHT,
                Y_AXIS_X_COORD, Y_AXIS_FIRST_Y_COORD);

        // draw origin Point
        g2.fillOval(
                X_AXIS_FIRST_X_COORD - (ORIGIN_COORDINATE_LENGHT / 2),
                Y_AXIS_SECOND_Y_COORD - (ORIGIN_COORDINATE_LENGHT / 2),
                ORIGIN_COORDINATE_LENGHT, ORIGIN_COORDINATE_LENGHT);

        // draw text "X" and draw text "Y"
        g2.drawString("X", X_AXIS_SECOND_X_COORD - AXIS_STRING_DISTANCE / 2,
                X_AXIS_Y_COORD + AXIS_STRING_DISTANCE);
        g2.drawString("Y", Y_AXIS_X_COORD - AXIS_STRING_DISTANCE,
                Y_AXIS_FIRST_Y_COORD + AXIS_STRING_DISTANCE / 2);
        g2.drawString("(0, 0)", X_AXIS_FIRST_X_COORD - AXIS_STRING_DISTANCE,
                Y_AXIS_SECOND_Y_COORD + AXIS_STRING_DISTANCE);

        // numerate axis
        int xCoordNumbers = 10;
        int yCoordNumbers = 10;
        int xLength = (X_AXIS_SECOND_X_COORD - X_AXIS_FIRST_X_COORD)
                / xCoordNumbers;
        int yLength = (Y_AXIS_SECOND_Y_COORD - Y_AXIS_FIRST_Y_COORD)
                / yCoordNumbers;

        // draw x-axis numbers
        for(int i = 1; i < xCoordNumbers; i++) {
            g2.drawLine(X_AXIS_FIRST_X_COORD + (i * xLength),
                    X_AXIS_Y_COORD - SECOND_LENGHT,
                    X_AXIS_FIRST_X_COORD + (i * xLength),
                    X_AXIS_Y_COORD + SECOND_LENGHT);
            g2.drawString(Integer.toString(i),
                    X_AXIS_FIRST_X_COORD + (i * xLength) - 3,
                    X_AXIS_Y_COORD + AXIS_STRING_DISTANCE);
        }

        //draw y-axis numbers
        for(int i = 1; i < yCoordNumbers; i++) {
            g2.drawLine(Y_AXIS_X_COORD - SECOND_LENGHT,
                    Y_AXIS_SECOND_Y_COORD - (i * yLength),
                    Y_AXIS_X_COORD + SECOND_LENGHT,
                    Y_AXIS_SECOND_Y_COORD - (i * yLength));
            g2.drawString(Integer.toString(i),
                    Y_AXIS_X_COORD - AXIS_STRING_DISTANCE,
                    Y_AXIS_SECOND_Y_COORD - (i * yLength));
        }

        //draw first section
        int fX1 = 125;
        int fY1 = 75;
        int fX2 = 135;
        int fY2 = 75;
        g2.drawLine(fX1, fY1, fX2, fY2);

        //draw second section
        int sX1 = 130;
        int sY1 = 50;
        int sX2 = 140;
        int sY2 = 150;

        g2.drawLine(sX1, sY1, sX2, sY2);

        int v1 = (sX2 - sX1) * (fY1 - sY1) - (sY2 - sY1) * (fX1 - sX1);

        int v2 = (sX2 - sX1) * (fY2 - sX1) - (sY2 - sY1) * (fX2 - sX1);

        int v3 = (fX2 - fX1) *(sY1 - fY1) - (fY2 - fY1) * (sX1 - fX1);

        int v4 = (fX2 - fX1) * (sY2 - fY1) - (fY2 - fY1) * (sX2 - fX1);

        Boolean result;

        if((v1 * v2 < 0) && (v3 * v4 < 0)){
            result = true;
        }
        else{
            result = false;
        }
        System.out.println(result);

        int detL1 = det(fX1, fY1, fX2, fY2);
        int detL2 = det(sX1, sY1, sX2, sY2);
        int x1mx2 = fX1 - fX2;
        int x3mx4 = sX1 - sX2;
        int y1my2 = fY1 - fY2;
        int y3my4 = sY1 - sY2;

        int denom = det(x1mx2, y1my2, x3mx4, y3my4);
        if(denom == 0){
            return;
        }
        int xnom = det(detL1 ,x1mx2, detL2, x3mx4);
        int ynom = det(detL1, y1my2, detL2, y3my4);
        int ixOut = xnom / denom;
        int iYOut = ynom / denom;
        System.out.println("ixOut: ");
        System.out.println("iYOut: ");
        System.out.println(ixOut);;
        System.out.println(iYOut);
    }

    public int det(int x1, int y1, int x2, int y2){
        return x1 * y2 - y1 * x2;
    }

}

package com.staaankey；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.RenderingHints；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.SwingUtilities；
公共类笛卡尔{
公共静态void main（字符串[]args）{
SwingUtilities.invokeLater（新的Runnable（）{
@凌驾
公开募捐{
笛卡尔框架=新笛卡尔框架（）；
frame.showUI（）；
}
});
}
}
类CartesianFrame扩展了JFrame{
CartesianPanel小组；
公共卡特尔框架（）{
面板=新的CartesianPanel（）；
添加（面板）；
}
公开无效showUI（）{
setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
设置标题（“主要”）；
设置大小（700700）；
setVisible（真）；
}
}
类CartesianPanel扩展了JPanel{
//x轴坐标常数
公共静态最终整数X_轴X_第一坐标=50；
公共静态最终整数X_轴X_秒X_坐标=600；
公共静态最终整数X_轴Y_坐标=600；
//y轴坐标常数
公共静态最终int Y_轴第一Y_坐标=50；
公共静态最终整数Y_轴Y_秒Y_坐标=600；
公共静态最终int Y_轴X_坐标=50；
//轴的箭头用“hipotenuse”表示
//三角
//现在我们来定义三角形的导管长度
公共静态最终整数首长=10；
公共静态最终整数秒长度=5；
//起始坐标长度的大小
公共静态最终整数原点坐标长度=6；
//坐标串与轴的距离
公共静态最终整数轴\字符串\距离=20；
公共组件（图形g）{
超级组件（g）；
图形2d g2=（图形2d）g；
g2.setRenderingHint（RenderingHints.KEY_抗锯齿，
RenderingHints.VALUE_ANTIALIAS_ON）；
//x轴
g2.绘制线（X轴第一坐标，X轴Y坐标，
X_轴（第二个X_坐标，X_轴（Y坐标）；
//y轴
g2.绘制线（Y_轴X_坐标、Y_轴Y_第一坐标、，
Y轴X坐标，Y轴第二坐标）；
//x轴箭头
g2.抽绳（X轴X坐标-第一长度，
X轴Y坐标-第二个长度，
X_轴（第二个X_坐标，X_轴（Y坐标）；
g2.抽绳（X轴X坐标-第一长度，
X轴Y坐标+第二长度，
X_轴（第二个X_坐标，X_轴（Y坐标）；
//y轴箭头
g2.抽绳（Y轴X坐标-第二个长度，
Y_轴Y_首字母Y_坐标+首字母长度，
Y轴X坐标，Y轴第一坐标）；
g2.拉线（Y轴X坐标+第二长度，
Y_轴Y_首字母Y_坐标+首字母长度，
Y轴X坐标，Y轴第一坐标）；
//画原点
g2.椭圆形(
X轴第一坐标-（原点坐标长度/2），
Y轴第二坐标-（原点坐标长度/2），
原点坐标长度，原点坐标长度）；
//绘制文本“X”和绘制文本“Y”
g2.抽绳（“X”，X轴第二坐标-轴距离/2，
X轴Y坐标+轴字符串距离）；
g2.拉线（“Y”，Y轴X轴坐标-轴X轴距离，
Y轴（第一个Y轴坐标+轴（字符串）距离/2）；
g2.拉线（“（0，0）”，X_轴X_坐标-轴X_线距离，
Y轴（第二坐标+轴（字符串）距离）；
//计算轴
int xCoordNumber=10；
int yCoordNumbers=10；
int X长度=（X_轴第二个X_坐标-X_轴第一个X_坐标）
/xCoordNumbers；
长度=（Y轴第二坐标-Y轴第一坐标）
/库德数；
//绘制x轴编号
对于（int i=1；i// some arbitrary line with slope = 5 and y-intercept = 23
UnaryOperator<Integer> y = x->5*x + 23; 
int endx = 2;
int endy = y.apply(endx);

int otherendx = 10;
int otherendy = y.apply(otherendx);

int intx = 5;
int inty = y.apply(intx);

double seg1Length = Math.hypot(endx-intx, endy - inty);
double seg2Length = Math.hypot(otherendx-intx, otherendy - inty);

double ratio = Math.min(seg1Length,seg2Length)/Math.max(seg1Length,seg2Length);

Ratio = 0.6