Java图形用户界面：高级组件综合例子

运行结果截图如下：

创新互联公司主要从事成都网站建设、网站制作、网页设计、企业做网站、公司建网站等业务。立足成都服务尼玛,十载网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18982081108

 
 
 
 
    
  
  
  
  
  1. /** 
    2. 
  
  
  
  
  2. 作者：wwj 
    3. 
  
  
  
  
  3. 日期：2012/4/18 
    4. 
  
  
  
  
  4. 功能：利用图像用户界面高级组件实现简单记事本 
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. 说明： 
    7. 
  
  
  
  
  7. （1）创建一个名为“简单记事本”窗口，在窗口中添加一个带有滚动条的文本区。 
    8. 
  
  
  
  
  8. （2）在窗口中添加一个具有以下菜单的菜单栏： 
    9. 
  
  
  
  
  9.    1.“文件”菜单，包含“打开”、“保存”、“退出”的菜单项，菜单间加分隔线， 
    10. 
  
  
  
  
  10.       添加事件处理方法，使菜单具有打开、保存文件及退出的功能。 
    11. 
  
  
  
  
  11.    2.“编辑”菜单，包含“复制”、“剪切”、“粘贴”的菜单项，添加事件处理方法， 
    12. 
  
  
  
  
  12.       使菜单具有“复制”、“剪切”、“粘贴”的功能。 
    13. 
  
  
  
  
  13.    3.“格式”菜单，包含“格式设置”的二级子菜单；而二级“格式设置”子菜单， 
    14. 
  
  
  
  
  14.       包含 “自动换行”、“取消自动换行”、“断行不断字”、“取消断行不断字”的菜单项，添加事件处理方法， 
    15. 
  
  
  
  
  15.       设置文本框自动换行和断行不断字的格式。 
    16. 
  
  
  
  
  16.     （提示：JTextArea类中，使用setLineWrap(true)方法设置自动换行，使用setWrapStyleword(true)方法设置断行不断字，参考书本例8.7） 
    17. 
  
  
  
  
  17. （3）在窗口中添加工具栏，包含“打开”、“保存”、“复制”、“剪切”、“粘贴”图片按钮的工具栏， 
    18. 
  
  
  
  
  18.      添加事件处理方法，单击相应的按钮能实现相应的功能。 
    19. 
  
  
  
  
  19. （4）在窗口中添加弹出式菜单，包含“打开”、“保存”、“复制”、“剪切”、“粘贴”的菜单项， 
    20. 
  
  
  
  
  20.      直接添加分隔线，添并加事件处理方法，选择相应的菜单项能实现相应的功能。 
    21. 
  
  
  
  
  21. **/
    22. 
  
  
  
  
  22. 
  
  
  
  
  23. import java.awt.*; 
    24. 
  
  
  
  
  24. import javax.swing.*; 
    25. 
  
  
  
  
  25. import java.awt.event.*; 
    26. 
  
  
  
  
  26. import java.io.*; 
    27. 
  
  
  
  
  27. public class Nodepad extends JFrame 
    28. 
  
  
  
  
  28. { 
    29. 
  
  
  
  
  29.     private JTextArea editor; 
    30. 
  
  
  
  
  30.     private Container c; 
    31. 
  
  
  
  
  31.     private Font f=new Font("sanserif",Font.PLAIN,12); 
    32. 
  
  
  
  
  32.     //菜单栏成员属性声明 
    33. 
  
  
  
  
  33.     private JMenuBar mb;        //菜单棒 
    34. 
  
  
  
  
  34.     private JMenu fileMenu;     //文件菜单 
    35. 
  
  
  
  
  35.     private JMenu editMenu;     //编辑菜单 
    36. 
  
  
  
  
  36.     private JMenu formatMenu;   //格式菜单 
    37. 
  
  
  
  
  37.     private JMenuItem fileMenuOpen,fileMenuSave,fileMenuExit;   //文件菜单的菜单项 
    38. 
  
  
  
  
  38.     private JMenuItem editMenuCopy,editMenuCut,editMenuPaste;   //编辑菜单的菜单项 
    39. 
  
  
  
  
  39.     private JMenu formatSet;//格式菜单第一级菜单 
    40. 
  
  
  
  
  40.     private JMenuItem lineWrap,cancleLineWrap,wrapStyleWord,cancleWrapStyleWord;//格式菜单的第二级菜单 
    41. 
  
  
  
  
  41. 
  
  
  
  
  42.     //工具栏成员属性声明 
    43. 
  
  
  
  
  43.     private JToolBar toolBar;   //工具棒 
    44. 
  
  
  
  
  44.     private JButton b1,b2,b3,b4,b5; //声明5个按钮，分别为：“打开”、“保存”、“复制”、“剪切”、“粘贴” 
    45. 
  
  
  
  
  45.      
    46. 
  
  
  
  
  46.     //弹出式菜单属性声明 
    47. 
  
  
  
  
  47.     private JPopupMenu pm; 
    48. 
  
  
  
  
  48.     private JMenuItem item1,item2,item3,item4,item5; 
    49. 
  
  
  
  
  49. 
  
  
  
  
  50. 
  
  
  
  
  51. 
  
  
  
  
  52.     public Nodepad() 
    53. 
  
  
  
  
  53.     { 
    54. 
  
  
  
  
  54.         super("简单记事本"); 
    55. 
  
  
  
  
  55.         setSize(400,300); 
    56. 
  
  
  
  
  56.      
    57. 
  
  
  
  
  57.         try{ 
    58. 
  
  
  
  
  58.             UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); 
    59. 
  
  
  
  
  59.         } catch (Exception e){ System.err.println("不能被设置外观的原因:"+e);} 
    60. 
  
  
  
  
  60.          
    61. 
  
  
  
  
  61. 
  
  
  
  
  62. 
  
  
  
  
  63.         c=getContentPane();         //创建一个内容面板 
    64. 
  
  
  
  
  64.         editor = new JTextArea();   //创建一个文本区 
    65. 
  
  
  
  
  65.         c.add(new JScrollPane(editor)); //设置滚动条，并添加到内容面板 
    66. 
  
  
  
  
  66. 
  
  
  
  
  67.         //菜单栏的实现 
    68. 
  
  
  
  
  68.         //文件菜单的实现 
    69. 
  
  
  
  
  69.         mb = new JMenuBar();    //创建菜单棒 
    70. 
  
  
  
  
  70.         fileMenu = new JMenu("文件(F)");//创建菜单 
    71. 
  
  
  
  
  71.         fileMenuOpen = new JMenuItem("打开(O)...Ctrl+O"); 
    72. 
  
  
  
  
  72.         fileMenuSave = new JMenuItem("保存(S)...Ctrl+S"); 
    73. 
  
  
  
  
  73.         fileMenuExit = new JMenuItem("退出"); 
    74. 
  
  
  
  
  74.         JMHandler JM=new JMHandler();       //创建监听器 
    75. 
  
  
  
  
  75.         fileMenuOpen.addActionListener(JM); //注册监听器 
    76. 
  
  
  
  
  76.         fileMenuSave.addActionListener(JM); 
    77. 
  
  
  
  
  77.         fileMenuExit.addActionListener(JM); 
    78. 
  
  
  
  
  78.         fileMenu.add(fileMenuOpen); 
    79. 
  
  
  
  
  79.         fileMenu.add(fileMenuSave); 
    80. 
  
  
  
  
  80.         fileMenu.addSeparator();    //添加分隔线 
    81. 
  
  
  
  
  81.         fileMenu.add(fileMenuExit); 
    82. 
  
  
  
  
  82.         fileMenu.setFont(f);        //设置菜单中文体的字体 
    83. 
  
  
  
  
  83. 
  
  
  
  
  84.          
    85. 
  
  
  
  
  85.         //编辑菜单的实现 
    86. 
  
  
  
  
  86.         editMenu = new JMenu("编辑(E)"); 
    87. 
  
  
  
  
  87.         editMenuCopy = new JMenuItem("复制(C) Ctrl+C"); 
    88. 
  
  
  
  
  88.         editMenuCut = new JMenuItem("剪切(T) Ctrl+X"); 
    89. 
  
  
  
  
  89.         editMenuPaste = new JMenuItem("粘贴(P) Ctrl+v"); 
    90. 
  
  
  
  
  90.         EMHandler EM=new EMHandler();   //创建监听器 
    91. 
  
  
  
  
  91.         editMenuCopy.addActionListener(EM);//注册监听器 
    92. 
  
  
  
  
  92.         editMenuCut.addActionListener(EM); 
    93. 
  
  
  
  
  93.         editMenuPaste.addActionListener(EM); 
    94. 
  
  
  
  
  94.         editMenu.add(editMenuCopy); 
    95. 
  
  
  
  
  95.         editMenu.add(editMenuCut); 
    96. 
  
  
  
  
  96.         editMenu.add(editMenuPaste); 
    97. 
  
  
  
  
  97.         editMenu.setFont(f); 
    98. 
  
  
  
  
  98. 
  
  
  
  
  99. 
  
  
  
  
  100.         //格式菜单的实现 
    101. 
  
  
  
  
  101.         formatMenu = new JMenu("格式(O)");            //创建菜单 
    102. 
  
  
  
  
  102.         formatSet = new JMenu("格式设置");          //二级菜单 
    103. 
  
  
  
  
  103.         lineWrap = new JMenuItem("自动换行");       //二级菜单项 
    104. 
  
  
  
  
  104.         cancleLineWrap = new JMenuItem("取消自动换行"); 
    105. 
  
  
  
  
  105.         wrapStyleWord = new JMenuItem("断行不断字"); 
    106. 
  
  
  
  
  106.         cancleWrapStyleWord = new JMenuItem("取消断行不断字"); 
    107. 
  
  
  
  
  107.         FMHandler FM=new FMHandler();               //创建事件监听器 
    108. 
  
  
  
  
  108.         lineWrap.addActionListener(FM);             //注册二级菜单项的监听器 
    109. 
  
  
  
  
  109.         cancleLineWrap.addActionListener(FM); 
    110. 
  
  
  
  
  110.         wrapStyleWord.addActionListener(FM); 
    111. 
  
  
  
  
  111.         cancleWrapStyleWord.addActionListener(FM); 
    112. 
  
  
  
  
  112.         formatSet.add(lineWrap); 
    113. 
  
  
  
  
  113.         formatSet.add(cancleLineWrap); 
    114. 
  
  
  
  
  114.         formatSet.addSeparator();   //添加分隔线 
    115. 
  
  
  
  
  115.         formatSet.add(wrapStyleWord); 
    116. 
  
  
  
  
  116.         formatSet.add(cancleWrapStyleWord); 
    117. 
  
  
  
  
  117.         formatMenu.add(formatSet); 
    118. 
  
  
  
  
  118.         formatMenu.setFont(f); 
    119. 
  
  
  
  
  119. 
  
  
  
  
  120. 
  
  
  
  
  121.         //将菜单全部添加菜单棒里 
    122. 
  
  
  
  
  122.         mb.add(fileMenu); 
    123. 
  
  
  
  
  123.         mb.add(editMenu); 
    124. 
  
  
  
  
  124.         mb.add(formatMenu); 
    125. 
  
  
  
  
  125. 
  
  
  
  
  126.         //工具栏的实现 
    127. 
  
  
  
  
  127.         //按钮分别为：“打开”、“保存”、“复制”、“剪切”、“粘贴” 
    128. 
  
  
  
  
  128.         toolBar =new JToolBar();    //创建工具棒 
    129. 
  
  
  
  
  129.         b1= new JButton(new ImageIcon("img/open.gif")); 
    130. 
  
  
  
  
  130.         b2= new JButton(new ImageIcon("img/save.gif")); 
    131. 
  
  
  
  
  131.         b3= new JButton(new ImageIcon("img/copy.gif")); 
    132. 
  
  
  
  
  132.         b4= new JButton(new ImageIcon("img/cut.gif")); 
    133. 
  
  
  
  
  133.         b5= new JButton(new ImageIcon("img/paste.gif")); 
    134. 
  
  
  
  
  134.         TBHandler TB=new TBHandler();       //创建按钮监听器 
    135. 
  
  
  
  
  135.         b1.addActionListener(TB);   b2.addActionListener(TB); 
    136. 
  
  
  
  
  136.         b3.addActionListener(TB);   b4.addActionListener(TB); 
    137. 
  
  
  
  
  137.         b5.addActionListener(TB); 
    138. 
  
  
  
  
  138.         //把按钮全部添加到工具棒中 
    139. 
  
  
  
  
  139.         toolBar.add(b1);    toolBar.add(b2); 
    140. 
  
  
  
  
  140.         toolBar.add(b3);    toolBar.add(b4); 
    141. 
  
  
  
  
  141.         toolBar.add(b5); 
    142. 
  
  
  
  
  142. 
  
  
  
  
  143. 
  
  
  
  
  144.         //弹出菜单的实现 
    145. 
  
  
  
  
  145.         pm =new JPopupMenu();   //创建弹出菜单 
    146. 
  
  
  
  
  146.         item1 = new JMenuItem("打开"); 
    147. 
  
  
  
  
  147.         item2 = new JMenuItem("保存"); 
    148. 
  
  
  
  
  148.         item3 = new JMenuItem("复制"); 
    149. 
  
  
  
  
  149.         item4 = new JMenuItem("剪切"); 
    150. 
  
  
  
  
  150.         item5 = new JMenuItem("粘贴"); 
    151. 
  
  
  
  
  151.         JPHandler JP=new JPHandler(); 
    152. 
  
  
  
  
  152.         item1.addActionListener(JP);  //注册菜单项的鼠标事件监听器 
    153. 
  
  
  
  
  153.         item2.addActionListener(JP); 
    154. 
  
  
  
  
  154.         item3.addActionListener(JP); 
    155. 
  
  
  
  
  155.         item4.addActionListener(JP); 
    156. 
  
  
  
  
  156.         item5.addActionListener(JP); 
    157. 
  
  
  
  
  157.         editor.addMouseListener(JP);  //注册文本区的鼠标事件监听器 
    158. 
  
  
  
  
  158.         pm.add(item1);  pm.add(item2); 
    159. 
  
  
  
  
  159.         pm.add(item3);  pm.add(item4); 
    160. 
  
  
  
  
  160.         pm.add(item5); 
    161. 
  
  
  
  
  161. 
  
  
  
  
  162. 
  
  
  
  
  163. 
  
  
  
  
  164. 
  
  
  
  
  165. 
  
  
  
  
  166.          
    167. 
  
  
  
  
  167.         //把菜单栏、工具栏、弹出菜单添加到内容面板 
    168. 
  
  
  
  
  168.         setJMenuBar(mb);        //显示菜单栏 
    169. 
  
  
  
  
  169.         c.add(toolBar,BorderLayout.NORTH); 
    170. 
  
  
  
  
  170.          
    171. 
  
  
  
  
  171. 
  
  
  
  
  172.         setVisible(true); 
    173. 
  
  
  
  
  173.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
    174. 
  
  
  
  
  174.     } 
    175. 
  
  
  
  
  175. 
  
  
  
  
  176. 
  
  
  
  
  177. 
  
  
  
  
  178.     //自定义类实现文件菜单项的事件处理 
    179. 
  
  
  
  
  179.     private class JMHandler implements ActionListener 
    180. 
  
  
  
  
  180.     {    
    181. 
  
  
  
  
  181.         public void actionPerformed(ActionEvent e) 
    182. 
  
  
  
  
  182.         { 
    183. 
  
  
  
  
  183.             if(e.getSource()==fileMenuOpen){ loadFile(); } 
    184. 
  
  
  
  
  184.             else if(e.getSource()==fileMenuSave){ saveFile(); } 
    185. 
  
  
  
  
  185.             else{System.exit(0);} 
    186. 
  
  
  
  
  186.         } 
    187. 
  
  
  
  
  187. 
  
  
  
  
  188.     } 
    189. 
  
  
  
  
  189. 
  
  
  
  
  190.     public void loadFile()  //打开文件方法 
    191. 
  
  
  
  
  191.     { 
    192. 
  
  
  
  
  192.         JFileChooser fc=new JFileChooser(); 
    193. 
  
  
  
  
  193.         int r=fc.showOpenDialog(this); 
    194. 
  
  
  
  
  194.         if(r==JFileChooser.APPROVE_OPTION) 
    195. 
  
  
  
  
  195.         { 
    196. 
  
  
  
  
  196.             File file=fc.getSelectedFile(); 
    197. 
  
  
  
  
  197.             try{ editor.read(new FileReader(file),null);} 
    198. 
  
  
  
  
  198.             catch(IOException e){} 
    199. 
  
  
  
  
  199.         } 
    200. 
  
  
  
  
  200.     } 
    201. 
  
  
  
  
  201.          
    202. 
  
  
  
  
  202.     public void saveFile()  //保存文件的方法 
    203. 
  
  
  
  
  203.     { 
    204. 
  
  
  
  
  204.         JFileChooser fc=new JFileChooser(); 
    205. 
  
  
  
  
  205.         int r=fc.showSaveDialog(this); 
    206. 
  
  
  
  
  206.         if(r==JFileChooser.APPROVE_OPTION) 
    207. 
  
  
  
  
  207.         { 
    208. 
  
  
  
  
  208.             File file=fc.getSelectedFile(); 
    209. 
  
  
  
  
  209.             try{ editor.write(new FileWriter(file));} 
    210. 
  
  
  
  
  210.             catch(IOException e){} 
    211. 
  
  
  
  
  211.         } 
    212. 
  
  
  
  
  212.     } 
    213. 
  
  
  
  
  213. 
  
  
  
  
  214.      
    215. 
  
  
  
  
  215.     //编辑菜单菜单项的事件处理 
    216. 
  
  
  
  
  216.     private class EMHandler implements ActionListener 
    217. 
  
  
  
  
  217.     { 
    218. 
  
  
  
  
  218.         public void actionPerformed(ActionEvent e) 
    219. 
  
  
  
  
  219.         { 
    220. 
  
  
  
  
  220.             if(e.getSource()==editMenuCopy)     //实现复制功能 
    221. 
  
  
  
  
  221.             { 
    222. 
  
  
  
  
  222.                 editor.copy(); 
    223. 
  
  
  
  
  223.                 editor.requestFocus(); 
    224. 
  
  
  
  
  224.             } 
    225. 
  
  
  
  
  225.             else if(e.getSource()==editMenuCut)//实现剪切功能 
    226. 
  
  
  
  
  226.             { 
    227. 
  
  
  
  
  227.                 editor.cut(); 
    228. 
  
  
  
  
  228.                 editor.requestFocus(); 
    229. 
  
  
  
  
  229.             } 
    230. 
  
  
  
  
  230.             else                                //实现粘贴功能 
    231. 
  
  
  
  
  231.             { 
    232. 
  
  
  
  
  232.                 editor.paste(); 
    233. 
  
  
  
  
  233.                 editor.requestFocus(); 
    234. 
  
  
  
  
  234.             } 
    235. 
  
  
  
  
  235.         } 
    236. 
  
  
  
  
  236.     } 
    237. 
  
  
  
  
  237.     //格式菜单二级菜单的菜单项的事件处理 
    238. 
  
  
  
  
  238.     private class FMHandler implements ActionListener 
    239. 
  
  
  
  
  239.     { 
    240. 
  
  
  
  
  240.         public void actionPerformed(ActionEvent e) 
    241. 
  
  
  
  
  241.         { 
    242. 
  
  
  
  
  242.             if(e.getSource()==lineWrap){ editor.setLineWrap(true); } 
    243. 
  
  
  
  
  243.             else if(e.getSource()==cancleLineWrap) { editor.setLineWrap(false);} 
    244. 
  
  
  
  
  244.             else if(e.getSource()==wrapStyleWord) { editor.setWrapStyleWord(true);} 
    245. 
  
  
  
  
  245.             else{ editor.setWrapStyleWord(false); } 
    246. 
  
  
  
  
  246.         } 
    247. 
  
  
  
  
  247.     } 
    248. 
  
  
  
  
  248. 
  
  
  
  
  249. 
  
  
  
  
  250.     //自定义类实现工具栏的按钮事件处理 
    251. 
  
  
  
  
  251.     private class TBHandler implements ActionListener 
    252. 
  
  
  
  
  252.     { 
    253. 
  
  
  
  
  253.         public void actionPerformed(ActionEvent e) 
    254. 
  
  
  
  
  254.         { 
    255. 
  
  
  
  
  255.             if(e.getSource()==b1){ loadFile(); }        //实现打开文件功能 
    256. 
  
  
  
  
  256.             else if(e.getSource()==b2) {saveFile();}    //实现保存文件功能 
    257. 
  
  
  
  
  257.             else if(e.getSource()==b3)  //文件复制 
    258. 
  
  
  
  
  258.             { 
    259. 
  
  
  
  
  259.                 editor.copy(); 
    260. 
  
  
  
  
  260.                 editor.requestFocus(); 
    261. 
  
  
  
  
  261.             } 
    262. 
  
  
  
  
  262.             else if(e.getSource()==b4) //文件剪切 
    263. 
  
  
  
  
  263.             { 
    264. 
  
  
  
  
  264.                 editor.cut(); 
    265. 
  
  
  
  
  265.                 editor.requestFocus(); 
    266. 
  
  
  
  
  266.             } 
    267. 
  
  
  
  
  267.             else                        //文件粘贴 
    268. 
  
  
  
  
  268.             { 
    269. 
  
  
  
  
  269.                 editor.paste(); 
    270. 
  
  
  
  
  270.                 editor.requestFocus(); 
    271. 
  
  
  
  
  271.             } 
    272. 
  
  
  
  
  272.         } 
    273. 
  
  
  
  
  273.     } 
    274. 
  
  
  
  
  274. 
  
  
  
  
  275.     //自定义类实现弹出式菜单的事件处理 
    276. 
  
  
  
  
  276.     private class JPHandler implements ActionListener,MouseListener 
    277. 
  
  
  
  
  277.     { 
    278. 
  
  
  
  
  278.         public void actionPerformed(ActionEvent e) 
    279. 
  
  
  
  
  279.         { 
    280. 
  
  
  
  
  280.             if(e.getSource()==item1){ loadFile(); }     //实现打开文件功能 
    281. 
  
  
  
  
  281.             else if(e.getSource()==item2) {saveFile();} //实现保存文件功能 
    282. 
  
  
  
  
  282.             else if(e.getSource()==item3)   //文件复制 
    283. 
  
  
  
  
  283.             { 
    284. 
  
  
  
  
  284.                 editor.copy(); 
    285. 
  
  
  
  
  285.                 editor.requestFocus(); 
    286. 
  
  
  
  
  286.             } 
    287. 
  
  
  
  
  287.             else if(e.getSource()==item4) //文件剪切 
    288. 
  
  
  
  
  288.             { 
    289. 
  
  
  
  
  289.                 editor.cut(); 
    290. 
  
  
  
  
  290.                 editor.requestFocus(); 
    291. 
  
  
  
  
  291.             } 
    292. 
  
  
  
  
  292.             else                        //文件粘贴 
    293. 
  
  
  
  
  293.             { 
    294. 
  
  
  
  
  294.                 editor.paste(); 
    295. 
  
  
  
  
  295.                 editor.requestFocus(); 
    296. 
  
  
  
  
  296.             } 
    297. 
  
  
  
  
  297.         } 
    298. 
  
  
  
  
  298. 
  
  
  
  
  299.         public void mouseReleased(MouseEvent e) 
    300. 
  
  
  
  
  300.         { 
    301. 
  
  
  
  
  301.             if(e.isPopupTrigger())                  //判断是否按下鼠标右键 
    302. 
  
  
  
  
  302.                 pm.show(editor,e.getX(),e.getY());  //显示弹出式菜单 
    303. 
  
  
  
  
  303.         } 
    304. 
  
  
  
  
  304. 
  
  
  
  
  305.         public void mouseClicked(MouseEvent e){} 
    306. 
  
  
  
  
  306.         public void mouseEntered(MouseEvent e){} 
    307. 
  
  
  
  
  307.         public void mouseExited(MouseEvent e){} 
    308. 
  
  
  
  
  308.         public void mousePressed(MouseEvent e){} 
    309. 
  
  
  
  
  309.     } 
    310. 
  
  
  
  
  310. 
  
  
  
  
  311.      
    312. 
  
  
  
  
  312. 
  
  
  
  
  313.     public static void main(String []args) 
    314. 
  
  
  
  
  314.     { 
    315. 
  
  
  
  
  315.         Nodepad N=new Nodepad(); 
    316. 
  
  
  
  
  316.     } 
    317. 
  
  
  
  
  317.          
    318. 
  
  
  
  
  318. }
    319.

网站题目：Java图形用户界面：高级组件综合例子
转载来于：http://www.shufengxianlan.com/qtweb/news4/39004.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

微信小程序知识

分类信息网站

温江网站制作　　 　宜宾做网站　　 　成都租用服务器　　 　成都网站优化　　 　成都能净科技　　 　郫县明安消防器材　　 　企业网站维护　　 　成都定制网站　　 　南充电信机房托管　　 　成都移动托管　　 　艾瑞格衣柜　　 　四川电信高防服务器托管　　 　不锈钢防护栏　　 　和县翔豪网站　　 　外贸营销网站建设　　 　服务器租用　　 　手机网站建设　　 　网站开发　　 　成都品牌官网设计公司　　 　眉山服务器托管