使用非JFrame扩展的Java_Java_Object_Jframe

使用非JFrame扩展的Java

java object

使用非JFrame扩展的Java,java,object,jframe,Java,Object,Jframe,我很难理解如何在不让程序从JFrame扩展的情况下编写程序我尝试删除extends JFrame子句，并将其添加到两个方法中，替换calculator whichusainterface frame=new calculator whichusainterface（）带有JFrame=newjframe（）的节和其他一些东西，但都不起作用我应该如何在程序中使用JFrame=newjframe（），而不是使用扩展JFrame import java.awt.BorderLayout; impo

我很难理解如何在不让程序从

JFrame

扩展的情况下编写程序

我尝试删除

extends JFrame

子句，并将其添加到两个方法中，替换

calculator whichusainterface frame=new calculator whichusainterface（）带有JFrame=newjframe（）的节
和其他一些东西，但都不起作用
我应该如何在程序中使用JFrame=newjframe（）
，而不是使用扩展JFrame

import java.awt.BorderLayout;
import java.awt.Font;
import java.awt.GridLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

class CalculatorWhichUsesAInterface extends JFrame{

     JFrame frame = new JFrame();

     public CalculatorWhichUsesAInterface(){
         JPanel jPanelOne = new JPanel();
         jPanelOne.setLayout(new GridLayout(1, 1);

         jPanelOne.add(new JButton("x"));

         JPanel jPanelTwo = new JPanel(new BorderLayout());
         JTextField field = new JTextField();
         field.setText("2141987.01235");
         jPanelTwo.add(field, BorderLayout.NORTH);
         jPanelTwo.add(jPanelOne, BorderLayout.CENTER);
         add(jPanelTwo, BorderLayout.CENTER);
    }

    public static void main(String[] args){
        CalculatorWhichUsesAInterface frame = new CalculatorWhichUsesAInterface();
        frame.setTitle("Calculator");
        frame.setSize(500, 200);
        frame.setLocationRelativeTo(null);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

看起来就像您在main中为JFrame对象所做的一切（setTitle、setSize等），这些对象“来自”继承（扩展JFrame）。所以实际上你什么都没做：
JFrame frame = new JFrame();

如果不想使用继承，应该调用JFrame对象的方法，而不是调用计算器whichuseSainterface（）。因此，构造函数应该如下所示（主要是创建对象）：
如您所见，我几乎将所有内容都从main复制到了构造函数，但它是在不同的对象上调用的（实际上是JFrame，而不是计算器whichuseanterface）。但通过继承执行JFrame是一种常见的方法。
看起来就像您在main中对JFrame对象所做的一切（setTitle、setSize等），它“来自”继承（扩展JFrame）。所以实际上你什么都没做：
JFrame frame = new JFrame();

如果不想使用继承，应该调用JFrame对象的方法，而不是调用计算器whichuseSainterface（）。因此，构造函数应该如下所示（主要是创建对象）：
如您所见，我几乎将所有内容都从main复制到了构造函数，但它是在不同的对象上调用的（实际上是JFrame，而不是计算器whichuseanterface）。但通过继承执行JFrame是常见的方法。
要不扩展JFrame，您的想法是正确的，但在上面的代码中，您需要首先删除Extended JFrame，但声明框架的方式是正确的：
JFrame frame = new JFrame("Title");

从那以后，你只需要引用它的对象，例如：
frame.add(jPanelTwo,BorderLayout.CENTER)

要不扩展JFrame，您的想法是正确的，但是在上面的代码中，您需要首先删除extends JFrame，但声明框架的方式是正确的：
JFrame frame = new JFrame("Title");

从那以后，你只需要引用它的对象，例如：
frame.add(jPanelTwo,BorderLayout.CENTER)

这实际上是相对容易的（抱歉，但事实确实如此）
首先从JPanel
扩展您的类，这为您提供了一个基本容器来构建接口
移除JFrame=newjframe（）
由于您没有真正使用它，在main
方法中，创建JFrame
的新实例，并将您的组件添加到其中
class CalculatorWhichUsesAInterface extends JPanel {
     public CalculatorWhichUsesAInterface(){
        JPanel jPanelOne = new JPanel();
         jPanelOne.setLayout(new GridLayout(1, 1);


         jPanelOne.add(new JButton("x"));

         JPanel jPanelTwo = new JPanel(new BorderLayout());
         JTextField field = new JTextField();
         field.setText("2141987.01235");
         jPanelTwo.add(field, BorderLayout.NORTH);
         jPanelTwo.add(jPanelOne, BorderLayout.CENTER);
         add(jPanelTwo, BorderLayout.CENTER);
     }

    public static void main(String[] args){
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                CalculatorWhichUsesAInterface calc = new CalculatorWhichUsesAInterface();
                JFrame frame = new JFrame()
                frame.setTitle("Calculator");
                frame.add(calc);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            }
        });
    }
}

这个概念为您提供了一个灵活且可重用的组件。这意味着您可以决定如何以及在何处显示零部件。在它自己的框架中显示（如上示例所示）或添加到另一个容器（例如另一个JPanel
甚至小程序）
您可能还想看看
示例二-不扩展任何内容
类计算器，它是一个保持面{
    public static void main(String[] args){
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                JPanel jPanelOne = new JPanel();
                jPanelOne.setLayout(new GridLayout(1, 1);


                jPanelOne.add(new JButton("x"));

                JPanel jPanelTwo = new JPanel(new BorderLayout());
                JTextField field = new JTextField();
                field.setText("2141987.01235");
                jPanelTwo.add(field, BorderLayout.NORTH);
                jPanelTwo.add(jPanelOne, BorderLayout.CENTER);

                JFrame frame = new JFrame()
                frame.setTitle("Calculator");
                frame.add(jPanelTwo);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            }
        });
    }
}

