设计数组工具类、日期工具类；线程模拟多窗口售票流程；总结内部类访问方式；区分数值和字符串并排序；猜四位数小游戏

java work week-two

1. 设计可存储不同长度、兼容多种类型数组工具类

可以参照工具类中有的方法来写。

用泛型的：

class ArrayTool<E> {

    private static final int DEFAULT_CAPACITY = 10; // 默认数组空间容量为10
    private Object[] objArr; // 初始数组
    private int size = 0; // 数组中元素个数

    public ArrayTool() {
        objArr = new Object[DEFAULT_CAPACITY];
    }

    public ArrayTool(int capacity) {
        objArr = new Object[capacity];
    }

    // 添加元素
    public boolean add(E element) {

        this.isCapacity(size+1); // 判断数组容量是否够用，不够扩容
        objArr[size++] = element; // 添加元素入数组
        return true;
    }

    // 判断数组容量是否够用
    private void isCapacity(int capacity) {

        if(capacity > objArr.length) { // 若不够用，需要扩容
            this.larger(capacity);
        }
    }

    // 扩容
    private void larger(int capacity) {

        int oldCapacity = objArr.length;
        int newCapacity = oldCapacity + (oldCapacity>>1); // oldCapacty*1.5
        if(newCapacity < capacity) {
            newCapacity = capacity;
        }

        // 扩容后，将就数组的内容复制到新数组空间中
        objArr = this.copyOf(objArr, newCapacity);
    }

    // 复制原数组内容到新数组
    private Object[] copyOf(Object[] oldArray, int capacity) {
        Object[] newArray = new Object[capacity];
        for(int i=0; i<objArr.length; i++) {
            newArray[i] = oldArray[i];
        }
        return newArray;
    }

    // 获取数组中元素
    public E get(int index) {
        this.rangeCheck(index); // 判断索引是否在数组范围内
        return (E)objArr[index];
    }

    // 判断索引是否在数组范围内
    private void rangeCheck(int index) {
        if(index<0 || index>this.size) {
            throw new BoxIndexOutOfBoundsException("your index:" + index + ",the size of the array" + size);
        }
    }

    // 删除元素
    public E remove(int index) {
        this.rangeCheck(index); // 检查索引是否在数组范围内
        E eleDel = (E)objArr[index]; // 要删除的元素

        // 删除元素
        for(int i=index; i<size-1; i++) {
            objArr[i] = objArr[i+1];
        }
        objArr[--size] = null; // 末尾元素清空

        return eleDel;
    }

    // 查看真实数组长度
    public int getLength() {
        return objArr.length;
    }

    // 查看数组中有效元素个数
    public int getSize() {
        return this.size;
    }

    // 查看数组中所有元素
    public void showElement() {
        for(int i=0; i<this.getSize(); i++) {
            System.out.print(objArr[i]+",");
        }
    }
}


// 自定义异常类
class BoxIndexOutOfBoundsException extends RuntimeException{

    public BoxIndexOutOfBoundsException() {}
    public BoxIndexOutOfBoundsException(String msg) {
        super(msg); // msg提供给父类
    }
}


public class OneArray {

    public static void main(String[] args) {

        ArrayTool<Integer> arrInt = new ArrayTool<Integer>(5);
        for(int i=0; i<5; i++) {
            arrInt.add(i);
        }
        System.out.println("length:" + arrInt.getLength() + ",size:" + arrInt.getSize());
        arrInt.showElement();
        arrInt.remove(3);
        System.out.println("length:" + arrInt.getLength() + ",size:" + arrInt.getSize());
        arrInt.showElement();

        System.out.println();

        ArrayTool<Float> arrFloat = new ArrayTool<Float>(5);
        for(int i=0; i<5; i++) {
            arrFloat.add(i+0.05f);
        }
        System.out.println("length:" + arrFloat.getLength() + ",size:" + arrFloat.getSize());
        arrFloat.showElement();
        arrFloat.remove(3);
        System.out.println("length:" + arrFloat.getLength() + ",size:" + arrFloat.getSize());
        arrFloat.showElement();
    }
}

