java笔记九

java 代码
  1. /*  
  2. AWT(Abstract Window Toolkit),抽象窗口工具包,SUN公司提供的用于  
  3. 图形界面编程(GUI)的类库。基本的AWT库处理用户界面元素的方法是把这些元素  
  4. 的创建和行为委托给每个目标平台上(Windows、Unix、Macintosh等)的本地  
  5. GUI工具进行处理。例如:如果我们使用AWT在一个Java窗口中放置一个按钮,那  
  6. 么实际上使用的是一个具有本地外观和感觉的按钮。这样,从理论上来说,我们所  
  7. 编写的图形界面程序能运行在任何平台上,做到了图形界面程序的跨平台运行。  
  8.  
  9. 容器里组件的位置和大小是由布局管理器来决定的。容器对布局管理器的特定  
  10. 实例保持一个引用。当容器需要定位一个组件时,它将调用布局管理器来完成。  
  11. 当决定一个组件的大小时,也是如此。  
  12. 在AWT中,给我们提供了五种布局管理器:BorderLayout //缺省的布局管理器  
  13.     FlowLayout  
  14.     GridLayout  
  15.     CardLayout  
  16.     GridBagLayout  
  17.  
  18. 我们可以通过设置空布局管理器,来控制组件的大小和位置。调用setLayout(null)。  
  19. 在设置空布局管理器后,必须对所有的组件调用setLocation(),setSize()  
  20. 或setBounds(),将它们定位在容器中。  
  21.  
  22. 更复杂的布局应该依靠开发工具的图形界面设计拖放功能  
  23.  */  
  24. package lesson8;   
  25. import java.awt.*;   
  26. import java.awt.event.*;   
  27. public class MyProject {   
  28.   
  29.     /**  
  30.      * @param args  
  31.      */  
  32.     public static void main(String[] args) {   
  33.         Frame f = new Frame("mybole");   
  34.         f.setSize(600400);   
  35.         f.setLocation(100100);//设置显示位置   
  36.         f.setBackground(Color.blue);//设置窗口背景颜色   
  37. //      窗口是个容器,可以向其中增加组件   
  38. //      f.setLayout(new BorderLayout(10,10));   
  39. /*      GrideLayout 列数通过指定的行数和布局中的组件总数来确定。因此,  
  40.         例如,如果指定了三行和两列,在布局中添加了九个组件,  
  41.         则它们将显示为三行三列。仅当将行数设置为零时,指定列数才  
  42.         对布局有效。*/    
  43.   
  44. //      f.setLayout(new GridLayout(2,2));//两行三列   
  45. /*流布局用于安排有向流中的组件,这非常类似于段落中的文本行。  
  46. 流的方向取决于容器的 componentOrientation 属性,它可能是以下两个  
  47. 值中的一个:   
  48. ComponentOrientation.LEFT_TO_RIGHT   
  49. ComponentOrientation.RIGHT_TO_LEFT   
  50. 流布局一般用来安排面板中的按钮。它使得按钮呈水平放置,直到同一条线  
  51. 上再也没有适合的按钮。*/  
  52.            
  53. //创建一个新的流布局管理器,具有指定的对齐方式以及指定的水平和垂直间隙。   
  54.         f.setLayout(new FlowLayout(FlowLayout.CENTER,10,10));   
  55.         Button btn1 = new Button("winsun");   
  56.         Button btn2 = new Button("weixin");   
  57.         Button btn3 = new Button("west");   
  58.         Button btn4 = new Button("east");   
  59.         Button btn5 = new Button("center");   
  60.         f.add(btn1,"North");//设置按钮显示位置,大小写敏感   
  61.         f.add(btn2,"South");   
  62.         f.add(btn3,"West");   
  63.         f.add(btn4,"East");   
  64.         f.add(btn5,"Center");   
  65. //      f.addWindowListener(new MyWindowListener());//注册一个事件侦听器   
  66.         f.addWindowListener(new YourWindowListener());   
  67.         f.setVisible(true);//显示窗口 show()方法已过时被setVisible()方法取代   
  68.     }   
  69. }   
  70. /*  
  71. //Source-->Override/Implement   Methods  自动生成接口方法  
  72. class MyWindowListener implements WindowListener {//自定义一个窗口侦听器  
  73.  
  74.     public void windowActivated(WindowEvent e) {  
  75.         // TODO Auto-generated method stub  
  76.           
  77.     }  
  78.  
  79.     public void windowClosed(WindowEvent e) {  
  80.         // TODO Auto-generated method stub  
  81.           
  82.     }  
  83.  
  84.     public void windowClosing(WindowEvent e) {  
  85.         System.exit(0);  
  86.           
  87.     }  
  88.  
  89.     public void windowDeactivated(WindowEvent e) {  
  90.         // TODO Auto-generated method stub  
  91.           
  92.     }  
  93.  
  94.     public void windowDeiconified(WindowEvent e) {  
  95.         // TODO Auto-generated method stub  
  96.           
  97.     }  
  98.  
  99.     public void windowIconified(WindowEvent e) {  
  100.         // TODO Auto-generated method stub  
  101.           
  102.     }  
  103.  
  104.     public void windowOpened(WindowEvent e) {  
  105.         // TODO Auto-generated method stub  
  106.           
  107.     }  
  108. }  */  
  109.   
  110. /*java中已有抽象类WindowAdapter实现了接口WindowListener,不过实现的方法  
  111.  * 都为空实现,以待用户继承该抽象类自己实现想要实现的方法  
  112.  
  113. public abstract class WindowAdapter extends Objectimplements   
  114. WindowListener, WindowStateListener, WindowFocusListener  
  115. 接收窗口事件的抽象适配器类。此类中的方法为空。此类存在的目的是方便创建侦  
  116. 听器对象。   
  117.  
  118. 扩展此类可创建 WindowEvent 侦听器并为所需事件重写该方法。(如果要实现  
  119.  WindowListener 接口,则您必须定义该接口内的所有方法。此抽象类将所有方  
  120.  法都定义为 null,所以只需针对关心的事件定义方法。)   
  121.  
  122. 使用扩展的类可以创建侦听器对象,然后使用窗口的 addWindowListener   
  123. 方法向该窗口注册侦听器。当通过打开、关闭、激活或停用、图标化或取消图标化  
  124. 而改变了窗口状态时,将调用该侦听器对象中的相关方法,并将 WindowEvent   
  125. 传递给该方法。   
  126.  
  127.  */  
  128.   
  129. class YourWindowListener extends WindowAdapter {   
  130.     public void windowClosing(WindowEvent e) {   
  131.         System.exit(0);        
  132.     }   
  133.        
  134. }  