用“生成器”示例更新
这是构建器模式的一个（非常基本的）示例，基本上，您有一个单独的类，它只构建UI并返回一个JPanel
（在本例中）
更复杂的构建器将允许您添加其他属性来调整结果
class CalculatorWhichUsesAInterface {

    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {

                JFrame frame = new JFrame();
                frame.setTitle("Calculator");
                frame.add(CalculatorBuilder.build());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            }
        });
    }

    public static class CalculatorBuilder {

        public static JPanel build() {
            JPanel jPanelOne = new JPanel();
            jPanelOne.setLayout(new GridLayout(1, 1));

            jPanelOne.add(new JButton("x"));

            JPanel jPanelTwo = new JPanel(new BorderLayout());
            JTextField field = new JTextField();
            field.setText("2141987.01235");
            jPanelTwo.add(field, BorderLayout.NORTH);
            jPanelTwo.add(jPanelOne, BorderLayout.CENTER);
            return jPanelTwo;
        }

    }
}

这实际上是相对容易的（抱歉，但事实确实如此）
首先从JPanel
扩展您的类，这为您提供了一个基本容器来构建接口
删除JFrame=new JFrame（）；
因为您没有真正使用它，在main
方法中，创建JFrame
的新实例，并将您的组件添加到其中
class CalculatorWhichUsesAInterface extends JPanel {
     public CalculatorWhichUsesAInterface(){
        JPanel jPanelOne = new JPanel();
         jPanelOne.setLayout(new GridLayout(1, 1);


         jPanelOne.add(new JButton("x"));

         JPanel jPanelTwo = new JPanel(new BorderLayout());
         JTextField field = new JTextField();
         field.setText("2141987.01235");
         jPanelTwo.add(field, BorderLayout.NORTH);
         jPanelTwo.add(jPanelOne, BorderLayout.CENTER);
         add(jPanelTwo, BorderLayout.CENTER);
     }

    public static void main(String[] args){
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                CalculatorWhichUsesAInterface calc = new CalculatorWhichUsesAInterface();
                JFrame frame = new JFrame()
                frame.setTitle("Calculator");
                frame.add(calc);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            }
        });
    }
}

此概念为您提供了一个灵活且可重复使用的组件。这意味着您可以决定如何以及在何处显示该组件。在它自己的框架中显示（如上示例所示）或添加到另一个容器中（例如另一个JPanel
甚至小程序）
您可能还想看看
示例二-不扩展任何内容
类计算器，它是一个保持面{
    public static void main(String[] args){
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                JPanel jPanelOne = new JPanel();
                jPanelOne.setLayout(new GridLayout(1, 1);


                jPanelOne.add(new JButton("x"));

                JPanel jPanelTwo = new JPanel(new BorderLayout());
                JTextField field = new JTextField();
                field.setText("2141987.01235");
                jPanelTwo.add(field, BorderLayout.NORTH);
                jPanelTwo.add(jPanelOne, BorderLayout.CENTER);

                JFrame frame = new JFrame()
                frame.setTitle("Calculator");
                frame.add(jPanelTwo);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            }
        });
    }
}

用“生成器”示例更新
这是构建器模式的一个（非常基本的）示例，基本上，您有一个单独的类，它只构建UI并返回一个JPanel
（在本例中）
更复杂的构建器将允许您添加其他属性来调整结果
class CalculatorWhichUsesAInterface {

    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {

                JFrame frame = new JFrame();
                frame.setTitle("Calculator");
                frame.add(CalculatorBuilder.build());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            }
        });
    }

    public static class CalculatorBuilder {

        public static JPanel build() {
            JPanel jPanelOne = new JPanel();
            jPanelOne.setLayout(new GridLayout(1, 1));

            jPanelOne.add(new JButton("x"));

            JPanel jPanelTwo = new JPanel(new BorderLayout());
            JTextField field = new JTextField();
            field.setText("2141987.01235");
            jPanelTwo.add(field, BorderLayout.NORTH);
            jPanelTwo.add(jPanelOne, BorderLayout.CENTER);
            return jPanelTwo;
        }

    }
}

BorderLayout.CENTER
是默认位置，如果没有指定（只是说），并且（我个人）我对构造函数以这种方式创建框架有一个问题，它会降低类的可重用性…并且您仍然在从JFrame
；）进行扩展）当然，我复制时没有删除“extends JFrame”部分。我也确实认为这很奇怪，我通常不建议只扩展JFrameExtending fromJFrame
。你通常不会向它添加任何功能或特性，如果你直接将UI构建到它，它会将你锁定为单一用途，使类/项目不可重用。这对我来说效果更好，但我是我在main方法中得到一个错误，没有使用frame。因为它没有被使用。你想创建JFrame并等待用户事件。有些人会在main方法中写入frame.setVisible（true），但我发现它很奇怪BorderLayout。如果没有指定（只是说）和（个人），则默认位置为CENTER
我对构造器以这种方式创建框架有一个问题，它降低了类的可重用性…而且你仍然在从JFrame
；）扩展）当然，我复制了，没有删除“extends JFrame”部分。我也认为这很奇怪，我通常只是扩展