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图形用户界面：高级组件综合例子
URL链接：http://www.csdahua.cn/qtweb/news4/39004.html

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

广告

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

成都快上网为您推荐相关内容

品牌网站建设知识

同城分类信息

成都app开发　　 　整合营销　　 　雅安移动机房　　 　外贸网站建设　　 　传美奇电器　　 　wap网站建设　　 　网站推广　　 　成都保温材料　　 　成都响应式网站建设　　 　达州网站建设　　 　手机网站开发　　 　什邡网站建设　　 　公司宣传册设计　　 　成都谷歌推广　　 　抖音短视频拍摄　　 　成都小程序开发　　 　节能环保网站建设方案　　 　成都网络公司　　 　重庆网络营销　　 　建站公司