java 代码
  1. package lesson8;   
  2. import java.awt.*;   
  3. import java.awt.event.*;   
  4. import java.io.*;   
  5. public class HisFrame {   
  6.     public static void main(String[] args) {   
  7.         final Frame f = new Frame("http://www.windycool.com");   
  8.         f.setSize(600400);   
  9.         f.setLocation(100100);   
  10. //      TextField 对象是允许编辑单行文本的文本组件   
  11. //      TextField tf = new TextField(20);//建立一个20列的文本域.   
  12. //      f.add(tf,"North");//文本域添加到North处   
  13.         final TextArea ta = new TextArea();   
  14.         f.add(ta);//默认放到Center处   
  15.         f.addWindowListener(new WindowAdapter() {//增加一个窗口侦听器   
  16.             public void windowClosing(WindowEvent e) {   
  17.                 System.exit(0);   
  18.             }   
  19.         });   
  20.         MenuBar mb = new MenuBar();   
  21.         Menu m1 = new Menu("File");   
  22.         Menu m2 = new Menu("Edit");   
  23.         MenuItem mi1= new MenuItem("new");   
  24.         MenuItem mi2= new MenuItem("open");   
  25.         mi2.addActionListener(new ActionListener() {   
  26.             public void actionPerformed(ActionEvent a) {   
  27. /*  
  28. public class FileDialogextends DialogFileDialog 类显示一个对  
  29. 话框窗口,用户可以从中选择文件。   
  30. 由于它是一个模式对话框,当应用程序调用其 show 方法来显示对话框时,  
  31. 它将阻塞其余应用程序,直到用户选择一个文件。   
  32.  */  
  33.                 FileDialog fd = new FileDialog(f,"打开文件",FileDialog.LOAD);   
  34.                 fd.setVisible(true);   
  35.                 String str = fd.getDirectory()+fd.getFile();   
  36.                 if(str!=null) {   
  37.                     try {   
  38.                         FileInputStream fis = new FileInputStream(str);   
  39.                         byte[] buf = new byte[1000*1024];   
  40.                         int len = fis.read(buf);//读到buf里面   
  41.                         if(len>=0)   
  42.                         ta.append(new String(buf,0,len));   
  43.                         fis.close();               
  44.                     }   
  45.                     catch(Exception e) {   
  46.                         e.printStackTrace();   
  47.                     }   
  48.                 }   
  49.             }   
  50.         });   
  51.         MenuItem mi3= new MenuItem("save");   
  52.         MenuItem mi4= new MenuItem("exit");   
  53.         mi4.addActionListener(new ActionListener() {   
  54.             public void actionPerformed(ActionEvent a) {   
  55.                 System.exit(0);   
  56.             }   
  57.         });//增加一个事件侦听器 , 相应事件    退出   
  58.         MenuItem mi5= new MenuItem("copy");   
  59.         MenuItem mi6= new MenuItem("paste");   
  60. //      菜单项添加到下拉菜单   
  61.         m1.add(mi1);   
  62.         m1.add(mi2);   
  63.         m1.add(mi3);   
  64.         m1.add(mi4);   
  65.         m2.add(mi5);   
  66.         m2.add(mi6);   
  67.         mb.add(m1);//菜单增加到菜单栏   
  68.         mb.add(m2);   
  69.            
  70.         f.setMenuBar(mb);//将菜单栏放置到框架窗口   
  71.         f.setVisible(true);   
  72.   
  73.     }   
  74.   
  75. }   

你可能感兴趣的:(java,设计模式,编程,unix,F#)