A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 黑马刘涛 中级黑马   /  2012-7-10 17:59  /  1839 人查看  /  6 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 黑马刘涛 于 2012-7-16 12:14 编辑

遇到问题了,程序在System.out.println("str"+str)处结束
设置了断点调试,最后查看main方法中变量str能得到正确值,但是不能打印,程序在这里就结束了。在eclipse中会提示我一些我倒入的类和加密解密方法没用到,到底是哪儿出问题了?麻烦大家解惑!!
  1. /*要求:参考API帮助,查找相关的方法,使用String类完成如下功能,对英文字符串进行加密处理。

  2. (1) 将给定的英文字符取相反顺序,并改变每个字符的大小写形式。
  3. (2) 将经第一步处理的信息进一步加工,将每个字符取其所在字母表中的顺序,取其后一个字母。
  4. (3) 编写解密方法。
  5. (4) 编写测试函数,在运行时通过命令行参数接受需要处理的字符串,将源字符串、加密字符串和解密字符串打印到屏幕输出。
  6. */
  7. import java.lang.*;
  8. import java.util.*;
  9. import java.io.*;
  10. class StringProc
  11. {
  12.         public static void main(String[] args)
  13.         {
  14.                 String str = "";
  15.                 System.out.println("请输入英文字符串");
  16.                 str = inputStr();//从键盘输入字符串
  17.                 System.out.println("str"+str);
  18.                 System.out.println("加密后输出");
  19.                 Encryption e = new Encryption(str);
  20.                 System.out.println(e.encryption(e.get()));
  21.                 System.out.println("解密后输出");
  22.                 Deciphering d = new Deciphering(e.encryption(e.get()));
  23.                 System.out.println(d.deciphering(e.get()));
  24.         }
  25.         public static String inputStr()
  26.         {               
  27.                 BufferedReader bufr = null;
  28.                 BufferedWriter bufw = null;
  29.                 String line = null;
  30.                 try
  31.                 {
  32.                         bufr = new BufferedReader(new InputStreamReader(System.in));
  33.                         bufw = new BufferedWriter(new OutputStreamWriter(System.out));
  34.                         //String line = null;

  35.                         if((line=bufr.readLine())!=null)
  36.                         {
  37.                                 bufw.write(line,0,line.length());
  38.                                 bufw.newLine();
  39.                                 bufw.flush();
  40.                         }
  41.                         return line;

  42.                 }
  43.                 catch (IOException e)
  44.                 {
  45.                         throw new RuntimeException("读写失败");
  46.                 }
  47.                 finally
  48.                 {
  49.                         try
  50.                         {
  51.                                 if(bufr!=null)
  52.                                         bufr.close();
  53.                                 
  54.                         }
  55.                         catch (IOException e)
  56.                         {
  57.                                 throw new RuntimeException("读取流关闭失败");
  58.                         }
  59.                         try
  60.                         {
  61.                                 if(bufw!=null)
  62.                                         bufw.close();
  63.                         }
  64.                         catch (IOException e)
  65.                         {
  66.                                 throw new RuntimeException("写入流关闭失败");
  67.                         }
  68.                 }
  69.         }
  70. }
  71. //加密类
  72. class Encryption
  73. {
  74.         private String str = null;
  75.         //构造方法
  76.         Encryption(String str)
  77.         {
  78.                 this.str = str;
  79.         }
  80.         public String get()
  81.         {
  82.                 return this.str;
  83.         }
  84.         //加密方法
  85.         public String encryption(String str)
  86.         {
  87.                 String oldString = str;
  88.                 String newString = null;
  89.                 //改变每个字符的大小写形式并将字符串取反
  90.                 return newString = this.upperLowerCaseReverse(this.reverse(oldString));
  91.         }
  92.         //交换大小写并返回处理后的字符串
  93.         private String upperLowerCaseReverse(String oldString)
  94.         {
  95.                 String str = oldString;
  96.                 char[] charArray = str.toCharArray();
  97.                 for(int i=0;i<charArray.length;i++)
  98.                 {
  99.                         char ch = charArray[i];
  100.                         if(ch=='z')
  101.                                 charArray[i] = 'A';
  102.                         else if(ch=='Z')
  103.                                 charArray[i] = 'A';
  104.                         else if(Character.isLowerCase(ch)==true)
  105.                                 charArray[i] = (char)(Character.toUpperCase(ch) + 1);//小写英文字符改为大写取其所在字母表中的顺序其后一个字母
  106.                         else if(Character.isUpperCase(ch)==true)
  107.                                 charArray[i] = (char)(Character.toLowerCase(ch) + 1);//大写英文字符改为小写取其所在字母表中的顺序其后一个字母
  108.                         else
  109.                                 continue;
  110.                 }
  111.                 return String.copyValueOf(charArray);
  112.         }
  113.         //将给定的英文字符取相反顺序
  114.         private String reverse(String str)
  115.         {
  116.                 StringBuilder sb = new StringBuilder(str);
  117.                 return sb.reverse().substring(0,sb.length());
  118.         }
  119. }
  120. class Deciphering //解密类
  121. {
  122.         private String str = null;
  123.         //构造方法
  124.         Deciphering(String str)
  125.         {
  126.                 this.str = str;
  127.         }
  128.         public String get()
  129.         {
  130.                 return this.str;
  131.         }

  132.         public String deciphering(String str)
  133.         {
  134.                 String oldString = str;
  135.                 String newString = null;
  136.                 //改变每个字符的大小写形式并将字符串取反
  137.                 return newString = this.upperLowerCaseReverse(this.reverse(oldString));
  138.         }
  139.         //交换大小写并返回处理后的字符串
  140.         private String upperLowerCaseReverse(String oldString)
  141.         {
  142.                 String str = oldString;
  143.                 char[] charArray = str.toCharArray();
  144.                 for(int i=0;i<charArray.length;i++)
  145.                 {
  146.                         char ch = charArray[i];
  147.                         if(ch=='a')
  148.                                 charArray[i] = 'Z';
  149.                         else if(ch=='z')
  150.                                 charArray[i] = 'A';
  151.                         else if(Character.isLowerCase(ch)==true)
  152.                                 charArray[i] = (char)(Character.toUpperCase(ch) - 1);//小写英文字符改为大写取其所在字母表中的顺序前面一个字母
  153.                         else if(Character.isUpperCase(ch)==true)
  154.                                 charArray[i] = (char)(Character.toLowerCase(ch) - 1);//大写英文字符改为小写取其所在字母表中的顺序前面一个字母
  155.                         else
  156.                                 continue;
  157.                 }
  158.                 return String.copyValueOf(charArray);
  159.         }
  160.         //将给定的英文字符取相反顺序
  161.         private String reverse(String str)
  162.         {
  163.                 StringBuilder sb = new StringBuilder(str);
  164.                 return sb.reverse().substring(0,sb.length());
  165.         }
  166. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
蒋映辉 + 1 鼓励一下新童鞋...

查看全部评分

6 个回复

正序浏览
对了,我主程序里还在继续用标准输出流out,去掉了关流操作。
修改了下,循环输入。
  1. /*要求:参考API帮助,查找相关的方法,使用String类完成如下功能,对英文字符串进行加密处理。

  2. (1) 将给定的英文字符取相反顺序,并改变每个字符的大小写形式。
  3. (2) 将经第一步处理的信息进一步加工,将每个字符取其所在字母表中的顺序,取其后一个字母。
  4. (3) 编写解密方法。
  5. (4) 编写测试函数,在运行时通过命令行参数接受需要处理的字符串,将源字符串、加密字符串和解密字符串打印到屏幕输出。
  6. */
  7. import java.lang.*;
  8. import java.util.*;
  9. import java.io.*;
  10. class StringProc
  11. {
  12.         public static void main(String[] args) throws NullPointerException
  13.         {
  14.                 while(true)
  15.                 {       
  16.                         String str = "";
  17.                         System.out.println("请输入英文字符串");
  18.                         str = inputStr();//从键盘输入字符串
  19.                         System.out.println("加密后输出");
  20.                         Encryption e = new Encryption(str);
  21.                         System.out.println(e.encryption(e.get()));
  22.                         System.out.println("解密后输出");
  23.                         Deciphering d = new Deciphering(e.encryption(e.get()));
  24.                         System.out.println(d.deciphering(d.get()));
  25.                         System.out.println("");
  26.                 }
  27.         }
  28.         public static String inputStr()
  29.         {               
  30.                 BufferedReader bufr = null;
  31.                 BufferedWriter bufw = null;
  32.                 String line = null;
  33.                 try
  34.                 {
  35.                         bufr = new BufferedReader(new InputStreamReader(System.in));
  36.                         bufw = new BufferedWriter(new OutputStreamWriter(System.out));
  37.                         //String line = null;

  38.                         if((line=bufr.readLine())!=null)
  39.                         {
  40.                                 bufw.write(line,0,line.length());
  41.                                 bufw.newLine();
  42.                                 bufw.flush();
  43.                         }
  44.                         return line;

  45.                 }
  46.                 catch (IOException e)
  47.                 {
  48.                         throw new RuntimeException("读写失败");
  49.                 }
  50.         }
  51. }
  52. //加密类
  53. class Encryption
  54. {
  55.         private String str = null;
  56.         //构造方法
  57.         Encryption(String str)
  58.         {
  59.                 this.str = str;
  60.         }
  61.         public String get()
  62.         {
  63.                 return this.str;
  64.         }
  65.         //加密方法
  66.         public String encryption(String str)
  67.         {
  68.                 String oldString = str;
  69.                 String newString = null;
  70.                 //改变每个字符的大小写形式并将字符串取反
  71.                 return newString = this.upperLowerCaseReverse(this.reverse(oldString));
  72.         }
  73.         //交换大小写并返回处理后的字符串
  74.         private String upperLowerCaseReverse(String oldString)
  75.         {
  76.                 String str = oldString;
  77.                 char[] charArray = str.toCharArray();
  78.                 for(int i=0;i<charArray.length;i++)
  79.                 {
  80.                         char ch = charArray[i];
  81.                         if(ch=='z')
  82.                                 charArray[i] = 'A';
  83.                         else if(ch=='Z')
  84.                                 charArray[i] = 'a';
  85.                         else if(Character.isLowerCase(ch)==true)
  86.                                 charArray[i] = (char)(Character.toUpperCase(ch) + 1);//小写英文字符改为大写取其所在字母表中的顺序其后一个字母
  87.                         else if(Character.isUpperCase(ch)==true)
  88.                                 charArray[i] = (char)(Character.toLowerCase(ch) + 1);//大写英文字符改为小写取其所在字母表中的顺序其后一个字母
  89.                         else
  90.                                 continue;
  91.                 }
  92.                 return String.copyValueOf(charArray);
  93.         }
  94.         //将给定的英文字符取相反顺序
  95.         private String reverse(String str)
  96.         {
  97.                 StringBuilder sb = new StringBuilder(str);
  98.                 return sb.reverse().substring(0,sb.length());
  99.         }
  100. }
  101. class Deciphering //解密类
  102. {
  103.         private String str = null;
  104.         //构造方法
  105.         Deciphering(String str)
  106.         {
  107.                 this.str = str;
  108.         }
  109.         public String get()
  110.         {
  111.                 return this.str;
  112.         }

  113.         public String deciphering(String str)
  114.         {
  115.                 String oldString = str;
  116.                 String newString = null;
  117.                 //改变每个字符的大小写形式并将字符串取反
  118.                 return newString = this.upperLowerCaseReverse(this.reverse(oldString));
  119.         }
  120.         //交换大小写并返回处理后的字符串
  121.         private String upperLowerCaseReverse(String oldString)
  122.         {
  123.                 String str = oldString;
  124.                 char[] charArray = str.toCharArray();
  125.                 for(int i=0;i<charArray.length;i++)
  126.                 {
  127.                         char ch = charArray[i];
  128.                         if(ch=='a')
  129.                                 charArray[i] = 'Z';
  130.                         else if(ch=='A')
  131.                                 charArray[i] = 'z';
  132.                         else if(Character.isLowerCase(ch)==true)
  133.                                 charArray[i] = (char)(Character.toUpperCase(ch) - 1);//小写英文字符改为大写取其所在字母表中的顺序前面一个字母
  134.                         else if(Character.isUpperCase(ch)==true)
  135.                                 charArray[i] = (char)(Character.toLowerCase(ch) - 1);//大写英文字符改为小写取其所在字母表中的顺序前面一个字母
  136.                         else
  137.                                 continue;
  138.                 }
  139.                 return String.copyValueOf(charArray);
  140.         }
  141.         //将给定的英文字符取相反顺序
  142.         private String reverse(String str)
  143.         {
  144.                 StringBuilder sb = new StringBuilder(str);
  145.                 return sb.reverse().substring(0,sb.length());
  146.         }
  147. }
复制代码
回复 使用道具 举报
关键是我关闭了out,in后也没再继续用。你给的帖子很有参考价值,但是是不同情况。
回复 使用道具 举报
你关闭out和in 后边就没法用了
参考资料:
http://bbs.itheima.com/forum.php?mod=viewthread&tid=17629
回复 使用道具 举报
果然,上面兄台真是一针见血,那到底是什么原因导致程序结束的呢?
回复 使用道具 举报
本帖最后由 rslheima 于 2012-7-10 18:30 编辑

你要把finally里面的代码全都注释掉,就可以了,经验。。。。。。。。。
不过这个加解密程序,是不是  。。。。。。。。。。。。。
回复 使用道具 举报
版主 ,帮忙想想啊。我把基础课程里讲的一些内容都在这道题里写了一下。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马