或者用Object的：

import java.util.Arrays;

class MyArrayList {

    private Object[] objects;
    private int size = 0; // 假定的容量
    private int maxSize = 10; // 当前最大容量

    public MyArrayList() {
        objects = new Object[maxSize];
    }

    /**
     * 增（添加数据，注意扩容）
     * @param object
     */
    public void add(Object object) {

        if(size == maxSize) { // 数组扩容
            objects = cloneMax(new Object[maxSize + 10], objects);
        }
        objects[size] = object;
        size++;
    }

    /**
     * 删
     * @param index
     */
    public void remove(int index) {
        if(index < size) {
            for(int i = index; i < size - 1; i++) {
                objects[i] = objects[i + 1];
            }
            size--;
        }
    }

    /**
     * 改
     * @param index
     * @param object
     */
    public void set(int index, Object object) {
        if(index < size) {
            objects[index] = object;
        }
    }

    /**
     * 查，根据下标查询
     * @param index
     * @return
     */
    public Object get(int index) {
        return index < size ? objects[index] : null;
    }

    public Object[] toArray() {
        Object[] temp = new Object[size];
        for(int i = 0; i < temp.length; i++) {
            temp[i] = objects[i];
        }
        return cloneMin(objects, new Object[size]);
    }

    public int size() {
        return size;
    }

    @Override
    public String toString() {
        return Arrays.toString(this.toArray());
    }

    /**
     * 将小的数组中的元素复制进大的数组
     * @param maxArray
     * @param minArray
     * @return
     */
    private Object[] cloneMax(Object[] maxArray, Object[] minArray) {
        for(int i = 0; i < minArray.length; i++) {
            maxArray[i] = minArray[i];
        }
        return maxArray;
    }

    /**
     * 将大的数组中的元素复制进小的数组
     * @param maxArray
     * @param minArray
     * @return
     */
    private Object[] cloneMin(Object[] maxArray, Object[] minArray) {
        for(int i = 0; i < minArray.length; i++) {
            minArray[i] = maxArray[i];
        }
        return minArray;
    }
}


public class OneNeusoft {

    public static void main(String[] args) {
        MyArrayList list = new MyArrayList();
        list.add(3.0f);
        list.add(4.5f);
        System.out.println(list.toString());
    }
}

2.控制台随机输入数值或字符串，区分出数值和字符串，从小到大输出。要求：个数、类型不限；去除重复

import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class TwoNeusoft {

    public static void main(String[] args) {

        Set<Integer> intSet = new HashSet<>();
        Set<String> strSet = new HashSet<>();

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字或字符串（空格分隔，回车提交）：");
        String string = sc.nextLine();
        sc.close();

        String[] str = string.split(" "); // 按空格分隔

        // 数据分类放入set中，去除重复
        for(String s : str) {
            if(s.matches("^-?[0-9]+$")) {
                intSet.add(Integer.parseInt(s));
            } else {
                strSet.add(s);
            }
        }

        Object[] intArray = intSet.toArray();
        Object[] strArray = strSet.toArray();

        Arrays.sort(intArray);
        Arrays.sort(strArray);

        System.out.println("数字排序后：" + Arrays.toString(intArray));
        System.out.println("字符串排序后：" + Arrays.toString(strArray));
    }
}

3.设计日期工具类(兼容jdk5-8)

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;

class DateUtils {

    // 固定格式同final。需要统一格式的，要定好
    public static final String DATE_FORMAT_YMD = "yyyy-MM-dd";

