Exam
第一题：
1、 假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。
* 经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。请使用继承的思想设计出员
* 工类和经理类。要求类中提供必要的方法进行属性访问。
* @author xxx
*
* 分析：
* 1、由于经理也是一个员工，他和普通员工的工作不一样，不同的工作，工作不一样，不确定，设为抽象类，
* 这时我们可以将经理和普通员工的继承与一个员工类。这样普通员工类和经理还可以具有自己的特有方法。
* 2、定义三个类：员工类（Employees）和经理类（Manager）、普通员工(GeneralEmployee),
* GeneralEmployees、Manager通过extends继承Employees，那么子类就拥有了父类中除了私有以外的所有属性和方法。
* 3、由于对象打印得到的是地址值(String除外)，为了方面查看打印输出效果，复写Employee类toString()方法
*/
public class Test1 {
public static void main(String[] args) {
//创建一个经理对象并实例化
Manager manager=new Manager("库克","001",10000,10000);
//创建普通员工对象并初始化
GeneralEmployee generalEmployee=new GeneralEmployee("xxx","1002",8000);
//查看经理的信息
System.out.println("经理:"+manager);
//查看员工的信息
System.out.println("员工:"+generalEmployee);
}
}
//创建一个员工类
abstract class Employees{
private String name; //姓名属性
private String id; //工号
private double salar; //工资
//空参数构造函数
public Employees() {
}
//有参构造函数进行初始化对象
public Employees(String name, String id, double salar) {
this.name = name;
this.id = id;
this.salar = salar;
}
//set、get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//一般来说工号是唯一的，所以我们不能修改，故没有set()
public String getId() {
return id;
}
public double getSalar() {
return salar;
}
public void setSalar(double salar) {
this.salar = salar;
}
//为了方便查看打印信息，重写toString
@Override
public String toString() {
return "[name=" + name + ", id=" + id + ", salar=" + salar
+ "]";
}
//强制员工都要工作
public abstract void work();
}
//普通员工类
class GeneralEmployee extends Employees{
//空参数
public GeneralEmployee()
{}
//有参构造函数，进行初始化
public GeneralEmployee(String name,String id,double salar)
{
super(name,id,salar);
}
//建立自己的特有工作
@Override
public void work() {
System.out.println("这位员工的姓名是："+getName()+" 工号的："+getId()+" 工资是："+getSalar());
System.out.println("他的工作是洗碗");
}
}
//经理类
class Manager extends Employees
{
private double Bonus; //经理的特有奖金属性
//空参数构造函数
public Manager() {
}
//有参构造函数,进行初始化
public Manager(String name, String id, double salar,double Bonus) {
super(name, id, salar);
this.Bonus=Bonus;
}
@Override
public void work() {
System.out.println("这位员工的姓名是："+getName()+" 工号的："+getId()+" 工资是："+getSalar()+" 他还另外有奖金："+Bonus);
System.out.println("他的工作是负责全面的工作监督");
}
}
package com.itheima;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
/**
* 2、 取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ，输出格式为：a(2)b(1)k(2)...
* @author xxx
*
*/
public class Test2 {
public static void main(String[] args) {
String str = "abcdekka27qoq";
System.out.println("字符串"+str);
System.out.println(charCount(str));
}
public static String charCount(String str) {
//转换成数组，利用数组的思想来操作字符串
char[] chs = str.toCharArray();
//加入泛型限定数据类型，第一个参数是字符类型，第二个参数是整型
Map<Character, Integer> m = new TreeMap<Character, Integer>();
int count = 0;
//遍历数组
for (int x = 0; x < chs.length; x++) {
if (chs[x] >= 'a' && chs[x] <= 'z' || chs[x] >= 'A' && chs[x] <= 'Z') {
//得到key所对应的value
Integer value = m.get(chs[x]);
if (value != null)
count = value;
count++;
m.put(chs[x], count);
count = 0;
}
}
//保存从集合中迭代出来的字母和次数
StringBuilder sb = new StringBuilder();
//迭代map集合
Iterator<Entry<Character, Integer>> it = m.entrySet().iterator();
while (it.hasNext()) {
//去除集合中的每一个Entry对象
Map.Entry<Character, Integer> me = it.next();
//去除Entry对象中的key、value加入到sb集合中
sb.append(me.getKey() + "(" + me.getValue() + ")");
}
return sb.toString();
}
}
package com.itheima;
import java.util.ArrayList;
/**
* 3、 分析运行结果，说明原理。(没有分析结果不得分)，代码如下：
* @author xxx
*
*/
class Data {
int val;
}
public class Test3 {
public static void main(String args[]) {
Data data = new Data();
ArrayList<Data> list = new ArrayList<Data>();
for (int i = 100; i < 103; i++) {
data.val = i;
list.add(data);
}
for (Data d : list) {
System.out.println(d.val);
}
}
}
/*
运行结果:
102
102
102
原理:
首先，需要明确一点，集合操作的是对象，存储的是对象的引用。 在本程序中，内存里只存在一个data对象。
ArrayList集合中存储一个data对象，当用for循环向集合list中的对象data遍历赋值时，只会改变data对象的值，
而后者会覆盖前者，最后一次赋值的值是102。由于集合中存储的引用始终不改变，只改变了对象的值，List集合可以重复
存储对象，遍历的过程中，每一次赋值，又存储一次，最终打印了三个对象的的值，list存储的三个对象都是同一个引用，
只是反复存储了三次而已，所以最后输出是3个换行的102。
*/
package com.itheima;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* 4、 写一个方法，此方法可将obj对象中名为propertyName的属性的值设置为value.
public void setProperty(Object obj, String propertyName, Object value){
}
* @author xxx
*
*/
class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Test4 {
public static void main(String[] args) {
try {
User user = new User();
// 通过内省写入name的值
String propertyName = "name";
Object value = "zhangsan";
setProperty(user, propertyName, value);
// 通过内省写入age的值
propertyName = "age";
value = 21;
setProperty(user, propertyName, value);
// 打印出结果
System.out.println(user.getName());
System.out.println(user.getAge());
} catch (Exception e) {
e.printStackTrace();
}
}
private static void setProperty(Object user, String propertyName,
Object value) throws IntrospectionException,
IllegalAccessException, InvocationTargetException {
PropertyDescriptor pd;
pd = new PropertyDescriptor(propertyName, user.getClass());
Method methodSetName = pd.getWriteMethod();
methodSetName.invoke(user, value);
}
}
package com.itheima;
import java.util.ArrayList;
import java.util.List;
/**
* 5、 编写程序，生成5个1至10之间的随机整数，存入一个List集合，编写方法对List集合进行排序
* （自定义排序算法，禁用Collections.sort方法和TreeSet），然后遍历集合输出。
* @author xxx
*
*/
public class Test5 {
public static void main(String[] args) {
//调用addList方法添加随机数，返回一个集合
List<Integer> list=addList();
//对集合进行排序
sort(list);
//遍历集合
for (Integer in : list) {
System.out.println(in);
}
}
/**
* 冒泡排序
* @param list 排序list
*/
private static void sort(List<Integer> list) {
int len = list.size();
int temp = 0;
for (int i = 0; i < len; i++) {
for (int j = i + 1; j < len; j++) {
if (list.get(i) > list.get(j)) {
temp = list.get(i);
list.set(i, list.get(j));
list.set(j, temp);
}
}
}
}
/**
* 自定义集合添加随机数
* @return 集合
*/
private static List<Integer> addList() {
//创建集合
List<Integer> list=new ArrayList<Integer>();
//循环5次，添加5个对象
for (int i = 0; i < 5; i++) {
//产生随机数
int sum=(int)(Math.random()*10)+1;
//添加入集合
//list.add(new Integer(sum));装箱
list.add(sum);//自动装箱
}
return list;
}
}
package com.itheima;
/**
* 6、 编写三各类Ticket、SealWindow、TicketSealCenter分别代表票信息、售票窗口、售票中心。
* 售票中心分配一定数量的票，由若干个售票窗口进行出售，利用你所学的线程知识来模拟此售票过程。
*
* @author xxx
*
*/
public class Test6 {
public static void main(String[] args) {
Ticket tt = new Ticket();
TicketSealCenter tc = new TicketSealCenter(tt);
SealWindow w1 = new SealWindow(tt);
SealWindow w2 = new SealWindow(tt);
SealWindow w3 = new SealWindow(tt);
SealWindow w4 = new SealWindow(tt);
new Thread(tc).start();
new Thread(w1).start();
new Thread(w2).start();
new Thread(w3).start();
new Thread(w4).start();
}
}
// 创建票的类，每张给一个ID
class Piao {
int id;
Piao(int id) {
this.id = id;
}
public String toString() {
return "piao: " + id;
}
}
class Ticket {// 创建售票信息
int index = 0;
Piao[] arrp = new Piao[100];
public synchronized void set(Piao p) {// 提供给票的方法，用锁解决线程安全问题
while (index == arrp.length) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
arrp[index] = p;
index++;
}
public synchronized Piao get() {// 对外提供取票的方法，解决线程同步问题
while (index == 0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("票已售欣，请稍后在试。。。。");
}
this.notifyAll();
index--;
return arrp[index];
}
}
class SealWindow implements Runnable {// 售票窗口调用取票的方法
Ticket tc = null;
SealWindow(Ticket tc) {
this.tc = tc;
}
public void run() {
for (int i = 0; i < 20; i++) {
Piao p = tc.get();
System.out.println("窗口剩余票：" + p);
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class TicketSealCenter implements Runnable {// 售票中心发布一定数量的票
Ticket tc = null;
TicketSealCenter(Ticket tc) {
this.tc = tc;
}
public void run() {
for (int i = 0; i < 100; i++) {
Piao p = new Piao(i);
tc.set(p);
System.out.println("售票中心已发布票：" + p);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
package com.itheima;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.TreeSet;
/**
* 7、 把以下IP存入一个txt文件，编写程序把这些IP按数值大小，从小到达排序并打印出来。 61.54.231.245 61.54.231.9
* 61.54.231.246 61.54.231.48 61.53.231.249
*
* @author xxx
*
* 分析：本题涉及IO流读取文本数据，正则表达式，字符串排序的相关知识 1、定义一个字符读取流从指定的txt中读取IP数据
* 2、将读取到的IP数据转换为字符串，然后进行排序
* IP地址分为4段，每一段的最大位数是3，先将最低位补齐(在前面补0)，补完后由于有的地址段已经超过3位，
* 再进行处理，将前面多余的0去掉，保留3位。此时得到的IP每一段都是3位的，将得到的IP地址排序
* 排序方法可将字符串转换成数组，利用工具类Arrays.sort排序 也可以将IP地址存入到TreeSet中排序
*
*/
public class Test7 {
public static void main(String[] args) {
// 从txt文件中读取IP地址
String str = getIp();
// 对ip地址进行排序
Mysort(str);
}
public static void Mysort(String str) {
// 第一次替换，给所有的地址段前补两个0，
str = str.replaceAll("(\\d+)", "00$1");
// 第二次替换，去除地址段前多余的0，让每一段都是3位
str = str.replaceAll("0*(\\d{3})", "$1");
// 读取的IP地址字符串中带有换行符，就以换行符来切割字符串，
// windows中的换行符为\r\n,正则表达式中\都以成对的形式出现，所以切割规则为\\r\\n
String[] arr = str.split("\\r\\n");
// 排序方法一
// 调用数组工具类的sort方法对数组排序
Arrays.sort(arr);
// 遍历数组，打印排序后的IP地址
for (int i = 0; i < arr.length; i++) {
// 第三次替换，排序后的IP地址段中有的前面有多余无效的0，将其去掉
System.out.println(arr[i].replaceAll("0+(\\d+)", "$1"));
}
// 定义分割付区分两种不同排序方式打印的结果
System.out.println("----------------------------");
// 排序方法二
// 通过TreeSet集合进行排序
TreeSet<String> set = new TreeSet<String>();
// 迭代取出切割后的IP地址字符串将其添加到TreeSet集合中
for (String ip : arr) {
set.add(ip);
}
// 遍历set集合，打印排序后的IP地址
for (String s1 : set) {
// 第三次替换，排序后的IP地址段中有的前面有多余无效的0，将其去掉
System.out.println(s1.replaceAll("0+(\\d+)", "$1"));
}
}
public static String getIp() {
// 定义一个字符读取流，读取txt中的IP
BufferedReader bfr = null;
// 定义一个字符串用来存储读取到IP字符串数据
String line = null;
try {
//指定文件路径，这里可以相对也可以绝对路径
bfr = new BufferedReader(new FileReader("IP.txt"));
// 定义字符缓冲数组
char[] buf = new char[1024];
int len = 0;
while ((len = bfr.read(buf)) != -1) {
// 将读取到的字符数据赋给line
line = new String(buf, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 判断流是否为空，若不为空则关闭字符读取流
if (bfr != null) {
try {
// 调用close方法关闭流对象
bfr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 返回IP字符串数据
return line;
}
}
package com.itheima;
/**
* 8、 分析以下程序运行结果，说明原理。(没有分析结果不得分)
* public class ThreadTest {
* public static void main(String args[])
* {
* MyThread t = new MyThread();
* t.run();
* t.start();
* System.out.println("A");
* }
* }
*
* class MyThread extends Thread
* {
* public void run()
* {
* try
* {
* Thread.sleep(3000);
* } catch (InterruptedException e)
* { }
* System.out.println("B");
* }
* }
*
* @author xxx
*
*/
public class Test8 {
public static void main(String args[]) {
MyThread t = new MyThread();
t.run();
t.start();
System.out.println("A");
}
}
class MyThread extends Thread {
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
}
System.out.println("B");
}
}
/*运行的结果应该是：
B
A
B
分析：
1、t.run() 是调用MyThread里的方法run()执行run方法打印B。
2、t.start() 是启动线程MyThread, 执行run(),执行时遇到线程休眠3000毫秒，这段时间该线程让与其他线程先执行，故打印A，
3、睡眠时间结束后继续执行线程打印出B。
*/
package com.itheima;
/**
* 9、 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
* 1 2 3 4
* 12 13 14 5
* 11 16 15 6
* 10 9 8 7
*
* @author xxx
*
*/
public class Test9 {
public static void main(String[] args) {
arrayNum(4);
}
// 便于改代码..输入不同y值输出不同的二维数列
private static void arrayNum(int y) {
int[][] arr = new int[y][y];
int n = arr.length;
int max = 0;
int c = 0;
specArr(arr, n, max, c);
arrPrint(arr);
}
// 高级for输出打印用的
private static void arrPrint(int[][] h) {
for (int[] in : h) {
for (int t : in) {
if (t < 10)
System.out.print(" " + t + " ");
else
System.out.print(t + " ");
}
System.out.println();
}
}
// 利用递归,一层一层写进去..
private static void specArr(int[][] arr, int n, int max, int count) {
if (n > 0) {
int j = 0;
for (int i = 0; i < (n - 1) * 4; i++) {
if (i < n - 1)
arr[0 + count][i + count] = ++max;
else if (i < 2 * n - 2)
arr[count + j++][arr.length - 1 - count] = ++max;
else if (i < 3 * n - 3)
arr[arr.length - 1 - count][(j--) + count] = ++max;
else if (i < 4 * n - 4)
arr[arr.length - 1 - (j++) - count][0 + count] = ++max;
}
if (n == 1) {
arr[arr.length / 2][arr.length / 2] = max + 1;
}// 注意到 当y值为奇数时,会有循环到n=1的情况,需要补进数组最中间值
count++;
n -= 2;
specArr(arr, n, max, count);
}
}
}
package com.itheima;
/**
* 10、 金额转换，阿拉伯数字转换成中国传统形式。
* 例如：101000001010 转换为 壹仟零壹拾亿零壹仟零壹拾圆整
*
* @author xxx
* 分析：
* 1.创建一个转换的方法实现转换
* 2.在转换方法中实现将阿拉伯形式转换成中国传统形式
* 3.去零操作
* 4.正则表达式替换操作
*/
public class Test10 {
public static void main(String[] args){
//测试数据是否正确
System.out.println(convertNumber(101000001010L));
}
//转换方法,
public static String convertNumber(long number){
//定义字符数组存储中国数字写法格式
final char[] chineseNumber = new char[]
{ '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' };
//定义字符数组存储中国数字的单位
final char[] units = new char[]
{ '圆', '拾', '佰', '仟', '万', '拾', '佰', '仟', '亿', '拾', '佰', '仟'};
//定义一个字符串缓冲区对字符进行存储
StringBuilder sb = new StringBuilder();
int index=0;
long lastNumber = 0;
while(number!=0){
lastNumber = number%10;
sb.insert(0,units[index++]);
sb.insert(0,chineseNumber[(int) lastNumber]);
number=number/10;
}
//去零操作，通过正则表达式
return sb.toString().replaceAll("零[拾佰仟]","零").replaceAll("零+亿","亿").replaceAll("零{4}万","零").
replaceAll("零+万","万").replaceAll("零+圆","圆").replaceAll("零+","零")+"整";
}
}
package com.itheima;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Test11 {
public static void main(String[] args) {
System.out.println("测试题目的测试数据的转换情况：" + convert("101000001010"));
//以下是从键盘输入金额数字，并查看打印结果
String data = getData();//调用自定义函数从键盘获取输入
String str = convert(data);//调用函数对金额进行转换
System.out.println("转换后的中文金额形式：" + str);//打印转换后的结果
}
/**
* 完成金额转换：从阿拉伯数字到中文大写字符形式（转换万亿以内的金额）
* @param str 阿拉伯数字金额的字符串表示形式
* @return 金额的中文大写字符串表示形式
*/
public static String convert(String str) {
final char[] num = {'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'}; // 定义大写中文数字的字符数组
final char[] unit = {'圆','拾','佰','仟','万','拾','佰','仟','亿','拾','佰','仟'}; // 定义金额单位字符数组
str = str.replaceAll("^0+", "");//去除整数前多余的0
if(str.equals("")){
return "零圆整";//如果去除整数前多余的0后，结果为空串，表明输入的整数为0，直接返回:"零圆整"
}
StringBuilder sb = new StringBuilder();// 字符串的临时容器，存储转换后的中文金额
int len = str.length();
if(len > 12)
throw new RuntimeException("金额太大，无法表示，只能表示万亿以内");
// 从字符串的尾部开始遍历，每次取一个单位和一个对应大写数字依次插入临时容器的头部。
for (int i = 0; i <= len - 1; i++) {
sb.insert(0, unit[i]);// 取一个单位符插入临时容器的首部
int val = str.charAt(len - i - 1) - '0';// 获取每位上对应的阿拉伯数字
sb.insert(0, num[val]); // 获取阿拉伯数字对应的中文字符，并插入到临时容器的首部
}
//使用正则表达式对金额的大写表示形式按要求格式化
return sb.append("整").toString().replaceAll("零[仟佰拾]", "零").replaceAll("零+万", "万").
replaceAll("零+亿", "亿").replaceAll("亿万", "亿零").replaceAll("零+", "零").replaceAll("零圆", "圆");
}
/**
* 完全从键盘获取数字的输入
* @return 获取到的字符串
*/
public static String getData(){
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//为了提供读取效率加入缓冲技术
String line = null;//存储从键盘录入的金额数字
System.out.println("请输入一串数字：");
try {
while ((line = br.readLine()) != null) {
//判断输入的是否为数字，否则重新输入
if (line.matches("[0-9]+"))//采用正则表达式判断是否为数字
break;//输入正确则推出循环
else {
System.out.println("数据格式有误，请重新输入一串数字：");//输入有误，则重新输入，至此输入正确为止。
}
}
} catch (IOException e) {
System.out.println("发送IO异常，从键盘读取数据出问题了！");
} finally {
try {
if (br != null) {
br.close();//关闭流
}
} catch (IOException e) {
System.out.println("关闭键盘输入流出错！");
}
}
return line;//返回获取到的字符串
}
}
package com.itheima;
/**
* 1、 假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。
* 经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
* 请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
* ...............
* @author Administrator
*
*/
public class Test1 {
public static void main(String[] args) {
//----测试-------
//员工
Employees e=new Employees("吉泽明步",1,1000.11f);
e.desc();
//经理
Boss b=new Boss("黑马立姐-经理",99,30000.28f);
b.setReward(4000.12f); //设置奖金
b.desc();
}
}
/**
* 抽象类:
*/
abstract class Person{
protected String name; //姓名
protected int Numbers; //工号
protected float salary; //工资
public Person(String name, int numbers, float salary) {
this.name = name;
this.Numbers = numbers;
this.salary = salary;
}
public void desc(){
System.out.println("员工姓名："+name+"; 员工工号："+Numbers+"; 员工工资："+salary);
}
}
/**
* 员工类:
*/
class Employees extends Person{
//构造方法：
public Employees(String name, int numbers, float salary) {
//调用父类的构造方法：提供了必要的方法进行属性访问
super(name, numbers, salary);
}
public void desc(){
System.out.println("员工姓名："+name+"; 员工工号："+Numbers+"; 员工工资："+salary);
}
}
/**
* 经理类
*/
class Boss extends Person{
private float reward; //奖金
public Boss(String name, int numbers, float salary) {
//调用父类的构造方法：提供了必要的方法进行属性访问
super(name, numbers, salary);
this.setReward(reward);
}
// get/set方法 来获取和设置 ：- 奖金值 -
public float getReward() {
return reward;
}
public void setReward(float reward) {
this.reward = reward;
}
public void desc(){
System.out.println("员工姓名："+name+"; 员工工号："+Numbers+"; 员工工资："+salary+"; 本经理奖金是："+reward);
}
}
package com.itheima;
/**
* 2、 方法中的内部类能不能访问方法中的局部变量，为什么？
*
* @author Administrator
*
*/
public class Test2 {
public static void main(String[] args) {
/**以下是具体的说明：------
(1)所谓“局部内部类”就是在对象的方法成员内部定义的类。而方法中的类，访问同一个方法中的局部变量，却必须要加上一个 【final】。
(2)原因是编译程序实现上的困难：内部类对象的生命周期会超过局部变量的生命期。
局部变量的生命期：当该方法被调用时，该方法中的局部变量在栈中被创建，当方法调用结束时，退栈，这些局部变量全部死亡。
内部类对象生命期：与其它类一样，当创建一个局部内部类对象后，只有当没有其它人再引用它时，它才能死亡。
所以完全可能一个方法已调用结束（局部变量已死亡），但该局部类的对象仍然活着。
【即：局部类的对象生命期会超过局部变量。】
(3)局部内部类的对象访问同一个方法中的局部变量，那么这就要求只要局部内部类对象还活着，那么栈中的那些它要访问的局部变量就不能“死亡”（否则：它都死了，还访问个什么呢？）。
这就是说：局部变量的生命期至少等于或大于局部内部类对象的生命期。
(4)解决方法：局部内部类的对象可以访问同一个方法中被定义为【final】的局部变量。定义为【final】后，
编译程序的实现方法：将所有的局部内部类对象要访问的final型局部变量，都拷贝成为该内部类对象中的一个数据成员。
这样，即使栈中局部变量（含final）已死亡，但由于它是【final】,其值永不变，因而局部内部类对象在变量死亡后，照样可以访问【final】型局部变量。(这一点我有些怀疑)
(5)--个人总结：--
一个类中的内部类，其实这个内部类相对这个类就和以他方法和属性一样的。只是内部类的生命周期和这个类的属性生命周期是不同的。
在内存中，类的属性会被分配到栈中的。当调用结束的时候就会退栈，也就是说在内存中这个属性就消失了。内部类也是类，只用在内存中对他的引用消失了才会死亡的内部类，
这个时候内部类调用类中已经结束调用的属性是不可能的。【也就是说:局部类的生命周期超过了类的局部变量。】
*：就是在局部变量前加上【final】，这样类中属性就会被分配在堆内存中，局部变量的生命周期就至少大于或者等于方法中的内部类，其内部类就可以调用了。
*/
Inners s=new Inners();
s.intersout("吉泽明步");
}
}
/**
* 例子说明
*/
class Inners{
private String name; //name属性
//正如上面提到的(注意以下两点)：
//1：方法内部类只能 -- 定义该方法内部类的方法内部实例化，不可以在此方法外对其实例化（因为作用域 就是在这里面）
//2：方法内部类对象不能使用该内部类所在的【非final局部变量和参数】
//方法内部类
public void intersout(final String name){ //内部类访问这个属性时 这必须：final修饰
final int age=12; //必须使用final
class inters{
public void talk(){
System.out.println("姓名是："+name+"; 年龄是："+age);
}
}
inters ins=new inters(); //方法内部实例化
ins.talk();
}
}
package com.itheima;
/**
* 3、 请说明Java中字符'\'的含义，有什么作用？
* @author Administrator
*
*/
public class Test3 {
public static void main(String[] args) {
/**
* --- 老师这是我的理解：'\'---
* 1：转义字符的：在计算机科学与远程通信中，转义字符是这样一个字符，通过 \ 来转变后面字母或符号的含义。
* 标志着在一个字符序列中出现在它之后的后续几个字符采取一种替代解释。
2： 从功能上来理解，其实很简单，有些特殊字符，不能直接用一个特定的符号来表示，比如TAB字符('\t')，
* 比如字符结束符('\0')，这些是没法通过正常手段来表示的，转义字符的出现，使得字符的表达能力更加强大了。
*
3：在java中及其其他语言的 转义字符大致有以下：
1.\n 回车(\u000a)
2.\t 水平制表符(\u0009)
3.\b 空格(\u0008)
4.\r 换行(\u000d)
5.\f 换页(\u000c)
6.\' 单引号(\u0027)
7.\" 双引号(\u0022)
8.\\ 反斜杠(\u005c)
9.\ddd 三位八进制
10.\udddd 四位十六进制
*/
}
}
package com.itheima;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* 4、 编写一个类，在main方法中定义一个Map对象（采用泛型），加入若干个对象，然后遍历并打印出各元素的key和value。
* @author Administrator
*
*/
public class Test4 {
public static void main(String[] args) {
Integer i1=new Integer(1);
Integer i2=new Integer(2);
Integer i3=new Integer(3);
Integer i4=new Integer(4);
Persons p1=new Persons("波多野结衣",26);
Persons p2=new Persons("小泽玛利亚",28);
Persons p3=new Persons("松岛枫",32);
Persons p4=new Persons("武藤兰",34);
//Map对象（采用泛型）
Map<Integer,Persons> mp=new HashMap<Integer,Persons>();
//加入若干个对象
mp.put(i1,p1);
mp.put(i2,p2);
mp.put(i3,p3);
mp.put(i4,p4);
//遍历并打印出各元素的key和value
Set<Integer> ketset=mp.keySet();
Iterator<Integer> iter=ketset.iterator();
while(iter.hasNext()){
Integer key=iter.next();
Persons value=mp.get(key);
System.out.println("键是："+key+"，值是："+value);
}
}
}
/**
* 人类
*/
class Persons{
private String name;
private int age;
public Persons() {
super();
}
public Persons(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Persons [name=" + name + ", age=" + age + "]";
}
}
package com.itheima;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
/**
* 5、 统计一个文本文件中字符出现的次数，结果存入另外的一个文本文件中。例如：
a： 21 次
b： 15 次
c： 15 次
把： 7 次
当： 9 次
前： 3 次
，：30 次
* @author Administrator
*
* 思路：
* （1）从文件中读取字符
* （2）将字符存入TreeMap中，进行默认排序（字母和次数对应关系）
* （3）将map中元素写到文件中
*
*/
public class Test5 {
public static void main(String[] args) {
try {
//构建一个---字符输出(写)缓冲---对象
BufferedReader bur= new BufferedReader(new FileReader("E:\\zuocao\\读取.txt"));
//构建一个TreeMap集合---用来存统计的
TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
String lines=null;
/*
* 输入流每读取一行，就将改行转换为字符数组，并遍历数组，将其存入TreeMap中
* 当TreeMap中以包含当前字母则将其值+1再存入，否则将值设为1存入
*/
while((lines=bur.readLine())!=null){
char[] chars=lines.toCharArray(); //每一行转换为字符数组
for(int i=0;i<chars.length;i++){
if(tm.containsKey(chars[i])){ //判断这个键里 【有无这个字符】
tm.put(chars[i], tm.get(chars[i])+1); //如果有 对应的值就+1
}else{
tm.put(chars[i], 1);
}
}
}
/*
*以上完成全部字符存入TreeMap，接下来，遍历TreeMap集合，将其写入文件中
*/
BufferedWriter buw= new BufferedWriter(new FileWriter("E:\\zuocao\\写入.txt"));
//遍历TreeMap集合
Set<Entry<Character,Integer>> sets=tm.entrySet();
Iterator<Entry<Character,Integer>> iter=sets.iterator();
while(iter.hasNext()){
Entry<Character,Integer> entry=iter.next();
Character ch=entry.getKey(); //得到键
Integer in=entry.getValue(); //得到值
buw.write(ch+"："+" ；"+in+"次"); //指定格式写入缓冲区
buw.newLine(); //另起一行
buw.flush(); //刷新数据
}
//关闭流
bur.close();
buw.close();
System.out.println("---【统计】并【存入另外的一个文本文件中】完成，请老师查阅-----");
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
}
}
}
package com.itheima;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
/**
* 6、 存在一个JavaBean，它包含以下几种可能的属性：
1:boolean/Boolean
2:int/Integer
3:String
4:double/Double
属性名未知，现在要给这些属性设置默认值，以下是要求的默认值：
String类型的默认值为字符串 www.itheima.com
int/Integer类型的默认值为100
boolean/Boolean类型的默认值为true
double/Double的默认值为0.01D.
只需要设置带有getXxx/isXxx/setXxx方法的属性，非JavaBean属性不设置，请用代码实现
* @author Administrator
*
*
*
*我的设计思路：
创建一个JavaBean类，通过反射进行对其中的未知属性名的变量赋值。
A：拿到字节码文件，建立一个空构造函数的实例对象。
B：利用字节码作为参数，Introspector.getBeanInfo(JavaBean.class)得到BeanInfo实例对象。
C：通过BeanInfo的方法，beanInfo.getPropertyDescriptors()拿到该字节码的所有属性描述。
D：通过PropertyDescriptor--属性描述实例对象，通过调用getWriteMethod()方法，修改字节码中属性的值。
E：在通过属性描述中getPropertyType()方法，定位是那种类型的成员变量，筛选出后，进行相应的修改赋值。
*
*
*/
// 创建一个JavaBean类
public class Test6{
public static void main(String[] args) throws Exception {
//拿到该类字节码
Class<JavaBean> clazz=JavaBean.class;
//拿到字节码的一个对象实例
Object obj=clazz.newInstance();
//通过字节码拿到BeanInfo实例对象
BeanInfo beanInfo=Introspector.getBeanInfo(clazz);
//通过BeanInfo拿到这个字节码的所有属性描述
PropertyDescriptor[] pds=beanInfo.getPropertyDescriptors();
//通过属性描述对象拿到属性对应的set方法和get方法，通过set方法进行属性赋值
for(PropertyDescriptor pd:pds){
//拿到当前属性的set方法
Method setMethod=pd.getWriteMethod();
Method getMethod=pd.getReadMethod();
//拿到当前属性的类型字节码
Class<?> properclass=pd.getPropertyType();
//通过字节码来筛选出相应的属性，再对应赋值,赋值完毕后，通过打印get方法查看赋值情况。
if(properclass==String.class){
//设置String类型的默认值为字符串 www.itheima.com
setMethod.invoke(obj, "www.itheima.com");
System.out.println(getMethod.invoke(obj));
}else if(properclass==int.class || properclass==Integer.class){
//设置int/Integer类型的默认值为100
setMethod.invoke(obj, 100);
System.out.println(getMethod.invoke(obj));
}else if(properclass==Boolean.class || properclass==boolean.class){
//设置boolean/Boolean类型的默认值为true
setMethod.invoke(obj, true);
System.out.println(getMethod.invoke(obj));
}else if(properclass==Double.class || properclass==double.class){
//设置double/Double的默认值为0.01D.
setMethod.invoke(obj, 0.01D);
System.out.println(getMethod.invoke(obj));
}
}
}
}
class JavaBean{
//成员变量
private boolean flag;
private int number;
private String itcast;
private double money;
//成员变量相应的set和get方法
public void setItcast(String newitcast){
itcast=newitcast;
}
public String getItcast(){
return itcast;
}
public void setNumber(int newnumber){
number=newnumber;
}
public int getNumber(){
return number;
}
public void setFlag(boolean newflag){
flag=newflag;
}
public boolean getFlag(){
return flag;
}
public void setMoney(double newmoney){
money=newmoney;
}
public double getMoney(){
return money;
}
}
package com.itheima;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
/**
* 7、 自定义字符输入流的包装类，通过这个包装类对底层字符输入流进行包装，
* 让程序通过这个包装类读取某个文本文件（例如，一个java源文件）时，能够在读取的每行前面都加上有行号和冒号。
* @author Administrator
*
*/
public class Test7 {
public static void main(String[] args) throws Exception{
File file=new File("E:\\JiGeFengShu.java");
//实例化包装类对象
Methods M=new Methods();
//调用包装类对象---方法
M.open(file);
}
}
/**
* 创建包装类
*/
class Methods{
public void open(File file) throws Exception {
//创建字符输入(读取)流
FileReader fRr=new FileReader(file);
//创建字符输入(读取)缓冲流
BufferedReader bRr=new BufferedReader(fRr);
String line=null;
int i=1; //行号标记
while((line=bRr.readLine())!=null){
System.out.println(i+":"+line);
i++;
}
//关闭流
bRr.close();
fRr.close();
}
}
package com.itheima;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/**
* 8、 已知一个类，定义如下：
package cn.itcast.heima;
public class DemoClass {
public void run()
{
System.out.println("welcome to heima!");
}
}
(1) 写一个Properties格式的配置文件，配置类的完整名称。
(2) 写一个程序，读取这个Properties配置文件，获得类的完整名称并加载这个类，用反射 的方式运行run方法。
* @author Administrator
*
*/
public class Test8 {
public static void main(String[] args) throws Exception {
//创建一个读取配置文件（键=值）的对象
Properties prop = new Properties();
//将读取的file.properties配置文件 读取到InputStream流中
InputStream IPS =Test8.class.getResourceAsStream("file.properties");
prop.load(IPS);//加载 : 把读取流添加到读取配置文件的对象中
String className = prop.getProperty("className");//获取key对应的value值
Class<?> c = Class.forName(className);//通过反射的方式获取该类的字节码文件
Method method = c.getMethod("run");//获取反射的方法
method.invoke(c.newInstance());//运行方法。
}
}
/**
已知一个类
*/
class DemoClass {
public void run()
{
System.out.println("welcome to heima!");
}
}
package com.itheima;
import java.util.Arrays;
/**
* 9、 在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，
* 如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。
* 要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入的数组为null，应抛出IllegalArgumentException异常。
* 在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，例如，字符不存在，字符存在，传入的数组为null等。
* @author Administrator
*
*/
public class Test9 {
public static void main(String[] args) {
//定义一个字符数组
char[] chars=new char[]{'我','是','一','个','A','V','女','优'};
Student s=new Student();
/******* 方法一：******/
int result1=s.search1(null,'个'); //1：如果传入的数组为null：抛出IllegalArgumentException异常
System.out.println("result3:"+result1);
int result2=s.search1(chars,'个'); //2：如果传入的某个字符 存在 字符数组中： 返回第一次出现的位置
System.out.println("存在返回脚标:"+result2);//result1:0
int result3=s.search1(chars,'苍'); //3：如果传入的某个字符 不存在 字符数组中： 返回-1
System.out.println("不存在返回:"+result3);
/******* 方法二：******/
s.search2(null,'个'); //1：如果传入的数组为null：抛出IllegalArgumentException异常
s.search2(chars,'个'); //2：如果传入的某个字符 存在 字符数组中： 返回第一次出现的位置
s.search2(chars,'苍'); //3：如果传入的某个字符 不存在 字符数组中： 返回-1
}
}
//编写一个类
class Student{
//搜索【一个字符数组中是否存在某个字符】的方法
/******* 方法一：******/
public int search1(char[] chars,char c){
if(chars==null){ //如果数组为空，抛出异常
throw new IllegalArgumentException("传入的数组：一个不合法或不正确的参数");
}else{
//遍历数组，得到脚标，或找到返回空
for(int i=0;i<chars.length;i++){
if(c==chars[i]){
return i;
}
}
}
return -1; 字符不存在 返回-1;
}
/******* 方法二：******/
@SuppressWarnings("unused")
public int search2(char[] chars,char c){
if(chars==null){
throw new IllegalArgumentException("传入的数组：一个不合法或不正确的参数");
}else if(chars!=null){
String str=new String(chars); //传入字符数组来 【定义一个新字符串实例】
int numbers=str.indexOf(c); //查找 某个字符第一次出现的位置
System.out.println(numbers);
return numbers; //返回 某个字符第一次出现的位置
}
return -1; //字符不存在 返回-1;
}
}
package com.itheima;
/**
* 10、 28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，
* 又需要买多少瓶可乐？（需写出分析思路）
*
* @author Administrator
* 我的思路：
当拿3个可乐瓶盖去换一瓶可乐,就多了一瓶可乐同时又多了一个瓶盖。(即三个可乐瓶可以换1瓶可乐和一个瓶盖)
再买两瓶可乐,拿3个可乐瓶盖去换取一瓶可乐同时多了一个瓶盖。
循环...直到所有人都能喝到一瓶可乐为止。
我的步骤：
//定义一个获取可乐瓶数的方法，传入人数
1. public static int countCokes(int num);
//通过上面的分析，开始计算需要的可乐数目。
2. for(int i=0;i<num;i++){
if(cap==3){
cap = 1;
}else{
sum++;
cap++;
}
}
*/
public class Test10 {
public static void main(String[] args) {
System.out.println("28人喝可乐，需要购买----"+countCola(28)+"瓶可乐");
System.out.println("50人喝可乐，需要购买----"+countCola(50)+"瓶可乐");
}
//购买可乐方法
public static int countCola(int num){ //传入要喝的人的数量
//瓶盖数
int cap = 0;
//我们需要购买瓶数
int sum = 0;
for(int i=0;i<num;i++){
if(cap==3){
//每当3个瓶盖可以换1瓶可乐和一个瓶盖
cap = 1;
}else {
//我们购买一瓶
sum++;
//同时多一个可乐瓶
cap++;
}
}
//返回需要购买的瓶数
return sum;
}
}
Test
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapTest {
/**
* 在main方法中定义一个Map对象（采用泛型），加入若干个对象，然后遍历并打印出各元素的key和value
*/
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<Integer, String>();
// 添加元素
map.put(10, "张三");
map.put(20, "李四");
map.put(30, "王五");
map.put(30, "赵六");
// 取出集合中的元素
Set<Integer> keySet = map.keySet();
Iterator<Integer> it = keySet.iterator();
while (it.hasNext()) {
// 取键
Integer key = it.next();
// 通过键用get()方法取出值
String value = map.get(key);
System.out.println(key + "," + value);
}
Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
Iterator<Map.Entry<Integer, String>> it1 = entrySet.iterator();
while (it1.hasNext()) {
Map.Entry<Integer, String> me = it1.next();
int key = me.getKey();
String value = me.getValue();
System.out.println(key + "," + value);
}
}
}
/**
*一道打印1-100，遇到7就跳过
*/
public class SevenJump {
public static void main(String[] args) {
print(100,7);
}
//判断是否含有指定的数
public static boolean seven(int num,int jump){
boolean flag = false;
while(num>0){
int t = num%10;//取出个位
//if(t == 7){
if(t == jump){
flag = true;
break;
}else{
num = num/10;//依次取出其他位（如十位、百位...）
}
}
return flag;
}
//遇到7就跳过
public static void print(int num,int jump){
for(int i = 1;i <= num;i++){
boolean b = seven(i,jump);
if(!b){
System.out.print(i+" ");
}
}
}
}
import java.util.Scanner;
/**
* 1、判断一个字符串是否是对称字符串，
* 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
* @author Administrator
*
*/
public class Test1 {
public static void main(String[] args) {
boolean mrk = true;
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String st = sc.next();
int length = st.length();
//判断前一半与后一半的是否相等
for (int i = 0, j = length-1; i < length/2; i++, j--) {
if(st.charAt(i) != st.charAt(j)) {
mrk = false;
break; //退出循环
}
}
System.out.printf("%s", mrk==true ? "对称" : "不对称"); //三元表达式输出结果
}
}
package com.itheima;
/**
* 2：Collection和Collections有什么关系？List和Set有什么异同点？Map有哪些常用类，各有什么特点？
* @author Administrator
*
*/
public class Test2 {
/**
* (一)Collection和Collections有什么关系？
Collection是java.util下的接口，也是集合类的父接口，继承与他的接口主要有 Set集合 和 List集合
Collections是个java.util下的类，是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、查找、排序、取出集合中的最大值，最小值、线程安全化等等操作。此类不能实例化，就像一个工具类，服务于Java的Collection框架。
(二)List和Set有什么异同点？
相同点：都是继承Collection集合下的接口。
不同点：List集合： 1：有序的(元素存入集合的顺序和取出的顺序一致)。
2：元素可以存储重复。
Set集合： 1：无序的(存入和取出顺序有可能不一致)。
2：不可以存储重复元素必须保证元素唯一性。
(三)Map有哪些常用类？各有什么特点？
Map有四种常用类，分别是HashMap，HashTable，TreeMap，LinkedHashMap
HashMap特点：
效率高，允许空值，线程安全/不同步。
默认的哈希表大小:16 默认的加载因子：0.75。
每次重新散列的方式：原数组的长度*2。
[HashMap、HashTable、LinkedHashMap自定义对象]必须是重写：hashcode方法和equal方法。
HashTable特点：
效率低，不允许空值，线程安全/同步。
默认的初始容量：11 默认的加载因子：0.75。
TreeMap特点：
所有元素保持一个固定的顺序，可用于Map集合中元素排序，不允许键对象是null。
便于插入、删除操作。
[自定义对象]必须实现：Comparable/Comparator接口。
LinkedHashMap特点：
保证有序的(元素存入集合的顺序和取出的顺序一致)，其使用的是（双重链表）哈希表和链表列表维护其顺序。
---------------：其他集合知识点补充 ：--------------------------------------------------------------------------
(1) Map集合存储和Collection有着很大不同：
1：Collection一次存一个元素；Map一次存一对元素。
2：Collection是单列集合；Map是双列集合。
3：Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系，要保证map集合中键的唯一性。
(2) Iterator 遍历迭代接口：
对集合遍历的方式：
1：Iterator (使用率高)
2：ListIterator (只针对List集合)
3：Enumeration (很少使用)
4：forearch (遍历每次会产生对象，造成内存浪费)
(3)【 ---Itarator迭代--- 】
Boolean hasNext() 如果仍有元素可以迭代判断[有无下一个元素]，则返回true
E Next() 返回迭代的下一个元素
Collection迭代 例子：
Iterator<String> iter=C.iterator();
while(iter.hasNext()){
String s=iter.next();
System.out.println(s);
}
Map迭代 例子：
Collection<V> values() 返回此映射中包含的 [值的 Collection 视图]。
Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的 [映射关系的 Set 视图]。
-----第一种遍历方式：通过Map中所有的Key对象的set集合，就可以用Iterator遍历...... Set<K> keySet() 返回此映射中包含的[键的 Set 视图]。
Set<Integer> keyset=maps.keySet();
Iterator<Integer> iter=keyset.iterator();
while(iter.hasNext()){
Integer key=iter.next(); //获取每一个key值
String value=maps.get(key); //根据获取到的每一个key值找到对应的value值。
System.out.println("key："+key+"---------->value："+value);
}
-----第二种遍历方式：通过Map中所有的value对象的Collection集合，就可以用Iterator遍历-----
System.out.println("----------第二种遍历方式-------------");
Collection<String> value=table.values();
Iterator<String> itr=value.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
-----第三种遍历方式：通过 Set<Map.Entry<K,V>> entrySet() ，就可以用Iterator遍历-----------
Set<Entry<String,String>> entrySet=linkedhashmapa.entrySet();
Iterator<Entry<String,String>> iyer=entrySet.iterator();
while(iyer.hasNext()){
Entry<String,String> entry=iyer.next();
System.out.println("key："+entry);
}
*/
}
package com.itheima;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* 3：创建ArrayList对象，添加5个元素，使用Iterator遍历输出
* @author Administrator
*
*/
public class Test3 {
public static void main(String[] args) {
ArrayLists(); //调用
}
public static void ArrayLists(){
//值得注意的是：集合必须指定--->泛型的类型 < >
List<String> list=new ArrayList<String>(); //创建ArrayList对象
//添加5个 [String类型] 元素
list.add("苍井空");
list.add("波多野结衣");
list.add("武藤兰");
list.add("小泽玛利亚");
list.add("吉泽明步");
//Iterator遍历 输出
Iterator<String> iter=list.iterator();
while(iter.hasNext()){
String s=iter.next();
System.out.println(s); //输出
}
}
}
package com.itheima;
/**
* 4、 编程计算3乘8等于几，什么方法效率更高？
* @author Administrator
*
*/
public class Test4 {
public static void main(String[] args) {
/* ---分析原理：----
我们都知道计算机里面只能做位移或者加法，计算机里是不能直接做乘法或者除法的
计算机底层都是0,1代码，使用位运算就好比是直接操作计算机的底层硬件，
而 [直接乘 ]则是要经过一系列的转换到底层二进制代码执行，
从过程来看，也知道位运算要快一些了，效率是最高的!!
*/
//采用移位运算输出结果
System.out.println("-----编程计算3乘8等于几，什么方法效率更高？----");
System.out.println("3向左移3位 等于 3*(2的3次幂=8)");
System.out.println("结果："+(3<<3));// 左移相当于乘. 左移一位相当于乘2（2^1）;左移两位相当于乘4(2^2);左移三位相当于乘8(2^3);
}
}
package com.itheima;
/**
* 5、 定义一个包含私有成员变量和函数的类，再定义一个内部类，
* 在内部类函数中访问外部成员变量，并调用外部函数。
* 在外部类函数中创建内部类对象，调用内部类函数。
* @author Administrator
*
*/
// 定义一个包含私有成员变量和函数的类 //
public class Test5 {
public static void main(String[] args) {
Test5 F=new Test5(); //外部类函数
F.CallInner(); //外部类的方法
}
private String name="私有成员变量"; //私有成员变量
private void PrivateS(){ //私有成员函数
System.out.println("---私有成员函数---");
}
//再定义一个内部类
class innerclass{
public void Outside (){
System.out.println("name="+name); //访问外部成员变量
PrivateS(); //调用外部函数
}
}
//外部类函数中创建内部类对象
public void CallInner(){
innerclass inC=new innerclass();
inC.Outside(); //调用内部类函数
}
}
package com.itheima;
/**
* 6、 编程打印所有的3位质数，质数特点：只能被1和其本身整除
*
* @author Administrator
* 【质数】概念：
* 如果除了1和它本身外，不能被其他自然数整除（除0以外）的数称之为素数（质数）；否则称为合数。
*/
public class Test6 {
public static void main(String[] args) {
print();//调用
}
//打印所有的3位质数方法
public static void print(){
//3位质数：100-1000之间的质数
for(int i=100;i<1000;i++){
int count=0;//每次遍历的到的质数初始值
for(int j=1;j<Math.round((i+2)/2);j++){ //每一次 i遍历取到的数， 去除以其他自然数整除 每个遍历 Math.round()取整
if(i%j==0){ //取余 判断是不是等于零 做判断来有几个零； 当本数只能是i%1才等于0时才是质数！
count++;
}
}
if(count<2){ //当只有一个一次能整除，那么该数就是质数
System.out.println("3位质数为："+i); //取出值
}
}
}
}
package com.itheima;
/**
* 8、 编写程序，打印1到100之内的整数，但数字中包含7的要跳过，例如：17、27、71、72
* @author Administrator
*
*/
public class Test7 {
public static void main(String[] args) {
for(int i=1;i<=100;i++){ //循环100次
if(i/10!=7 && i%10!=7 && (i<69||i>79)){ //判断条件1-100的数带有7的数全部除去
System.out.print(i+",");
}
}
System.out.println();
System.out.println("----------------------为了方便看以上取出来的数据，我每隔 循环7次 换行输出数据-------------------");
Number();
}
public static void Number(){
int b=1; //定义每次换行的位置初始值
for(int j=1;j<=100;j++){ //循环100次
if(j/10!=7 && j%10!=7 && (j<69||j>79)){ //判断条件1-100的数带有7的数全部除去
//打印出需要的值
if(j==100){
System.out.print(j); //去掉100最后的逗号
}else{
System.out.print(j+",");
}
b++; //每循环一次 +1
if(b%7==0){ //设置 每隔 循环7次 换行
System.out.println("\n"); //换行
}
}
}
}
}package com.itheima;
/**
* 7、 编写一个延迟加载的单例设计模式。
* @author Administrator
*
*/
public class Test8 {
public static void main(String[] args) {
//测试
singleton1 S1=singleton1.getInstance();
singleton1 S2=singleton1.getInstance();
S1.print();
System.out.println("单例设计模式 -- 懒汉式 ：如果S1对象和S2对象为true说明都返回同一个对象："+(S1==S2));
}
}
//原理分析：
//单例设计模式分两种：一种是懒汉式，一种是饿汉式。
//其中 [懒汉式]---就是---【 延迟加载的单例设计模式】
class singleton1{
/**** 懒汉式 ****/
//第一步：构造方法私有化
private singleton1(){}
//第二步：定义一个本类对象；并且实例化 null；
private static singleton1 S=null;
//第三步：给外部提供一个静态方法，获取对象实例
public static singleton1 getInstance(){
if(S==null){
S=new singleton1(); //对象先不实例化，什么时候用，什么时候实例化，这就是延迟的意思
}
return S;
}
public void print(){
System.out.println("延迟加载的单例设计模式------>懒汉式");
}
}
/*********懒汉式：值得注意的是：在多线程访问时会有线程安全问题*******/
// 上例这个地方
// if(S==null){
// S=new singleton1();
// }
// 可以修改成这样---【双重判断对象的引用进行判断，加入同步更安全】--：
// if(S==null){
// synchronized (S) { // //懒汉式多线程容易出问题 ，加双重判断解决了这个问题
// if(S==null)
// S=new singleton1();
// }
// }
// 补充 一个： 饿汉式
class singleton2{
/**** 懒汉式 ****/
//第一步：构造方法私有化
private singleton2(){}
//第二步：定义一个本类对象实例
private static singleton2 S1=new singleton2();
//第三步：给外部提供一个静态方法，获取对象实例
public static singleton2 getInstance(){
return S1;
}
public void print(){
System.out.println("延迟加载的单例设计模式------>饿汉式");
}
}
package com.itheima;
import java.io.*;
import java.text.*;
import java.util.Date;
/**
* 9、 编写程序，该程序启动后用户可以按“yyyy-MM-dd”的格式输入一个日期，程序计算这一天是星期几，并且计算出是一年中的第几天。
*/
//首先：先判断是否闰年，在利用swtch（）的break；得出每个偶数月份和奇数月份的出现的次数，然后相加，最后一定要加最后一个月的天数。
//星期的判定是利用DateFormat和Data中的特有的方法；
public class Test9 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
System.out.println("开始输入日期: 格式如下yyyyMMdd");
int month = 0,day = 0;
long year = 0;
//从键盘读取数据，建立转换流
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
String s = null;
StringBuffer sb = new StringBuffer();
while((s = bf.readLine())!=null){
//年数
year = Integer.valueOf(s.substring(0,4));
if(Integer.valueOf(s.substring(4,5)) == 0){
//月数
month = Integer.valueOf(s.substring(5,6));
}
else{
if(Integer.valueOf(s.substring(4,6)) <= 12)
month = Integer.valueOf(s.substring(4,6));
else{
System.out.println("月份输入错误");
}
}
//当前月天数
day = Integer.valueOf(s.substring(6));
//调用Day方法算出天数
System.out.println(year+"--"+month+"--"+day+"");
System.out.println("一年中的第"+Day(year,month,day)+"天");
WeekDay(s);
}
}
public static void WeekDay(String day){
String[] str ={"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
DateFormat df = new SimpleDateFormat("yyyyMMdd");//日期格式化辅助类
Date d = new Date();
try{
d = df.parse(day);//格式化日期
}catch(ParseException e){
e.printStackTrace();
}
for(int i=0;i<str.length;i++){
if(d.getDay()==(i)){ //根据取出来的数判断取数组下标
System.out.println(str[i]);
}
}
}
//计算月份 值得注意的是：闰年
public static int Day(long year,int month,int day){
int dateSum1 = 0;
for (int i = 1; i < month; i++){
switch(i){
//当月份为1,3,5,7，8，,10,12时，自动加31天
case 1: case 3: case 5: case 7: case 8: case 10:
case 12:dateSum1 += 31; break;
//当月份为4,6,9,11时，自动加30天
case 4: case 6: case 9: case 11:dateSum1 += 30; break;
case 2:
// 判断是否为闰年,如果是加29，否加28
if(((year % 4 == 0) & (year % 100 != 0)) | (year % 400 == 0))
dateSum1 += 29;
else dateSum1 += 28;
}
}
return dateSum1+day;
}
}
/**
* 取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ，输出格式为：a(2)b(1)k(2)...
*
* 思路：字母与它出次的次数形成映射关系，所以可以使用Map集合来存储，键存储字母，值存储字母出现的次数
*/
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class StringCharNum {
public static void main(String[] args) {
String str = "ywonv4o5woiayooxaakolvlnbboxie2";
//取出一个字符串中字母出现的次数
findNum(str);
}
private static void findNum(String str) {
Map<Character,Integer> map = new TreeMap<Character,Integer>();//定义集合来存储元素
//取出字符串中
for(int i = 0;i < str.length();i++){
//判断字符串中的每一个字符是否为字母
char ch = str.charAt(i);
if((ch>='a' && ch<='z')||(ch>='A' && ch<='Z')){
//取出键的值，判断它是否已经存在
Integer value = map.get(ch);
if(value == null){
value = 0;
map.put(ch, ++value);
}else{
//新值替换旧值
map.put(ch, ++value);
}
}
}
//迭代输出map集合中的元素
Set<Character> keySet = map.keySet();//键的Set图
Iterator<Character> it = keySet.iterator();
while(it.hasNext()){
char key = it.next();
//通过键值获取值
int value = map.get(key);
System.out.print(key+"("+value+")");
}
}
}
package practice1;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
public class Demo1 {
public static void main(String[] args) throws IOException {
Comparator<Student> com = Collections.reverseOrder(); // 自定义一个比较器
File fi = new File("c:\\stu.txt"); // 指定文件目录.定义在外面更好一些,提高扩展.
Set<Student> se = StudnetIn(com, false); // 将比较器传入方法以及排序方式..返回一个集合.
ToFile(se, fi); // 将集合和file传入.
}
// 对于集合进行遍历,获取对象元素.并输出到指定文件.
public static void ToFile(Set<Student> se, File fi) throws IOException {
Iterator<Student> it = se.iterator();
FileWriter fw = new FileWriter(fi);
while (it.hasNext()) {
Student s = it.next();
fw.write(s.toString() + s.getMax() + "\t" + "\r\n");
}
fw.close();
}
// 传入比较器以及排序需求.如果是true,就是默认排序,否则就是自定义的排序.
public static Set<Student> StudnetIn(Comparator<Student> com, boolean bo) {
Scanner s = new Scanner(System.in);
Set<Student> se = null;
if (bo == true) // 自然排序.
{
se = new TreeSet<Student>();
} else // 自定义排序(也就是定义的倒序)
{
se = new TreeSet<Student>(com);
}
while (true) {
String ss = s.nextLine();
if (ss.equals("over")) // 输入结束指令.
{
System.out.println("输入结束");
break;
} else {
// 切割,并将字符串和角标传递给student对象,并存入集合中.
String[] str = ss.split(",");
se.add(new Student(str[0], Double.parseDouble(str[1]), Double
.parseDouble(str[2]), Double.parseDouble(str[3])));
}
}
return se;
}
}
// 定义一个实现Comparable的学生对象.
class Student implements Comparable<Student> {
private String name;
private Double ch;
private Double ma;
private Double en;
private Double max;
Student(String name, Double ch, Double ma, Double en) // 参数直接收语文,数学,英语,为什么?
{
this.name = name;
this.ch = ch;
this.ma = ma;
this.en = en;
this.max = ch + ma + en; // 总成绩是算出来的,不是传入的.
}
public int compareTo(Student stu) // 重写compareTo方法.
{
// 在这里要注意:谁是关键的?我们要比较什么?----成绩是关键的.
int i = new Double(this.max).compareTo(new Double(stu.max));
if (i == 0) // 只有成绩相等,再去比较名字.
return this.name.compareTo(stu.name);
return i;
}
public int hashCode() // 重写hashCode方法.
{
return (int) (this.name.hashCode() + this.max * 66);
}
public boolean equals(Student stu) // 重写equals方法.
{
return this.name.equals(stu.name) && this.max == stu.max;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getCh() {
return ch;
}
public void setCh(Double ch) {
this.ch = ch;
}
public Double getMa() {
return ma;
}
public void setMa(Double ma) {
this.ma = ma;
}
public Double getEn() {
return en;
}
public void setEn(Double en) {
this.en = en;
}
public Double getMax() { // 只想对外提供总成绩的get,而不提供set,为什么?
return max;
}
@Override
public String toString() {
return "Student [name=" + name + ", ch=" + ch + ", ma=" + ma + ", en="
+ en + "]";
}
}
package practice1;
public class Demo2 {
public static void main(String[] args) {
// System.out.println(new Date());
Thread mythred = new Thread(new myThread());
Thread mythred2 = new Thread(new myThread());
mythred.start();
mythred2.start();
for (int i = 0; i <50; i++) {
System.out.println("nini");
}
}
}
class myThread extends Thread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 200; i++) {
try {
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+"hello world");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
GUI
Component
import util.FrameUtil;
/**
* 非容器组件
*
* 注册页面
*
* */
public class Demo1 {
public static void main(String[] args) {
//创建一个注册页面窗口
JFrame frame = new JFrame();
//创建面板
Panel panel = new Panel();
//向面板中添加非容器组件
//用户名
JLabel name=new JLabel("用户名：");
//创建文本框并设置列数
JTextField nameField=new JTextField(12);
panel.add(name);
panel.add(nameField);
//设置颜色
panel.setBackground(Color.pink);
//设置窗体大小
FrameUtil.init(frame,300,300);
frame.add(panel);
}
}
Jframe
/*parentComponent： 对话框的所有者
message: 对话框显示的内容
title ： 对话框的标题
messageType: 对话框的类型， 消息对话框，、警告对话框、 错误对话框...*/
public class Demo1 {
public static void main(String[] args) {
JFrame frame=new JFrame("窗体");
//设置大小
frame.setSize(300, 300);
//设置位置,居中显示
frame.setLocationRelativeTo(null);
//消息对话框
JOptionPane.showMessageDialog(frame, "你好吗？", "消息对话框", JOptionPane.INFORMATION_MESSAGE);
//警告对话框
JOptionPane.showMessageDialog(frame, "警告你", "警告对话框", JOptionPane.WARNING_MESSAGE);
//错误对话框
//确认对话框
JOptionPane.showConfirmDialog(frame, "是否要卸载", "你确认要卸载？", JOptionPane.INFORMATION_MESSAGE);
//输入对话框
String str=JOptionPane.showInputDialog("请输入金额");
System.out.println(str);
}
}
public class JFrameDemo {
private static Dimension dimension;
public static void main(String[] args) {
//创建 一个窗体(都是初始化不可见的，需设置是否可见性)
JFrame frame=new JFrame();
//设置标题
frame.setTitle("创建窗体");
//设置大小
frame.setSize(300,300);
//设置位置,居中对齐
frame.setLocationRelativeTo(null);
//获取分辨率来设置位置
//获取方法
//init(frame, 300, 300);
//设置可见性
frame.setVisible(true);
//设置关闭事件，否则程序并未关闭
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
//设置通过获取分辨率来设置位置及窗体大小
public static void init(Frame frame,int width,int heigth) {
//获取工具包对象
Toolkit toolkit=Toolkit.getDefaultToolkit();
//获取分辨率
dimension = toolkit.getScreenSize();
int x=(int)dimension.getWidth();
int y=(int)dimension.getHeight();
//设置窗体大小及位置
frame.setBounds((x-width)/2, (y-heigth)/2, width, heigth);
}
}
package Test;
import util.FrameUtil;
public class OpenDialog {
public static void main(String[] args) {
JFrame jFrame = new JFrame("打开文件框");
String str=null;
JTextField textField=new JTextField(12);
JButton jButton = new JButton("搜索");
JTextArea textArea = new JTextArea();
//布局
FlowLayout flowLayout = new FlowLayout();
jFrame.setLayout(flowLayout);
jFrame.add(textField);
jFrame.add(jButton);
jFrame.add(textArea);
FrameUtil.init(jFrame, 300, 300);
}
}
package util;
public class FrameUtil {
//设置窗体的属性（分辨率）
public static void init(JFrame frame,int width,int heigth) {
//获取工具包
Toolkit toolkit=Toolkit.getDefaultToolkit();
//获取分辨率
Dimension d=toolkit.getScreenSize();
int x=(int)d.getWidth();
int y=(int)d.getHeight();
frame.setBounds((x-width)/2, (y-heigth)/2, width, heigth);
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
