3、组件和容器

3、组件和容器

1. Frame

   1. 万物皆对象，窗口也是一个对象，这里Frame也是一个对象，我们可以看到Frame是可以new出来的，它是属于java.awt包下的

   2. 学习中想要知道这个类怎么用可以采用查JDK帮助文档，这里推荐查看源码，在IDEA中按住Ctrl键，点击类名即可查看源码

   3. 通过Structure选项卡可以查看类的结构打开方式如图，也可以使用快捷键alt+7

      

      public class Frame extends Window implements MenuContainer
      1

      从类的定义可以看出，Frame类继承了Window类，实现了MemuContainer接口

      从类中我们可以看出Frame类构造器共有4个，我们可以看出无参构造方法

       public Frame() throws HeadlessException {
              this("");
          }
      1
      2
      3

      无参构造方法中this(“”)调用了类中的有参构造方法Fram(String)，有参构造方法如下

        public Frame(String title) throws HeadlessException {
              init(title, null);
          }
      1
      2
      3

      有参构造方法又调用了类中的init方法

          private void init(String title, GraphicsConfiguration gc) {
              this.title = title;
              SunToolkit.checkAndSetPolicy(this);
          }
      1
      2
      3
      4

2. 第一个Frame窗口

   package com.dryant.lesson1;                                                               
                                                                                             
   import java.awt.*;                                                                        
                                                                                             
   //GUI的第一个界面                                                                               
   public class TestFrame {                                                                  
       public static void main(String[] args) {                                              
           //万物接对象，窗口也是一个对象，这个对象就是Frame对象                                                    
           //学习中想要知道这个类怎么用可以采用查JDK帮助文档，这里推荐查看源码                                              
           Frame frame = new Frame("第一个Java图形界面窗口");//使用快捷键Ctrl+Alt+V快速插入对象                  
           //当前的这个代码在Java中是看不到的，窗口是在内存中的，想要显现出来就必须设置可见性                                      
                                                                                             
                                                                                             
           //设置可见性，通过  对象.方法 可以看到该对象可以调用那些方法                                                 
           frame.setVisible(true);                                                           
                                                                                             
           //设置窗口大小                                                                          
           frame.setSize(400,400);                                                           
                                                                                             
           //设置窗口背景颜色                                                                        
           frame.setBackground(new Color(179, 152, 152));                                    
                                                                                             
           //设置弹出初始位置                                                                        
           frame.setLocation(200,200);                                                       
                                                                                             
           //设置窗口大小不能拉伸，大小固定，一些游戏需要                                                          
           frame.setResizable(false);                                                        
       }                                                                                     
   }                                                                                         
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29

   运行结果如下图

   

3. 多个弹窗

   当一个弹窗的时候可以用上面的方法生成，如果多个弹窗的话每个都要写这样的代码显然太麻烦，这时我们就可以用到封装的办法

   封装的方法就是把上面方法体抽出来作为一个方法，参数是frame就可以了

   展示多个窗口，对于Java来说就是new多个对象即可，代码如下

   package com.dryant.lesson1;
   
   import java.awt.*;
   
   public class TestFrame2 {
       public static void main(String[] args) {
           //展示多个窗口，对于Java来说就是new多个对象即可
           //此时就要考虑怎样做一个类与Frame有关系，可以使用继承的方法
           //在建好类之后就可以new出对象即可
           MyFrame myFrame1 = new MyFrame(100, 100, 200, 200, Color.blue);
           MyFrame myFrame2 = new MyFrame(300, 100, 200, 200, Color.yellow);
           MyFrame myFrame3 = new MyFrame(100, 300, 200, 200, Color.red);
           MyFrame myFrame4 = new MyFrame(300, 300, 200, 200, Color.green);
       }
   }
   class MyFrame extends Frame {
       //因为要展示多个窗口就需要计数器
       static int id = 0;
       //1、写构造器，因为需要实例化写一个与类同名、无返回值的方法就是构造器
       //2、考虑构造器需要的变量，宽、高、初始位置、颜色
       public MyFrame(int x,int y,int w,int h,Color color){
           super("Myframe+"+(++id));//调用父类的构造方法
           setVisible(true);//设置可见性，这个代码与super.setVisible效果一样
           setBounds(x,y,w,h);//设置初始位置及窗口大小
           setBackground(color);//设置背景颜色
       }
   
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28

   运行结果如图所示

   

   这里我们同样学习了类的封装