Java基础笔记-优快云博客

本文链接：https://blog.youkuaiyun.com/huangmingtxf/article/details/107497492

这篇博客详细记录了Java的基础知识，包括希尔排序和快速排序的实现，二分查找算法的讲解，封装的Bank系统例题，static关键字的应用，以及哥德巴赫猜想在接口中的应用。通过实例和测试展示了每个概念的实际操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java基础笔记

1 笔记链接
2 语言基础
- 2.1 难点
3 数组
4 三大特性
- 4.1 封装的Bank系统例题
5 三个关键字
- 5.1 static
6 接口
- 6.1 哥德巴赫猜想

1 笔记链接

java基础脑图笔记

2 语言基础

2.1 难点

public class Test{
	public static void main(String[] args){
		int a = 20;
		int b = 20;
		for (int i = 0 ; i < 10 ; i++){
			a = a++;
		}
		for (int i = 0 ; i < 10 ; i++){
			b = ++b;
		}
		System.out.println("a:" + a + ";b:" + b);
	}	
}

答案

a:20;b:30

答案详解

3 数组

3.1 希尔排序

定义一个变量gap,gap的初始大小为数组的长度int gap = arr.length;，每次while循环，gap/=2，然后进入for循环，循环次数是gap次for (int i = 0; i < gap; i++) {}。在这个for循环里面进行插值排序，插值排序的for循环初始值为外面for循环的变量值+gap,当插值排序的for循环变量小于数组的长度时，此变量每次增加gapfor (int j = i + gap; j < arr.length; j += gap) {}，定义一个局部变量int t = arr[j],定义数组索引int index = j - gap，判断当索引大于或者等于0并且arr[index] > t时把索引为index 的值赋给索引为 index + gap ，直到 index >= 0 && arr[index] > t不成立，arr[index + gap] = t;当gap = 1的时候，排序就完成了。

希尔排序的代码：

public static int[] shellSort(int[] arr) {
     int gap = arr.length;
     while (true) {
         gap /= 2;
         for (int i = 0; i < gap; i++) {
             for (int j = i + gap; j < arr.length; j += gap) {
                 int t = arr[j];
                 int index = j - gap;
                 while (index >= 0 && arr[index] > t) {
                     arr[index + gap] = arr[index];
                     index -= gap;
                 }
                 arr[index + gap] = t;
             }
         }
         if (gap == 1) {
             break;
         }
     }
     return arr;
 }

测试数组：

int[] arr = {1, 8, 7, 6, 2, 9, 0, 3, 5, 4};

结果：

原数组：
1 8 7 6 2 9 0 3 5 4 
排序后：
0 1 2 3 4 5 6 7 8 9

3.2 快速排序

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。从数列中挑出一个元素，称为 “基准”（pivot）；重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

public static int[] quikeSort(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        int pivot = arr[start];
        while (i < j) {
            while (i < j && pivot < arr[j]) {
                j--;
            }
            arr[i] = arr[j];
            i++;

            while (i < j && pivot > arr[i]) {
                i++;
            }
            arr[j] = arr[i];
            j--;
        }
        arr[i] = pivot;

        if (i - 1 > start) {
            quikeSort(arr, start, i - 1);
        }
        if (j + 1 < end) {
            quikeSort(arr, j + 1, end);
        }

        return arr;
    }

测试数组：

int[] arr = {1, 8, 7, 6, 2, 9, 0, 3, 5, 4};

结果：

原数组：
1 8 7 6 2 9 0 3 5 4 
排序后：
0 1 2 3 4 5 6 7 8 9

3.3 二分查找

二分查找要求数组必须是有序的。也可以叫折半查找，定义一个变量int low = 0;,定义第二个变量int upper = arr.length - 1;,当low <= upper 时一直进行while循环，循环内定义一个变量int mid = (low + upper) / 2;，用mid下标所在的值和需要查找的值比较，min下标的值大，upper = mid - 1;,mid下标的值小，low = mid + 1;，

public static int bainarySearch(int[] arr,int num){
        int low = 0;
        int upper = arr.length - 1;
        while (low <= upper){
            int mid = (low + upper) / 2;
            if (arr[mid] > num){
                upper = mid - 1;
            }else if (arr[mid] < num){
                    low = mid + 1;
            }else {
                return mid;
            }
        }
        return -1;
    }

4 三大特性

4.1 封装的Bank系统例题

User类

/**
 * @Author mingx
 * @Date 2020/7/24 17:16
 **/
public class User {
    private int cardNo;
    private String identity;
    private String username;
    private String password;
    private String phone;
    private double balance;

    public User() {
    }

