JAVA 技术方向支线任务-面向对象高级训练任务

1. 试题：假设用户账号为：admin，密码为 123，编写用户登陆案例。 要求：请将登陆定义为 login 方法， 并将 login 方法写在 UserService 类中

创建User.java，User主要包括用户名和密码两个参数，并在里面创建内部类UserService用于实现login方法，用来判断是否登录成功

public class User {
    private String name;
    private int password;

    public User(){}
    public User(String name, int password) {
        this.name = name;
        this.password = password;
    }
    static class UserService {
        public void login(User user){
            if(user.name.equals("admin") && user.password == 123){
                System.out.println("登录成功!");
            }else{
                System.out.println("登录失败，用户名或者密码不对！");
            }
        }
    }
}

User测试方法：
让用户输入相应用户名密码判断是否正确

public static void main(String args[]){
        //题目1测试
        System.out.println("请输入登录用户名: ");
        Scanner sc = new Scanner(System.in);
        String name = sc.next();
        System.out.println("请输入登录密码: ");
        int password = sc.nextInt();
        User user = new User(name, password);
        User.UserService uus = new User.UserService();
        uus.login(user);
}

2. 试题：设置一个类， 命名为 MyList 类中包含属性：Object[] element 方法有如下几个：

• 增加方法 add ： 可以向数组属性中依次存储 Object，数组内容 存满时，需实现动态扩容（详解在下面）。

• 删除方法 remove ：可以根据数据或下标， 从数组属性中删除 Object 数据，删除后，数组后续元素需前移。

• 查询方法 get ：方法传入下标，返回数组中指定下标的数据。

• 当前存储数据量 size ： 获取当前存储的有效数据长度 动态扩容详解：无需真正增加原数组的容量，只用将原内容复制到新 的大数组，然后让原数组名称重新等于大数组即可。由于原数组数据在堆中， 失去引用会被 GC 自动回收。

MyList.java

import java.util.List;

public class MyList {
    //类的属性
    Object[] element;

    public MyList() {
    }

    public MyList(Object[] element) {
        this.element = element;
    }

    public void setElement(Object[] element) {
        this.element = element;
    }

    public Object[] getElement() {
        return element;
    }

    //add方法，向数组中添加元素
    public void add(String content, int n) {
        if (n == element.length) {
            //创建一个大数组，复制原来数据到新数组中
            Object[] newElement = new Object[element.length * 2];
            for (int i = 0; i < element.length; i++) {
                newElement[i] = element[i];
            }
            newElement[element.length] = new String(content);
            element = newElement;
        } else {
            element[n] = new String(content);
        }

    }

    //remove方法：通过特定元素
    public void remove(Object[] element, Object content) {
        ListHelper lh1 = new ListHelper();
        ListHelper lh2 = new ListHelper(content);
        for(int i=0; i<element.length; i++){
            lh1.setText(element[i]);
            if(lh1.equals(lh2)){
                if(i == element.length-1){
                    element[i] = null;
                    break;
                }else{
                    for(int j=i; j<element.length-1; j++){
                        element[j] = element[j+1];
                    }
                    if(element[element.length-1] != null){
                        element[element.length-1] = null;
                    }
                }
            }
        }
    }

    //remove方法：通过下标删除数据
    public void remove(Object[] element, int index) {
        boolean isRemove = false;
        if (index == element.length - 1) {
            element[index] = null;
            isRemove = true;
        } else {
            for (int i = index; i < element.length - 1; i++) {
                //num后的元素往前移
                element[i] = element[i + 1];
                isRemove = true;
            }
            if (element[element.length - 1] != null) {
                element[element.length - 1] = null;
                isRemove = true;
            }
        }
        if(isRemove){
            System.out.println("成功删去下标为" + index + "的元素");
        }else{
            System.out.println("下标有问题！");
        }

    }

    //查询方法get()
    public Object get(Object[] element, int index) {
        if((index>=0) && (index<=element.length-1)) {
            return element[index];
        }else {
            System.out.println("查询下标超出数组范围！");
            return false;
        }
    }

    //print方法：打印数组
    public void print() {
        System.out.println("当前数组内容如下：");
        for (int i = 0; i < element.length; i++) {
            System.out.print(element[i] + " ");
        }
        System.out.println();
    }
}

由于输入相应的元素要删除是要比较对应元素的值，而不是默认的内存地址，所以需要改写自带的equals()方法，所以创建一个ListHelper.java重写此功能

//ListHelper类用于重写equals方法可以比较字符串
public class ListHelper {

    private Object text;

    public ListHelper() {
        super();
    }

    public ListHelper(Object text) {
        super();
        this.text = text;
    }

    public void setText(Object text) {
        this.text = text;
    }

    public Object getText() {
        return text;
    }

    //重写equals方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        ListHelper other = (ListHelper) obj;
        if (text == null) {
            if (other.text != null)
                return false;
        } else if (!text.equals(other.text))
            return false;
        return true;
    }
}

测试过程如下：

public static void main(String args[]){
//题目2测试
        MyList list = new MyList();
        list.element = new Object[3];

        list.add("123", 0);
        list.add("234", 1);
        list.add("345", 2);
        list.add("456", 3);
        list.add("567", 4);
        //添加元素后输出确认
        list.print();

        System.out.println("删除数组下标为3的元素：");
        list.remove(list.element, 3);
        //输出确认
        list.print();

        System.out.println("删除指定元素345：");
        list.remove(list.element, "345");
        //输出确认
        list.print();

        //查询特定下标元素
        System.out.println("查询下标为1的元素：");
        System.out.println(list.get(list.element, 1));
    }