一些练习题,未写完
package com.gotoheima; /** * 看JDK多少位 */ public class Test0 { public static void main(String[] args) { String banben = System.getProperty("sun.arch.data.model"); System.out.println(banben); } }
package com.gotoheima; import java.io.FileReader; import java.io.IOException; import java.io.Reader; /** * 编写一个类,增强java.io.BufferedReader的ReadLine()方法,使之在读取某个文件时,能打印出行号。 * * 就是一个模拟BufferedReadLine的程序 * 定义一个计数器,定义Reader * 模拟ReadLine方法,当读取一行,计数器+1,遇到\r\n就表示应该换行 * 关闭缓冲区 * */ public class Test1 { public static void main(String[] args) { MyLineNumReader mnr = null; try { mnr = new MyLineNumReader(new FileReader("Test.txt")); String line = null; while ((line = mnr.myReadLine()) != null) { System.out.println(mnr.getCount()+":\t"+line); } } catch (IOException e) { System.out.println("读写错误"); } finally { try { if (mnr != null) mnr.myClose(); } catch (IOException e) { System.out.println("流关闭错误"); } } } } //声明一个类,模拟BufferedReader方法 class MyLineNumReader { private Reader r; private int count; //构造函数,使可以被创建对象 MyLineNumReader(Reader r) { this.r = r; } //定义一个myReadLine方法,功能是读取一行数据 public String myReadLine() throws IOException { StringBuffer sb = new StringBuffer (); int num = 0; count ++; while ((num = r.read()) != -1) { if (num == '\r') continue; if (num == '\n') return sb.toString(); else sb.append((char)num); } if (sb.length() != 0) return sb.toString(); return null; } //必要的读取属性的方法 public int getCount() { return count; } ////必要的修改属性的方法 public void setCount(int count) { this.count = count; } //关流方法 public void myClose() throws IOException { r.close(); } }
package com.gotoheima; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FilenameFilter; import java.io.IOException; /** * 编写程序,将指定目录下所有的.java文件拷贝到另一个目的中,将扩展名改为.txt。 * 定义一个函数,函数功能是遍历当前目录所有非文件夹的文件 * 把后缀是.java文件的文件拷贝到另一个文件夹中 * 修改她们的后缀名为.txt,用String的replace方法。 * */ public class Test3 { public static void main(String[] args) { File f = new File("F:\\java\\day20"); copyFile(f); } //函数功能:把一个文件夹下面的.java结尾的文件复制到copy文件夹下面并改名 public static void copyFile(File f) { //创建一个copy文件加,复制后的文件会被装进来 File copy = new File("copy"); copy.mkdir(); //过滤。java文件 File[] files = f.listFiles(new FilenameFilter() { public boolean accept(File f,String name) { return name.endsWith(".java"); } }); //复制文件并改名 for (File fileName : files) { BufferedInputStream bis = null; BufferedOutputStream bos = null; try { bis = new BufferedInputStream(new FileInputStream(fileName)); //把后缀名.java改成.txt String newName = fileName.getName().replace(".java",".txt"); bos = new BufferedOutputStream(new FileOutputStream(new File(copy,newName))); byte[] by = new byte[1024]; int num = 0; while ((num = bis.read()) != -1) { bos.write(by,0,num); } } catch(IOException e) { throw new RuntimeException("读写出错"); } finally { try { if (bis != null) bis.close(); } catch(IOException e) { throw new RuntimeException("读取关闭出错"); } try { if (bos != null) bos.close(); } catch(IOException e) { throw new RuntimeException("写入关闭出错"); } } } } }
package com.gotoheima; import java.lang.reflect.Method; import java.util.ArrayList; /** * * ArrayList list = new ArrayList(); 在这个泛型为Integer的ArrayList中存放一个String类型的对象。 * * 这里考察的是反射,获取ArrayList的字节码对象 * 用Method的方法获取add的字段 * 绕过编译阶段去添加String类型对象 * */ public class Test4 { public static void main(String[] args) throws Exception { ArrayList<Integer> list = new ArrayList<Integer>(); Method methodAdd = list.getClass().getMethod("add",Object.class); methodAdd.invoke(list,"String"); System.out.println(list); } }
package com.gotoheima; import java.util.Collections; import java.util.Scanner; import java.util.TreeSet; /** * 编写程序,循环接收用户从键盘输入多个字符串,直到输入“end”时循环结束,并将所有已输入的字符串按字典顺序倒序打印。 * 用Scanner扫描多个字符串 * 判断,如果扫描的字符串是end则结束循环 * 如果不是存入集合中,因为考虑排序,所以用TreeSet集合 * 定义其比较规则,实现comparable * 打印 */ public class Test5 { public static void main(String[] args) { TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder()); Scanner sc = new Scanner(System.in); System.out.print("输入字符串(end结束):"); while (true) { String str = sc.next(); if (str.equals("end")) break; ts.add(str); } System.out.println(ts); } }
package com.gotoheima; import java.lang.reflect.Method; /** * * 编写一个类,增加一个实例方法用于打印一条字符串。并使用反射手段创建该类的对象,并调用该对象中的方法 * */ public class Test6 { public static void main(String[] args) throws Exception { Class<stringDemo> clazz = stringDemo.class; Method method = clazz.getMethod("printDemo",String.class); method.invoke(clazz.newInstance(),"Hello java"); } } class stringDemo { public void printDemo(String str) { System.out.println(str); } }
package com.gotoheima; import java.io.FileInputStream; import java.io.IOException; /** * * 定义一个文件输入流,调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组的大小限制为5,不考虑中文编码问题) * */ public class Test7 { public static void main(String[] args) { FileInputStream fis = null; try { fis = new FileInputStream("exercise.txt"); byte[] b = new byte[5]; int num = 0; while ((num = fis.read(b)) != -1) { System.out.print(new String(b,0,num)); } } catch(IOException e) { throw new RuntimeException("读写出错!"); } finally { try { if (fis != null) fis.close(); } catch(IOException e) { throw new RuntimeException("关闭出错!"); } } } }
package com.gotoheima; import java.util.Scanner; /** * 编写一个程序,它先将键盘上输入的一个字符串转换成十进制整数,然后打印出这个十进制整数对应的二进制形式。 * 这个程序要考虑输入的字符串不能转换成一个十进制整数的情况,并对转换失败的原因要区分出是数字太大,还是其中包含有非数字字符的情况。 * 提示:十进制数转二进制数的方式是用这个数除以2,余数就是二进制数的最低位,接着再用得到的商作为被除数去除以2 ,这次得到的余数就是次低位,如此循环,直到被除数为0为止。 * 其实,只要明白了打印出一个十进制数的每一位的方式(不断除以10,得到的余数就分别是个位,十位,百位),就很容易理解十进制数转二进制数的这种方式。 * * */ public class Test8 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入一个字符串:"); String str = sc.next(); int in = 0; try { in = Integer.parseInt(str); long shang = in/2; long yu = in%2; StringBuffer sb = new StringBuffer(); while (shang != 0) { yu = shang%2; shang = shang/2; sb.append(yu); } System.out.println(sb.reverse().toString()); } catch (Exception e) { String regx = ".*\\D+.*"; if (str.matches(regx)) throw new RuntimeException("出现非数字"); else throw new RuntimeException("范围超出"); } } }
package com.gotoheima; /** * 将字符串中进行反转。abcde -->edcba * 定义一个StringBuffer * reverse方法 * */ public class Test9 { public static void main(String[] args) { StringBuffer sb = new StringBuffer("abcde"); sb.reverse(); System.out.print(sb.toString()); } }
package com.gotoheima; import java.util.HashSet; import java.util.Random; /** * 编写一个程序,获取10个1至20的随机数,要求随机数不能重复。 * * */ public class Test10 { public static void main(String[] args) { Random r = new Random(); HashSet<Integer> hs = new HashSet<Integer>(); while (hs.size()<10) { hs.add(r.nextInt(20)+1); } System.out.println(hs); } }
package com.gotoheima; import java.util.Iterator; import java.util.Map; import java.util.Set; import java.util.TreeMap; /** * 取出一个字符串中字母出现的次数。如:字符串:"abcde%^kka27qoq" ,输出格式为: a(2)b(1)k(2)... * 把字符串存到数组中 * 因为存在对应关系,所以可以考虑把每个字符存进map集合中 * 遍历数组,如果出现字符就存 * 因为要转成相应的格式,所以可以考虑StringBuilder * * */ public class Test11 { public static void main(String[] args) { String str = "asdasdasdada"; char[] ch = str.toCharArray(); TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>(); for (int i=0;i<ch.length;i++) { Integer value = tm.get(ch[i]); if (value == null) tm.put(ch[i], 1); else { value += 1; tm.put(ch[i], value); } } //通过StringBuilder转换成相应格式 StringBuilder sb = new StringBuilder(); Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet(); for (Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator(); it.hasNext(); ) { Map.Entry<Character,Integer> me = it.next(); Character key = me.getKey(); Integer value =me.getValue(); sb.append(key+"("+value+")"); } System.out.println(sb.toString()); } }
package com.gotoheima; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.util.Arrays; /** * 已知文件a.txt文件中的内容为“bcdeadferwplkou”,请编写程序读取该文件内容,并按照自然顺序排序后输出到b.txt文件中。即b.txt中的文件内容应为“abcd…………..”这样的顺序。 * * 因为已知为一个字符串,所以用字符流读取,因为有重复字符,所以不可以使用Set和Map集合 * 所以存到ArrayList集合中,用collections中的sort方法进行排序 * 写入到b文件中输出 * */ public class Test12 { public static void main(String[] args) throws IOException { FileInputStream fis = null; FileOutputStream fos = null; try { fis = new FileInputStream("a.txt"); fos = new FileOutputStream("b.txt"); byte[] by = new byte[1024]; int num = 0; while ((num = fis.read(by)) != -1) { Arrays.sort(by); fos.write(by,0,num); } } catch(IOException e) { e.printStackTrace(); } finally { try { fis.close(); } catch(IOException e) { e.printStackTrace(); } try { fos.close(); } catch (IOException e) { e.printStackTrace(); } } } }
package com.gotoheima; /** * 编写三各类Ticket、SealWindow、TicketSealCenter分别代表票信息、售票窗口、售票中心。售票中心分配一定数量的票,由若干个售票窗口进行出售,利用你所学的线程知识来模拟此售票过程。 * * 多个售票窗口一起工作,这是一个多线程考题 * * */ public class Test13 { public static void main(String[] args) { SealWindow sw = new SealWindow(); Thread t1 = new Thread(sw); Thread t2 = new Thread(sw); Thread t3 = new Thread(sw); t1.start(); t2.start(); t3.start(); } } class SealWindow implements Runnable { TicketSealCenter tsc = new TicketSealCenter(100); private int ticket; public void run() { System.out.println(Thread.currentThread().getName()+"------"+ticket--); } } class TicketSealCenter { private int ticket; TicketSealCenter(int ticket) { this.ticket = ticket; } public int getTicket() { return ticket; } public void setTicket(int ticket) { this.ticket = ticket; } } class Ticket { private String name;//车次 private int num;//座位号 public String getName() { return name; } public int getNum() { return num; } }
package com.gotoheima; /** * * 已知一个int类型的数组,用冒泡排序法将数组中的元素进行升序排列。 * */ public class Test14 { public static void main(String[] args) { int[] arr = {3,5,6,1,3,8,9,3,9}; for (int x=0;x<arr.length-1;x++) { for (int y=0;y<arr.length-x-1;y++) { if (arr[y] > arr[y+1]) { swap(arr,y,y+1); } } } for (int i=0;i<arr.length;i++) { System.out.println(arr[i]); } } public static void swap(int[] arr,int x,int y) { int temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } }
package com.gotoheima; /** * 假如我们在开发一个系统时需要对员工进行建模,员工包含 3 个属性:姓名、工号以及工资。经理也是员工,除了含有员工的属性外,另为还有一个奖金属性。 * 请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。 * * */ public class Test15 { public static void main(String[] args) { Worker e = new Worker("leilei","007",5000); Manager m = new Manager("hanmeimei","001",10000,20000); System.out.println("员工姓名:"+e.getName()+"\t工号:"+e.getId()+"\t工资:"+e.getMoney()); System.out.println("经理姓名:"+m.getName()+"\t工号:"+m.getId()+"\t工资:"+m.getMoney()+"\t奖金:"+m.getBouns()); } } class Worker { private String name; private String id; private long money; Worker(String name,String id,long money) { this.name = name; this.id = id; this.money = money; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getId() { return id; } public void setId(String id) { this.id = id; } public long getMoney() { return money; } public void setMoney(long money) { this.money = money; } } class Manager extends Worker { private double bonus; Manager(String name,String id,long money,double bouns) { super(name, id, money); this.bonus = bouns; } public double getBouns() { return bonus; } public void setBouns(double bouns) { this.bonus = bouns; } }
package com.gotoheima; import java.util.ArrayList; import java.util.Collections; import java.util.Random; /** * 编写程序,生成5个1至10之间的随机整数,存入一个List集合,编写方法对List集合进行排序(自定义排序算法,禁用Collections.sort方法和TreeSet),然后遍历集合输出。 * * */ public class Test16 { public static void main(String[] args) { ArrayList<Integer> al = new ArrayList<Integer>(); Random r= new Random(); while (al.size()<5) { al.add(r.nextInt(10)+1); } //排序 for (int x=0;x<al.size()-1;x++) { for (int y=0;y<al.size()-x-1;y++) { if (al.get(y)>al.get(y+1)) Collections.swap(al, y, y+1); } } System.out.println(al); } }
package com.gotoheima; import java.util.Arrays; /** * 把以下IP存入一个txt文件,编写程序把这些IP按数值大小,从小到达排序并打印出来。 * 61.54.231.245 * 61.54.231.9 * 61.54.231.246 * 61.54.231.48 * 61.53.231.249 * * */ public class Test17 { public static void main(String[] args) { String[] ip = {"61.54.231.245","61.54.231.9","61.54.231.246","61.54.231.48","61.53.231.249"}; Arrays.sort(ip); for (int i=0;i<ip.length;i++) { System.out.println(ip[i]); } } }
package com.gotoheima; /** * * 写一方法,打印等长的二维数组,要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如: n = 4 则打印: * 1 2 3 4 * 12 13 14 5 * 11 16 15 6 * 10 9 8 7 * */ public class Test18 { public static void main(String[] args) { printMath(60); } public static void printMath(int n) { int[][] arr = new int[n][n]; int x = 0; int y = 0; int max = arr.length-1; int min = 0; int num = 1; while (min<=max) { //right while (y<max) { arr[x][y++] = num++; } //down while (x<max) { arr[x++][y] = num++; } //left while (y>min) { arr[x][y--] = num++; } //up while (x>min) { arr[x--][y] = num++; } //如果是奇数,可能赋值不上 if (min == max) { arr[x][y] = num; } max--; min++; x++; y++; } for (int i=0;i<arr.length;i++) { for (int j=0;j<arr.length;j++) { System.out.print(arr[i][j]+"\t"); } System.out.println(); } } }
package com.gotoheima; /** * 28人买可乐喝,3个可乐瓶盖可以换一瓶可乐,那么要买多少瓶可乐,够28人喝?假如是50人,又需要买多少瓶可乐?(需写出分析思路) * * 三个瓶盖就是一个可乐和一个瓶盖 * */ public class Test19 { public static void main(String[] args) { System.out.println(buyCoke(28)); System.out.println(buyCoke(50)); } public static int buyCoke(int num) { int coke = 0; int cap = 0; int buy = 0; while (coke < num) { buy++; coke++; cap++; if (cap == 3) { coke++; cap = 1; } } return buy; } }
package com.gotoheima; import java.io.FileReader; import java.io.IOException; import java.io.Reader; /** * 自定义字符输入流的包装类,通过这个包装类对底层字符输入流进行包装,让程序通过这个包装类读取某个文本文件(例如,一个java源文件)时,能够在读取的每行前面都加上有行号和冒号。 * */ public class Test20 { public static void main(String[] args) { MyLineNumberReader mlnr = null; try { mlnr = new MyLineNumberReader(new FileReader("F:\\java\\day09\\Demo.java")); String len = null; while ((len = mlnr.myReadLine()) != null) { System.out.println(mlnr.getCount()+":\t"+len); } } catch (IOException e) { System.out.println("读取出错!"); } finally { try { if (mlnr != null) mlnr.myclose(); } catch (IOException e) { System.out.println("关闭出错"); } } } } class MyLineNumberReader { private Reader r; private int count; MyLineNumberReader(Reader r) { this.r = r; } public String myReadLine() throws IOException { StringBuffer sb = new StringBuffer(); int num = 0; count++; while ((num = r.read()) != -1) { if (num == '\r') continue; if (num == '\n') return sb.toString(); else sb.append((char)num); } if (sb.length() != 0) return sb.toString(); return null; } public void myclose() throws IOException { r.close(); } public int getCount() { return count; } public void setCount(int count) { this.count = count; } }
package com.gotoheima; /** * 使用TCP协议写一个可以上传文件的服务器和客户端。 * * */ public class Test21 { public static void main(String[] args) { } }
import java.io.*; import java.util.*; /** 把一个文件夹下的包括子文件夹里的所有.java文件复制到另一个文件夹下面,并改名.txt 对一个文件夹进行递归,筛选出.java文件,并存到集合中 用IO字符流操作复制文件,并将.java文件改成.txt */ class DirPrintListDemo { public static void main(String[] args) throws IOException { //源文件夹 File dir = new File("F:\\java"); //目标文件夹 File copy = new File("F:\\copy_java"); if (!copy.exists()) copy.mkdir(); ArrayList<File> dirlist = new ArrayList<File>(); fileToArray(dir,dirlist); copy_ReName(dirlist,copy); } //函数功能,把一个文件夹中包括子文件夹的所有.java文件存到dirlist集合中 public static void fileToArray(File dir,List<File> dirlist) { File[] files = dir.listFiles(); for (File file : files ) { if (file.isDirectory()) fileToArray(file,dirlist); else { if (file.getName().endsWith(".java")) dirlist.add(file); } } } //函数功能,用IO字符流操作复制文件,并将.java文件改成.txt public static void copy_ReName(List<File> dirlist,File copy) throws IOException { //遍历集合 for (File files : dirlist) { BufferedReader br = new BufferedReader(new FileReader(files)); String newName = files.getName().replace(".java",".txt"); BufferedWriter bw = new BufferedWriter(new FileWriter(new File(copy,newName))); String len = null; while ((len = br.readLine()) != null) { bw.write(len); bw.newLine(); bw.flush(); } br.close(); bw.close(); } } }
package com.gotoheima; import java.util.Iterator; import java.util.Map; import java.util.Set; import java.util.TreeMap; /** * 编写一个类,在main方法中定义一个Map对象(采用泛型),加入若干个对象,然后遍历并打印出各元素的key和value。 * * */ public class Test22 { public static void main(String[] args) { Map<String,Integer> m = new TreeMap<String,Integer>(); m.put("Lilei", 10); m.put("hanmeimei", 9); //第一种 Set<Map.Entry<String,Integer>> entrySet = m.entrySet(); for (Iterator<Map.Entry<String,Integer>> it = entrySet.iterator();it.hasNext(); ) { Map.Entry<String,Integer> me = it.next(); String key = me.getKey(); Integer value = me.getValue(); System.out.println(key+"-------"+value); } //第二种 Set<String> keySet = m.keySet(); for (Iterator<String> it = keySet.iterator();it.hasNext(); ) { String key = it.next(); Integer value = m.get(key); System.out.println(key+"-------"+value); } } }
package com.gotoheima; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Iterator; import java.util.Map; import java.util.Set; import java.util.TreeMap; /** * 把当前文件中的所有文本拷贝,存入一个txt文件,统计每个字符出现的次数并输出,例如: a: 21 次 b: 15 次 c:: 15 次 把: 7 次 当: 9 次 前: 3 次 ,:30 次 * * */ public class Test23 { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new FileReader("面试题.txt")); BufferedWriter bw = new BufferedWriter(new FileWriter("tongji.txt")); TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>(); String len = null; while ((len = br.readLine()) != null) { char[] chs = len.toCharArray(); for (int i=0;i<chs.length;i++) { Integer value = tm.get(chs[i]); if (value == null) { tm.put(chs[i],1); } else { value += 1; tm.put(chs[i], value); } } } Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet(); for (Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();it.hasNext(); ) { Map.Entry<Character, Integer> me = it.next(); Character key = me.getKey(); Integer value = me.getValue(); bw.write(key+": "+value+"次"); bw.newLine(); bw.flush(); } br.close(); bw.close(); } }
package com.gotoheima; /** * 在一个类中编写一个方法,这个方法搜索一个字符数组中是否存在某个字符,如果存在,则返回这个字符在字符数组中第一次出现的位置(序号从0开始计算),否则,返回-1。 * 要搜索的字符数组和字符都以参数形式传递传递给该方法,如果传入的数组为null, 应抛出IllegalArgumentException异常。在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确, * 例如,字符不存在,字符存在,传入的数组为null等。 * * */ public class Test24 { public static void main(String[] args) { char[] chs = {'z','a','c','t','c'}; IsTest it = new IsTest(); System.out.println(it.isTest(chs, 'c')); System.out.println(it.isTest(chs, 'v')); System.out.println(it.isTest(null, 'c')); } } class IsTest { public int isTest(char[] chs,char ch) { if (chs == null) throw new IllegalArgumentException("传入字符数组不能为空!"); for (int i=0;i<chs.length;i++) { if (ch == chs[i])//基本数据类型不能用equals,用== return i; } return -1; } }
package com.gotoheima; import java.io.FileReader; import java.lang.reflect.Method; import java.util.Properties; /** * 已知一个类,定义如下: package cn.itcast.heima; public class DemoClass { public void run() { System.out.println("welcome to heima!"); } } (1) 写一个Properties格式的配置文件,配置类的完整名称。 (2) 写一个程序,读取这个Properties配置文件,获得类的完整名称并加载这个类,用反射 的方式运行run方法。 * * */ public class Test25 { public static void main(String[] args) throws Exception { Properties prop = new Properties(); prop.load(new FileReader("cn\\itcast\\heima\\class.propertise")); String className = prop.getProperty("name"); Class clazz = Class.forName(className); Method method = clazz.getMethod("run", null); method.invoke(clazz.newInstance()); } }
package com.gotoheima; import java.util.Scanner; /** * 金额转换,阿拉伯数字转换成中国传统形式。例如:101000001010 转换为壹仟零壹拾亿零壹仟零壹拾圆整 * * 扫描一个数转换字符串存进一个数组中 * 定义两个字符数组,分别是零壹贰叁肆伍陆柒捌玖,圆拾佰扦萬拾万佰萬仟萬亿拾亿佰亿仟亿萬亿 * */ public class Test26 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.print("请输入金额:"); String str = sc.nextLine(); System.out.println(getChinese(str)); } public static String getChinese(String str) { String[] str1 = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"}; String[] str2 = {"整圆","拾","佰","扦","萬","拾万","佰萬","仟萬","亿","拾亿","佰亿","仟亿","萬亿"}; StringBuilder sb = new StringBuilder(); char[] chs = str.toCharArray(); for (int i=chs.length-1;i>=0;i--) { } return sb.toString(); } }
package com.gotoheima; /** * 方法中的内部类能不能访问方法中的局部变量,为什么? * * 因为内部类的生存周期比方法中的局部变量长,局部变量再作用域完成后就会被栈内存释放销毁。要想访问局部变量,那么局部变量必须被final修饰。 * */ public class Test27 { }
package com.gotoheima; /** * 有一个类为ClassA,有一个类为ClassB,在ClassB中有一个方法b,此方法抛出异常,在ClassA类中有一个方法a, * 请在这个方法中调用b,然后抛出异常。在客户端有一个类为TestC,有一个方法为c ,请在这个方法中捕捉异常的信息。 * 完成这个例子,请说出java中针对异常的处理机制。 * * java中的异常处理机制,谁调用谁处理,如果一直抛出最终会抛给虚拟机 * */ public class Test28 { public static void main(String[] args) { C.c(); } } class A { public static void a() throws Exception { B.b(); } } class B { public static void b() throws Exception { throw new Exception("b"); } } class C { public static void c() { try { A.a(); } catch(Exception e) { System.out.println("处理"); } } }
package com.gotoheima; import java.lang.reflect.Field; /** * 写一个方法,此方法可将obj对象中名为propertyName的属性的值设置为value. * * public void setProperty(Object obj, String propertyName, Object value) * { * } * * 考点是反射 */ public class Test29 { public static void main(String[] args) { Person p = new Person(); System.out.println(p.name+"---"+p.age); setProperty(p,"name","Hanmeimei"); setProperty(p,"age",19); System.out.println(p.name+"---"+p.age); } public static void setProperty(Object obj,String propertyName,Object value) { try { Field f = obj.getClass().getDeclaredField(propertyName); f.setAccessible(true); f.set(obj, value); f.setAccessible(false); } catch (Exception e) { System.out.println("修改错误"); } } public static class Person { public String name = "Lilei"; private int age = 18; } }
package com.gotoheima; import java.util.LinkedList; /** * 有100个人围成一个圈,从1开始报数,报到14的这个人就要退出。然后其他人重新开始,从1报数,到14退出。问:最后剩下的是100人中的第几个人? * */ public class Test30 { public static void main(String[] args) { final int num = 14; int count = -1; LinkedList<Integer> ll = new LinkedList<Integer>(); for (int i=0;i<100;i++) { ll.add(i+1); } while (ll.size() != 1) { for (int x=1;x<=num;x++) { count ++; if (count>=ll.size()) count = 0; } ll.remove(count); count--; } System.out.print(ll.get(0)); } }