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，遇到
就表示应该换行
* 关闭缓冲区
*
*/
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()+": "+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 == '
')
continue;
if (num == '
')
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()+" 工号："+e.getId()+" 工资："+e.getMoney());
System.out.println("经理姓名："+m.getName()+" 工号："+m.getId()+" 工资："+m.getMoney()+" 奖金："+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]+" ");
}
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()+": "+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 == '
')
continue;
if (num == '
')
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));
}
}