    public User(int cardNo, String identity, String username, String password, String phone, double balance) {
        this.cardNo = cardNo;
        this.identity = identity;
        this.username = username;
        this.password = password;
        this.phone = phone;
        this.balance = balance;
    }

    public int getCardNo() {
        return cardNo;
    }

    public void setCardNo(int cardNo) {
        this.cardNo = cardNo;
    }

    public String getIdentity() {
        return identity;
    }

    public void setIdentity(String identity) {
        this.identity = identity;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

Bank类

/**
 * @Author mingx
 * @Date 2020/7/24 17:24
 **/
public class Bank {

    private static User[] users = new User[6];

    static {
        users[0] = new User(10001, "学生", "hm", "1111", "13688888888", 10000);
        users[1] = new User(10002, "学生", "zzp", "1111", "13688888888", 10000);
        users[2] = new User(10003, "学生", "lq", "1111", "13688888888", 10000);
        users[3] = new User(10004, "学生", "chw", "1111", "13688888888", 10000);
        users[4] = new User(10005, "学生", "da", "1111", "13688888888", 10000);
        users[5] = new User(10006, "学生", "lz", "1111", "13688888888", 10000);
    }

    //登录
    public User login(String username, String password) {
        User user = null;
        for (int i = 0; i < users.length; i++) {
            if (users[i].getUsername().equals(username) && users[i].getPassword().equals(password)) {
                user = users[i];
            }
        }
        return user;
    }


    //存款
    public int save(double money, User user) {
        if (money <= 0) {
            return -1;
        } else {
            user.setBalance(user.getBalance() + money);
            return 1;
        }
    }

    //查看余额
    public double query(User user) {
        return user.getBalance();
    }

    //取款
    public int withDraw(double money, User user) {
        if (money <= 0 || money > user.getBalance()) {
            return -1;
        } else {
            user.setBalance(user.getBalance() - money);
            return 1;
        }
    }

    //转账
    public int trans(User fromUser, String toUsername, double money) {
        for (int i = 0; i < users.length; i++) {
            if (users[i].getUsername().equals(toUsername)) {
                User toUser = users[i];
                if (money <= 0 || money > fromUser.getBalance()) {
                    return 0;
                } else {
                    fromUser.setBalance(fromUser.getBalance() - money);
                    toUser.setBalance(toUser.getBalance() + money);
                    return 1;
                }
            }
        }
        return -1;
    }

    //修改密码
    public void modifyPassword(User user, String newPassword) {
        user.setPassword(newPassword);
    }


}

业务逻辑层

/**
 * @Author mingx
 * @Date 2020/7/25 10:53
 **/
public class Service {

    private static Bank bank = new Bank();

    //登录功能
    public User loginJudge(String username, String password) {
        User user = bank.login(username, password);
        if (user != null) {
            System.out.println("登陆成功！");
            return user;
        } else {
            System.out.println("登录失败，请重新登录！");
            return null;
        }
    }

    //存钱功能
    public void saveJudge(double moeny, User user) {
        int save = bank.save(moeny, user);
        if (save == -1) {
            System.out.println("您的存款金额输入有误！");
            System.out.println("您的余额为" + bank.query(user));
        } else {
            System.out.print("存入成功，您的余额为：");
            System.out.println(bank.query(user));
        }
    }

    //取钱功能
    public void withDrawJudge(double money, User user) {
        int take = bank.withDraw(money, user);
        if (take == -1) {
            System.out.println("取款数目输入有误！");
            System.out.println("您的余额为" + bank.query(user));
        } else {
            System.out.print("取款成功，您的余额为：");
            System.out.println(bank.query(user));
        }
    }

    //查看余额
    public void query(User user) {
        double query = bank.query(user);
        System.out.print("您的余额为：");
        System.out.println(bank.query(user));
    }

    //转账
    public void trans(User fromUser, String toUsername, double moeny) {
        int trans = bank.trans(fromUser, toUsername, moeny);
        if (trans == -1) {
            System.out.println("对方账户不存在！");
        } else if (trans == 0) {
            System.out.println("请输入正确的金额数目！");
        } else {
            System.out.print("转账成功！您的余额为：");
            System.out.println(bank.query(fromUser));
        }
    }

    //修改密码
    public void modifyPassword(User user, String newPassword){
        bank.modifyPassword(user, newPassword);
        System.out.print("修改密码成功，新密码是：");
        System.out.println(user.getPassword());
    }


}

测试类

/**
 * @Author mingx
 * @Date 2020/7/24 17:38
 **/
public class TestBank {
    public static void main(String[] args) {

        Service service = new Service();
        User user = null;
        Scanner scanner = new Scanner(System.in);

        do {
            System.out.println("-----------用户登录------------");
            System.out.print("请输入用户名：");
            String username = scanner.next();
            System.out.print("请输入密码：");
            String password = scanner.next();
            user = service.loginJudge(username,password);
        } while (user == null);

        while (true) {
            System.out.println("============欢迎进入ATM机系统================");
            System.out.println("-------1.存款   2.取款   3.转账   4.查询余额   5.修改密码   0.退出----");
            System.out.print("请输入业务选项：");
            int choose = scanner.nextInt();
            switch (choose) {
                case 1:
                    System.out.print("请输入存钱的数目：");
                    double saveMoney = scanner.nextDouble();
                    service.saveJudge(saveMoney,user);
                    break;
                case 2:
                    System.out.print("请输入取款的数目：");
                    double takeMoney = scanner.nextDouble();
                    service.withDrawJudge(takeMoney, user);
                    break;
                case 3:
                    System.out.print("请输入对方的用户名：");
                    String toUsername = scanner.next();
                    System.out.print("请输入转账金额：");
                    double moeny = scanner.nextInt();
                    service.trans(user,toUsername,moeny);
                    break;
                case 4:
                    service.query(user);
                    break;
                case 5:
                    System.out.print("请输入新密码：");
                    String newPassword = scanner.next();
                    service.modifyPassword(user,newPassword);
                    break;
                case 0:
                    System.out.println("祝您生活愉快,下次再见!");
                    return;
                default:
                    System.out.println("输入有误，请重新输入！");
                    break;
            }
            System.out.println();
        }
		
    }
}

测试结果：

-----------用户登录------------
请输入用户名：hm
请输入密码：1111
登陆成功！
=============================欢迎进入ATM机系统==============================
-------1.存款   2.取款   3.转账   4.查询余额   5.修改密码   0.退出----
请输入业务选项：1
请输入存钱的数目：1
存入成功，您的余额为：10001.0

-------1.存款   2.取款   3.转账   4.查询余额   5.修改密码   0.退出----
请输入业务选项：2
请输入取款的数目：1
取款成功，您的余额为：10000.0

-------1.存款   2.取款   3.转账   4.查询余额   5.修改密码   0.退出----
请输入业务选项：3
请输入对方的用户名：zzp
请输入转账金额：1
转账成功！您的余额为：9999.0

-------1.存款   2.取款   3.转账   4.查询余额   5.修改密码   0.退出----
请输入业务选项：4
您的余额为：9999.0

-------1.存款   2.取款   3.转账   4.查询余额   5.修改密码   0.退出----
请输入业务选项：5
请输入新密码：111111
修改密码成功，新密码是：111111

-------1.存款   2.取款   3.转账   4.查询余额   5.修改密码   0.退出----
请输入业务选项：0
祝您生活愉快,下次再见!

5 三个关键字

5.1 static

例子

public class TestStatic {
    public static void main(String[] args) {
        Static.show();
    }
}

class Static {
    private static Static aStatic = new Static();
    private static int a;
    private static int b = 0;


    public Static() {
        a++;
        b++;
        System.out.println(a);
        System.out.println(b);
    }

    public static void show() {
        System.out.println(a);
        System.out.println(b);
    }
}

答案

解析

类加载，初始化静态成员变量，为三个静态变量开辟空间
给astatic初始化，创建对象，调用构造方法，此时a=1,b=1;
a没有赋值，b赋值1，所以最后a=1,b=0

6 接口

6.1 哥德巴赫猜想

要求：输入一个大于6 的偶数，请输出这个偶数能被分解为哪两个质数的和。
如 10=3+7 12=5+7 
要求：两个人一组合作完成。一个人负责把一个整数n 拆分成两个整数的和，另一个人负责写一个函数，判断某一个整数a 是否是质数 。

标准接口

public interface Judge {
    boolean isPrime(int n);
}

接口的实现者

public class IsPrime implements Judge {

    @Override
    public boolean isPrime(int n) {
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0){
                return false;
            }
        }
        return true;
    }
}

接口的使用者

public class Test {
    public static void main(String[] args) {
        IsPrime isPrime = new IsPrime();
        System.out.println("请输入一个大于6的整数：");
        Scanner scanner = new Scanner(System.in);
        List<Integer> list = new ArrayList<>();
        int n = scanner.nextInt();
        for (int i = 3; i <= n/2; i++) {
            if (isPrime.isPrime(i) && isPrime.isPrime(n-i)){
                list.add(i);
                list.add(n-i);
            }
        }
        list.sort(Integer::compareTo);
        System.out.println("答案为：");
        for (int i = 0; i < list.size(); i++) {
            if (i % 8 == 0){
                System.out.println();
            }
            System.out.print(list.get(i) + " ");
        }


    }
}

测试

请输入一个大于6的整数：
100
答案为：

3 11 17 29 41 47 53 59 
71 83 89 97