    /**
     * 获得现在时间
     * @return
     */
    // static静态方法，类中被频繁访问的方法用static，可以类名.方法名调用，方便
    public static String now() {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_YMD);
        return sdf.format(new Date());
    }

    /**
     * 默认输出yyyy-MM-dd
     * @param time
     * @return
     */
    public static String formatDateToString(Date time) {
        // Date旧的
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_YMD);
        return sdf.format(time);
    }

    // 完成同一功能的用重载
    public static String formatDateToString(LocalDate localDate) {
        // LocalDate 新的 java8
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern(DATE_FORMAT_YMD);
        return dtf.format(localDate);
    }

    /**
     * 按照指定格式输出
     * @param time
     * @param format
     * @return
     */
    public static String formatDateToString(Date time, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(time);
    }

    public static String formatDateToString(LocalDate localDate, String format) {
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern(format);
        return dtf.format(localDate);
    }

    /**
     * 根据日期获得是星期几
     * @param date
     * @return
     */
    public static String getWeekOfDate(Date date) {

        String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);

        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if(w < 0)
            w = 0;

        return weekDays[w];
    }
}


public class ThreeNeusoft {

    public static void main(String[] args) {
        System.out.println(DateUtils.now());
        System.out.println(DateUtils.getWeekOfDate(new Date()));
    }
}

4.总结内部类访问方式

内部类特性

普通类的访问权限修饰符：
default、public

内部类的访问权限修饰符：
default、public、protected、private

以Outer为外部类，Inner为内部类。

class Outer {
    class Inner {
    }
}

在Outer内访问Inner，只需:

Inner in = new Inner();

在Outer外访问Inner，必须：

Outer o = new Outer(); // 实例化外部类
// 内部类前加前缀，哪个类里的内部类
Outer.Inner oi = o.new Inner(); // 实例化内部类

静态内部类

用static标识的内部类为静态内部类。

静态内部类作为外部类的静态成员，不能访问外部类非静态成员。

非静态内部类只能定义非静态成员，而静态内部类可以定义静态成员和非静态成员。

使用Outer.Inner inn = new Outer.Inner()方式实例化静态内部类。
非静态内部类不可以使用这种方式实例化。

局部内部类

在一个类的方法中或程序块内定义的内部类。

class A{
    int a;
    public void method() {
    }
    // 类中定义的内部类
    class B {
    }
}

class C {
    int a;
    public void method(int c) {
        int b = 0;
        // 局部内部类
        class B {
        }
    }
}

需要写很多代码时，为了方便，使用局部内部类。
局部内部类，调用外面final成员。
局部内部类一般不让其它类调用，只是当前方法用。

还有比较细的版本…

// 内部类指将一个类定义在另一个类的内部。内部类可分为静态内部类、成员内部类、局部内部类和匿名内部类。

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

// 静态内部类定义方法：
class OutClass1{
    static class InnerClass {
    }
}

/*
静态内部类被声明为static的内部类。
它不依赖于外部类实例而被实例化，而通常的内部类需要在外部类实例化后才能实例化。
静态内部类不能与外部类有相同的名字，而且不能访问外部类的普通成员变量，只能访问外部类中的静态成员和静态方法。
 */

// 成员内部类定义方法：
class OutClass2{
    class InnerClass{
    }
}

/*
静态内部类去掉关键字static就变成了成员内部类。
成员内部类可以随便引用外部类的成员变量和方法，无论其实静态和非静态。
但是成员内部类是在外部类实例化后才能够被实例化，因此不可以定义静态的属性和方法。
需要注意的是：非静态内部类中不能有静态成员。
 */

// 局部内部类定义方法：

class OutClass3{
    public void fuctionName(){
        class InnerClass{
        }
    }
}

/*
局部内部类指定义在一个代码块中的类，它的作用范围为所在的代码块，是内部类中最少是用的一种内部类。
局部内部类类似于局部变量，不能被public、protected、private以及static修饰，只能访问方法中定义为final类型的局部变量。
 */

// 匿名内部类
class MyFrame extends Frame { // 外部类
    public MyFrame(){
        addWindowListener(new WindowAdapter(){ // 匿名内部类
            public void windowClosing(WindowEvent e){
                dispose();
                System.exit(0);
            }
        }
        );
    }
}

/* 匿名内部类是一种没有类名的内部类，没有构造函数，它必须继承其他类或者其他接口。
他一般应用于GUI编程中实现事件处理等。
 */

// 内部类与外部类的互访使用小结

// 内部类访问外部类
// 里面的可以自由访问外面的，规则和static一样。（访问非静态时必须先创建对象）

// 非静态内部类的非静态方法-直接访问
class Outter1 {
    int i = 5;
    static String string = "Hello";

    class Inner1{
        void Test1 () {
            System.out.println(i);
            System.out.println(string);
        }
    }
}

// 静态内部类的非静态方法
// 因为静态方法访问非静态外部成员需先创建实例，所以访问i时必须先new外部类
class Outter2 {
    int i = 5;
    static String string = "Hello";

    static class Inner2{
        void Test1 () {
            System.out.println(new Outter2().i);
            System.out.println(string);
        }
    }
}

// 静态内部类的非静态方法
// 因为静态方法访问非静态外部成员需先创建实例，所以访问i时必须先new外部类
class Outter3 {
    int i = 5;
    static String string = "Hello";

    static class Inner2{
        void Test1 () {
            System.out.println(new Outter3().i);
            System.out.println(string);
        }
    }
}

// 静态内部类的静态方法-规则如上
class Outter4 {
    int i = 5;
    static String string = "Hello";

    static class Inner2{
        static void Test2 () {
            System.out.println(new Outter4().i);
            System.out.println(string);
        }
    }
}

// 外部类访问内部类
//大方向：因为将内部类理解为外部类的一个普通成员，所以外部的访问里面的需先new一个对象。

// 非静态方法访问非静态内部类的成员-new 内部类对象
class Outter5 {
    static void Test2() {
        System.out.println(new Outter5().new Inner1().i);
    }
    class Inner1{
        int i = 5;
//      static String string = "Hello"; 定义错误!
    }
}

// 静态方法访问非静态内部类的成员
// 静态方法Test2访问非静态Inner1需先new外部类，继续访问非静态成员i需先new内部类
// 所以访问规则为：new Outter().new Inner1().i。
class Outter6 {
    static void Test2(){
        System.out.println(new Outter6().new Inner1().i);
    }
    class Inner1{
        int i = 5;
//      static String string = "Hello";  定义错误！
    }
}

// 非静态方法访问静态内部类的成员
// 先“外部类.内部类”访问至内部类。
// 若访问非静态成员，则需先new再访问；若访问静态成员，则可直接访问。
class Outter7 {
    void Test2() {
        Outter7.Inner2 inner2 = new Outter7.Inner2();
        System.out.println(inner2.i);
        System.out.println(inner2.string);
        System.out.println(Outter7.Inner2.string);
    }
    static class Inner2{
        int i = 5;
        static String string = "Hello"; // 定义错误!
    }
}

// 非静态方法访问非静态内部类的成员
// 先“外部类.内部类”访问至内部类，再new即可访问静态成员。
class Outter8 {
    void Test1(){
        Outter8.Inner1 inner2 = new Outter8.Inner1();
        System.out.println(inner2.i);
    }
    class Inner1{
        int i = 5;
//        static String string = "Hello"; 定义错误！
    }
}

// 匿名内部类
// 匿名内部类访问外部成员变量时，成员变量前应加final关键字。
// final int k = 6;

5.设计小游戏-控制台输入一个四位不重复数

控制台输入一个四位不重复数。输入数字后，如果数位上给的提示是“A”，说明既猜对了数字，也猜对了数位；如果数位上给的提示是“B”，说明猜对了数字，但数位没猜对；如果数位上给的提示是“—”，那么证明你猜的数字根本不会出现在这个四位数中。

例如： 1234，AB–，说明第一位是1，数字2存在，但不第二位上

要求：四位数后台随机生成，限时一分钟，可猜30次，最终提示成功或失败。

这道题需要我们可爱的多线程啦…

import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.Set;

public class FiveGame {

    private boolean flag = true; //

    /**
     * 得到一个0-9的随机数
     * @return
     */
    private static int getRandomNumber() {
        return (int) ((Math.random() * 100) % 10);
    }

    /**
     * 得到一个四位无重复数字的数
     * @return
     */
    private static String getNumber() {

        Set<Integer> set = new HashSet<Integer>();
        while (true) {
            int a = getRandomNumber();
            set.add(new Integer(a));
            if(set.size() > 3)
                break;
        }

        int index = (int) ((Math.random() * 100) % 4);
        if(index==0) {
            index+=1;
        }

        Integer[] arr = new Integer[set.size()];
        set.toArray(arr);
        String s = "";

        if(arr[0].intValue()==0){ // 如果第一位是0，则随机和后面三位交换
            Integer temp = arr[0];
            arr[0] = arr[index];
            arr[index] = temp;
        }

        for(int i=0;i<arr.length;i++){
            s += arr[i].intValue();
        }

        return s;
    }

    /**
     * 根据用户输入的四位数判断游戏得到的结果
     * @param number 系统生成的四位数
     * @param num 用户输入的四位数
     * @return
     */
    private static String game(String number, String num) {
        String str = "";
        for(int i=0; i<number.length(); i++) {
            str += every(number, num.charAt(i), i);
        }
        return str;
    }

    /**
     *
     * @param number 系统生成的四位数
     * @param a 用户输入四位数中的第i位
     * @param i
     * @return
     */
    private static String every(String number, char a, int i) {
        String c = "";
        int position = number.indexOf(a);
        if(position != -1) {
            if(position == i) {
                return "A";
            } else {
                return "B";
            }
        } else {
            return "-";
        }
    }

    public void startGame() {

        String number = getNumber(); // 系统生成的四位随机数

        Thread thread = new Thread() {

            public void run() {
                System.out.println("Thread");
                Scanner sc = new Scanner(System.in);
                System.out.println("游戏开始！\n请输入四位数：");
                int count = 0;

                while (flag) {

                    if(count >= 30) {
                        System.out.println("次数已用尽...");
                        System.exit(0);
                    }

                    String numStr = String.valueOf(sc.nextInt()); // 用户输入

                    if(game(number, numStr).equals("AAAA")) {
                        System.out.println("恭喜您，猜对了！");
                        System.exit(0);
                    } else {
                        System.out.println(game(number, numStr));
                    }

                    count++;
                }
            }
        }; // end Thread

        thread.start();

        try {
            Thread.sleep(1000 * 60);
            flag = false;
            if(thread.isAlive()) {
                System.out.println("对不起，时间到了，游戏结束");
            }
            System.exit(0);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {

        FiveGame fg = new FiveGame();
        fg.startGame();
    }
}

写的还不完善…（懒得写了）->_->
待改善：用户输入的问题（不是四位不同的数）

附加题：使用线程模拟多窗口售票流程（不可出现重复票）

class SaleTickets implements Runnable {

    private int ticketCount = 100; // 总的票数，进程之间共享
    Object lock = new Object(); // 锁

    /**
     * 卖票，操作共享数据，用同步代码块包裹
     */
    public void sellTicket() {

        synchronized (lock) {
            if(ticketCount > 0) {
                ticketCount--;
                System.out.println(Thread.currentThread().getName() + "正在卖票，还剩" + ticketCount + "张票");
            } else {
                System.out.println("票已卖完！");
                return;
            }
        }
    }

    @Override
    public void run() {

        while(ticketCount > 0) {
            sellTicket();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


public class MoreNeusoft {

    public static void main(String[] args) {

        SaleTickets st = new SaleTickets();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        Thread t4 = new Thread(st, "窗口4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}