java學習筆記part2

面向對象oop

設計對象并使用

類：對象共同特征的描述
對象：真實存在的具體實例

對象在內存中的運行機制

方法區：字節碼文件加載時進入的內存
棧內存：方法運行時，進入的內存，變量也在這里，變量中存儲對象在堆內存的地址
堆內存：new出來的對象，在這塊內存中開辟空間并產生地址，放置成員變量，在對象中放置成員方法的引用地址
堆內存中的對象，沒有任何變量應用時，就會判定為內存中的垃圾

面向對象練習

模擬購物車

package oop;


import java.util.Scanner;

public class ShowCarTest{
    public static void main(String[] args) {
        //定義商品類，用于創建商品對象
        //定義購物車對象，使用數組對象表示
        Goods[] shopCar = new Goods[100];//商品類型的數組
        //搭建操作架構
        while (true) {
            System.out.println("選擇下面命令操作");
            System.out.println("添加商品到購物車 add");
            System.out.println("查詢購物車商品 query");
            System.out.println("修改商品購買數量  update");
            System.out.println("結算商品 pay");
            Scanner sc = new Scanner(System.in);
            System.out.println("輸入命令");

            String command = sc.next();
            switch (command){
                case "add":
                    //添加商品到購物車
                    addGoods(shopCar, sc);
                    break;
                case "query":
                    //查詢購物車商品
                    queryGoods(shopCar);
                    break;
                case "update":
                    //修改商品購買數量
                    updateGoods(shopCar, sc);
                    break;
                case "pay":
                    //結算商品
                    payGoods(shopCar);
                    break;
                default:
                    System.out.println("沒有該功能");
            }
        }
    }

    public static void payGoods(Goods[] shopCar) {
        queryGoods(shopCar);
        //定義求和遍歷，累加金額
        double money = 0;
        //遍歷購物車數組中全部商品對象，單價*數量
        for (int i = 0; i < shopCar.length; i++) {
            Goods g =shopCar[i];
            if(g != null){
                money += (g.price * g.buyNumber);
            }else {
                break;
            }
        }
        System.out.println("訂單金額" + money);
    }

    //修改購買數量
    public static void updateGoods(Goods[] shopCar, Scanner sc) {
        //讓用戶輸入要修改商品的id，id查詢要修改的對象
        while (true) {
            System.out.println("輸入要修改的商品id");
            int id = sc.nextInt();
            Goods g = getGoodsById(shopCar, id);
            if(g == null){
                //沒有商品
                System.out.println("沒有該商品");
            }else {
                //存在該商品
                System.out.println("輸入"+g.name+"購買數量");
                g.buyNumber = sc.nextInt();
                System.out.println("修改完成");
                queryGoods(shopCar);
                break;
            }
        }
    }

    //    根據id查詢要修改的對象
    public static Goods getGoodsById(Goods[] shopCar, int id){
        for (int i = 0; i < shopCar.length; i++) {
            Goods g = shopCar[i];
            if(g != null){
                //判斷商品id是不是要找的
                if(g.id == id){
                    return g;
                }
            }else {
                return null;//找完前面存在的都沒找到
            }
        }
        //所有位置都不是null，都有數據，不匹配
        return null;
    }


    //查詢購物車中商品信息
    public static void queryGoods(Goods[] shopCar) {
        System.out.println("--------購物車信息如下--------");
        System.out.println("編號\t\t名稱\t\t價格\t\t購買數量");
        for (int i = 0; i < shopCar.length; i++) {
            Goods g = shopCar[i];
            if(g != null){
                //展示這個對象
                System.out.println(g.id+"\t\t"+g.name+"\t\t"+g.price+"\t\t"+g.buyNumber);
            }else {
                //遍歷結束
                break;
            }
        }
    }

    //商品添加到購物車
    public static void addGoods(Goods[] shopCar, Scanner sc) {

        //1.錄入用戶輸入的購買商品的信息
        System.out.println("輸入購買商品的編號");
        int id = sc.nextInt();
        System.out.println("輸入購買商品的名稱");
        String name = sc.next();
        System.out.println("輸入購買商品的數量");
        int buyNumber = sc.nextInt();
        System.out.println("商品價格");
        double price = sc.nextDouble();

        //把購買商品的信息，封裝成商品對象
        Goods g = new Goods();
        g.id = id;
        g.name = name;
        g.buyNumber = buyNumber;
        g.price = price;

        //商品對象添加到購物車數組中
        for (int i = 0; i < shopCar.length; i++) {
            if(shopCar[i] == null){
                //這個位置沒有元素
                shopCar[i] = g;
                break;//商品成功存進去，退出
            }
        }
        System.out.println(g.name + "\t添加到購物車");
    }
}

構造器

定義在類中，可以用于初始化一個類的對象，并返回對象地址
無參數構造器：默認存在的，初始化對象時，成員變量的數據采用默認值
有參數構造器：在初始化對象時，同時可以接收參數為對象進行賦值
調用構造器得到對象的格式Car c = new Car()

public  class Car{
	public Car(){
	//無參構造器
	}
	public Car(String n){
	//有參構造器
	}
}

//測試類
package constructor;

import org.w3c.dom.ls.LSOutput;

public class Test {
    public static void main(String[] args) {
        //調用無參數構造器，得到對象
        Car c = new Car();
        c.namr = "bmw";
        c.price = 33.33;
        System.out.println(c.price);
        System.out.println(c.namr);


        //調用有參數構造器
        Car c2 = new Car("bbb", 55.55);
        System.out.println(c2.namr);
        System.out.println(c2.price);

    }
}

//Car類
package constructor;

public class Car {
    String namr;
    double price;


//    無參數構造器
    public Car(){
        System.out.println("調用無參數構造器");
    }

//    有參數構造器
    public Car(String n, double p){
        System.out.println("調用有參數構造器");
        namr = n;
        price = p;
    }
}

注意事項：

任何類定義出來，默認自帶無參數構造器，
一旦定義了有參數構造器，那無參數構造器就沒有了，如果還想用無參數構造器，就需要自己寫一個無參數構造器

this 關鍵字

this可以出現在構造器，方法中
this代表當前對象的地址
可以用于指定訪問當前對象的成員變量，成員方法

//測試類
package thist;

public class Test {
    public static void main(String[] args) {
//        Car c = new Car();
//        c.run();
//        System.out.println(c);
        Car c = new Car("bmw", 55.55);
        System.out.println(c.name);
        System.out.println(c.price);

        c.gowith("bbb");
    }
}



//Car類
package thist;

public class Car {
    String name;
    double price;
//  定義無參數構造器
//    public Car(){
//        System.out.println("無參數構造器中的" + this);
//    }
//
//    public void run(){
//        System.out.println("方法中的" + this);
//    }

    public Car(String name, double price){
        this.name =name;
        this.price = price;
        //指定訪問當前對象的成員變量
    }
    public void gowith(String name){
        System.out.println(this.name + "和" + name + "一起比賽");
    }
}

封裝

面向對象的三大特征：封裝，繼承，多態
封裝：如何正確設計對象的屬性和方法
封裝的原則：對象代表什么，就得封裝對應的數據，并對數據提供對應的行為
private

標準javabean

實體類，對象可以用于程序中封裝數據

標注javabean書寫要求

成員變量使用private修飾
提供成員變量get，set方法
必須提供一個無參構造器，有參構造器可寫可不寫

面向對象案例

//測試類

package demo;

public class Test {
    public static void main(String[] args) {
//        1.設計電影類
//        2.創建三個電影對象，封裝電影信息
//        3.定義電影類型的數組，存儲電影對象
        Movie[] movies = new Movie[3];
        movies[0] = new Movie("長津湖", 8.7, "吳京");
        movies[1] = new Movie("我和我的父輩", 5.5, "吳京");
        movies[2] = new Movie("少年", 6.6, "王");
        
        
//        4.遍歷數組中電影對象
        for (int i = 0; i < movies.length; i++) {
            Movie m = movies[i];
            System.out.println(m);//輸出地址
            System.out.println(m.getName());
            System.out.println(m.getScore());
            System.out.println(m.getActor());
            System.out.println("-----------------------------");

        }
    }
}



package demo;

public class Movie {
    //1.成員變量
    private String name;
    private double score;
    private String actor;

    public Movie() {
    }

    public Movie(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }


    //2.get,set

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }
}

常用api

java寫好的功能代碼，可直接調用

String類

String類定義的變量可以用來存儲字符串
常被稱為不可變字符串類型，對象創建后不能修改
String變量每次修改，都是產生并指向了新的字符串對象，原來的字符串對象沒有改變

String創建對象的兩種方式

“ ”方法給出的字符串，在字符串常量池中存儲，相同內容只會在其中存儲一份
通過構造器new對象，每new一次都會產生新的對象，放在堆內存

package StringLei;

public class StringDemo {
    public static void main(String[] args) {
//        1.使用雙引號，得到字符串對象
        String name = "rrr";
//        2.通過構造器創建對象
//        public String();創建一個空白字符串對象，不用
        String s1 = new String();
//        public String(String);根據傳入的字符串內容，創建字符串對象，不用
        String s2 = new String("tttttt");
//        public String(char[] c);根據字符數組的內容，創建字符串對象
        char[] chars = {'2', '3', '4'};
        String s3 = new String(chars);
//        public String(byte[] b);根據字節數組的內容，創建字符串對象
        byte[] bytes = {1, 2, 3, 4, 5};
        String s4 = new String(bytes);

    }
}

String類常用api

比較

package StringLei;

import java.util.Scanner;

public class StringEqualsDemo {
    public static void main(String[] args) {
        // 正確登錄名和密碼
        String okName = "heima";//指向常量池
        String okPasswd = "123456";

        //輸入登錄名和密碼
        Scanner sc = new Scanner(System.in);
        System.out.println("用戶名");
        String name = sc.next();
        System.out.println("密碼");//堆內存
        String passwd = sc.next();


        //判斷用戶輸入
       if(okName.equals(name) && okPasswd.equals(passwd)){//比較地址
            System.out.println("對了");
        }else {
            System.out.println("錯誤");
        }
       
    }
}

package StringLei;

import java.nio.charset.StandardCharsets;

public class StringDemo11 {
    public static void main(String[] args) {
        //獲取字符串長度
        String name = "好家伙";
        System.out.println(name.length());

        //獲取索引位置處的字符
        System.out.println(name.charAt(1));

        //遍歷字符串中的每個字符
        for (int i = 0; i < name.length(); i++) {
            System.out.println(name.charAt(i));
        }

        //字符串轉換成字符數組
        System.out.println(name.toCharArray());


        //截取字符串
        String name2 = "haojiahuo";
        System.out.println(name2.substring(0, 4));//包括前面,不包括后面


        //從當前索引截取到結尾
        System.out.println(name2.substring(1));

        //替換,后面的字符串替換前面的字符串
        String name3 = "niubi";
        System.out.println(name3.replace("bi", "bidal"));


        //判斷是否包含,生成一個布爾值
        System.out.println(name3.contains("bi"));

        //判斷開頭
        System.out.println(name3.startsWith("niu"));


        //將字符串分割，返回
        String name4 = "niu, bi, da, l";
        String[] name5 = name4.split(",");
        for (int i = 0; i < name5.length; i++) {
            System.out.println(name5[i]);
        }
    }
}

案例

//驗證碼
package StringLei;

import java.util.Random;

public class StringDemo2 {
    public static void main(String[] args) {
        String data = "qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKMNJHBGVFCDXSZA1234567890";

        //循環5次，每次生成一個隨機索引，提取對應字符
        String code = "";
        Random r = new Random();
        for (int i = 0; i < 5; i++) {
            //隨機一個索引
            int index = r.nextInt(data.length());
            char c =data.charAt(index);
            code += c;
        }
        System.out.println(code);
    }
}



//登錄
package StringLei;

import java.util.Scanner;

public class StringDemo3 {
    public static void main(String[] args) {
        //1. 定義名稱密碼
        String okname = "root";
        String okpasswd = "root";

        //2. 定義循環三次
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("輸入名稱");
            String name = sc.next();
            System.out.println("輸入密碼");
            String passwd = sc.next();

            //3. 判斷登錄成功
            if(okname.equals(name)){
                if(okpasswd.equals(passwd)) {
                    System.out.println("登錄成功");
                    break;
                }else {
                    System.out.println("passwd錯誤");
                }
            }else {
                System.out.println("name錯誤");
            }
        }
    }
}


//屏蔽手機號
package StringLei;

import java.util.Scanner;

public class StringDemo5 {
    public static void main(String[] args) {
        // 輸入號碼
        Scanner sc = new Scanner(System.in);
        System.out.println("輸入號碼");
        String tel = sc.next();


        //截取號碼，前三后四
        String before = tel.substring(0, 3);
        String after = tel.substring(7);


        String s = before + "****" + after;
        System.out.println(s);
    }
}

ArrayList集合

支持索引的集合

package ArrayLIst1;

import java.util.ArrayList;

public class Demo1 {
    public static void main(String[] args) {
        // 1.創建arraylist對象
        ArrayList list = new ArrayList();

        //添加數據
        list.add("java");
        list.add("mysql");
        list.add(2);
        list.add(false);
        System.out.println(list);


        //指定索引插入元素
        list.add(1, 666);
        System.out.println(list);
    }
}

泛型

ArrayList:其實就是一個泛型類，可以在編譯階段約束集合對象只能操作某種數據類型

ArrayList：此集合只能操作字符串類型的元素

集合中只能存儲引用類型，支持基本數據類型

package ArrayLIst1;

import java.util.ArrayList;

public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();//jdk1.7開始，泛型 后面的類型聲明可以不寫
        list.add("6666666");
//        list.add(6666666);//只有字符串加進去

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(33333);
        
    }
}

常用api，遍歷

package ArrayLIst1;

import java.util.ArrayList;

public class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("java");
        list.add("mysql");
        list.add("6666");

        //獲取每個索引位置的元素值
        System.out.println(list.get(2));

        //獲取集合元素的個數
        System.out.println(list.size());

        //集合元素遍歷
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }


        //根據索引刪除元素值，返回被刪除的元素值
        System.out.println(list);
        System.out.println(list.remove(1));
        System.out.println(list);


        //直接刪除元素值，成功返回ture，失敗返回false
        //刪除集合的相同元素，會刪除第一個
        System.out.println(list.remove("java"));
        System.out.println(list);



        //修改索引處的元素值,返回修改前的元素值
        System.out.println(list.set(0, "333333333"));
        System.out.println(list);

    }
}

ArrayList案例

99.77.66.89.79.50.100，去掉低于80的

package ArrayLIst1;

import java.util.ArrayList;

public class Demo4 {
    public static void main(String[] args) {
     //1. 創建ArrayList集合存儲一個班級學生成績
        ArrayList<Integer> score = new ArrayList<>();
        score.add(98);
        score.add(77);
        score.add(66);
        score.add(89);
        score.add(79);
        score.add(100);
        score.add(50);
        System.out.println(score);


        //低于80的成績在集合中去掉
        //方案1
/*        for (int i = 0; i < score.size(); i++) {
            int s = score.get(i);
            if(s < 80 ){
                //刪除分數
                score.remove(i);
                i--;
            }
        }
        System.out.println(score);*/

        //方案2
        for (int i = score.size() - 1; i >= 0 ; i--) {
            int s = score.get(i);
            if(s < 80){
                score.remove(i);
            }
        }
        System.out.println(score);
    }
}

展示三個對象

//測試類
package ArrayLIst1;

import java.util.ArrayList;

public class Demo5 {
    public static void main(String[] args) {

    //定義電影類
    //創建電影對象'
    Movie m1 = new Movie("小", 6.6,"xiao");
    Movie m2 = new Movie("中", 6.7,"zhong");
    Movie m3 = new Movie("大", 6.8,"da");

    //創建電影類型的集合
    ArrayList<Movie> movies = new ArrayList<>();

    movies.add(m1);
    movies.add(m2);
    movies.add(m3);

    //遍歷電影類集合中的對象
        for (int i = 0; i < movies.size(); i++) {
            Movie m = movies.get(i);
            System.out.println("name" + m.getName());
            System.out.println("score" + m.getScore());
            System.out.println("actor" + m.getActor());
            System.out.println("--------------------------");
        }
    }
}





package ArrayLIst1;

public class Movie {
    private String name;
    private double score;
    private String actor;

    //有參構造器
    public Movie(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }
    //無參構造器
    public Movie() {
    }

    //get，set
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }
}

元素所搜
存儲學生信息并展示，提供安寧莊學號搜索的功能

//測試類
package ArrayLIst1;

import java.util.ArrayList;
import java.util.Scanner;

public class Demo6 {

    public static void main(String[] args) {
    //構建學生類
    //創建集合，存儲學生對象,封裝學生信息
        ArrayList<Students> students = new ArrayList<>();
        students.add(new Students("2222", "hao", 23, "yiban"));
        students.add(new Students("3333", "jia", 24, "erban"));
        students.add(new Students("4444", "huo", 25, "sanban"));

    //遍歷，展示
        for (int i = 0; i < students.size(); i++) {
            Students s = students.get(i);
            System.out.println(s.getNumber()+ "\t" + s.getName() + "\t" + s.getAge() + "\t" + s.getClassname());
        }

    //定義搜索方法，按學號
        Scanner sc =new Scanner(System.in);
        while (true){
            System.out.println("輸入學號查詢學生");
            String num = sc.next();

            //調用方法查詢
            Students s = getStudentnyid(students, num);

            //判斷s中是否存在，地址
            if(s == null){
                System.out.println("找不到");
            }else {
                System.out.println("找到了");
                System.out.println(s.getNumber()+ "\t" + s.getName() + "\t" + s.getAge() + "\t" + s.getClassname());
            }
        }
    }



    /**
     * 根據學生的學號嗎，查詢學生對象返回
     * @param arrayList 存儲學生對象的集合
     * @param num 學號
     * @return 學生對象 | null
     */
    public static Students getStudentnyid(ArrayList<Students> arrayList, String num){
        //遍歷學生對象
        for (int i = 0; i < arrayList.size(); i++) {
            Students s = arrayList.get(i);
            //對比當前學號，和要搜索的學號
            if(s.getNumber().equals(num)){
                //找到了
                return s;
            }
        }
        //找不到
        return null;
    }
}




//學生類
package ArrayLIst1;

public class Students {
    private String number;
    private String name;
    private int age;
    private String classname;



    //構造器
    public Students(String number, String name, int age, String classname) {
        this.number = number;
        this.name = name;
        this.age = age;
        this.classname = classname;
    }

    public Students() {
    }



    //set，get
    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    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 String getClassname() {
        return classname;
    }

    public void setClassname(String classname) {
        this.classname = classname;
    }
}

ATM系統

package ATM;

import javax.crypto.spec.PSource;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

/**
 * 入口類
 */
public class ATMSystem {
    public static void main(String[] args) {
        //1.定義賬戶類
        //2. 定義集合容器，存儲全部賬戶對象
        ArrayList<Account> accounts = new ArrayList<>();
        //3. 展示系統首頁，
        while (true) {
            System.out.println("--------ATM系統---------");
            System.out.println("1, 登錄");
            System.out.println("2, 注冊");
            Scanner sc = new Scanner(System.in);
            System.out.println("選擇操作");
            int command = sc.nextInt();

            switch (command) {
                case 1 ->
                    //登錄
                        login(accounts, sc);
                case 2 ->
                    //注冊
                        register(accounts, sc);
                default -> System.out.println("沒這功能");
            }
        }
    }


    /**
     * 登錄功能,
     * @param accounts 全部賬戶對象集合
     * @param sc 掃描器
     */
    private static void login(ArrayList<Account> accounts, Scanner sc) {
        System.out.println("----------------登錄-----------------");
        //1。判斷賬戶集合中是否存在賬戶，沒有的話不能運行
        if(accounts.size() == 0){
            System.out.println("系統中無任何用戶，先注冊");
            return;//結束方法的執行
        }

        //進入登錄操作
        while (true) {
            System.out.println("輸入卡號");
            String cardId = sc.next();

            //判斷卡號是否存在
            Account acc = getAccountByCardId(cardId, accounts);
            if(acc != null){
                //卡號存在
                //用戶輸入密碼認證
                while (true) {
                    System.out.println("輸入密碼");
                    String passwd = sc.next();
                    //判斷密碼是否正確
                    if(acc.getPasswd().equals(passwd)){
                        //登錄成功
                        System.out.println(acc.getUsername() + "登錄成功，卡號是" + acc.getCardid());
                        //展示登錄后的操作頁，整個方法
                        showUserCommand(sc, acc, accounts);
                        return;//干掉登錄方法

                    }else {
                        System.out.println("輸入密碼有誤");
                    }
                }
            }else {
                System.out.println("系統中不存在該賬戶卡號");
            }
        }
    }

    /**
     * 展示登錄后的操作頁面
     */
    private static void showUserCommand(Scanner sc, Account acc, ArrayList<Account> accounts) {
        while (true) {
            System.out.println("--------------用戶操作頁------------------");
            System.out.println("1, 查詢賬戶");
            System.out.println("2, 存款");
            System.out.println("3, 取款");
            System.out.println("4, 轉賬");
            System.out.println("5, 修改密碼");
            System.out.println("6, 退出");
            System.out.println("7, 銷戶");
            System.out.println("選擇");
            int command = sc.nextInt();
            switch (command) {
                case 1 ->
                    //查詢賬戶，當前登錄的賬戶信息
                        showAccount(acc);
                case 2 ->
                    //存款
                        depositMoney(acc, sc);
                case 3 ->
                    //取款
                        drawMoney(acc, sc);
                case 4 ->
                    //轉賬
                        transferMoney(sc, acc, accounts);
                case 5 -> {
                    //修改密碼
                    updatepasswd(sc, acc);
                    return;//跳出登錄
                }
                case 6 -> {
                    //退出
                    System.out.println("退出成功");
                    return;//干掉當前方法的執行
                }
                case 7 -> {
                    //注銷
                    if(deleteAccount(acc, sc, accounts)){
                        return;
                    }else {
                        //銷戶沒有成功
                        break;
                    }
                }
                default -> System.out.println("輸入的操作命令不正確");
            }
        }
    }

    /**
     * 銷戶
     * @param acc
     * @param sc
     * @param accounts
     */
    private static boolean deleteAccount(Account acc, Scanner sc, ArrayList<Account> accounts) {
        System.out.println("-----------用戶銷戶-----------");
        System.out.println("真的銷戶嗎 y/n");
        String s = sc.next();
        switch (s){
            case "y":
                //真銷戶
                if(acc.getMoney() > 0){
                    System.out.println("賬戶還有錢，不能銷戶");
                }else {
                    accounts.remove(acc);
                    System.out.println("銷戶成功");
                    return true;
                }
                break;
            default:
                System.out.println("那就不銷戶了");
        }
        return false;
    }

    /**
     * 改密碼
     * @param sc 掃描器
     * @param acc 當前登錄成功的對象
     */
    private static void updatepasswd(Scanner sc, Account acc) {
        System.out.println("-----------用戶改密碼-----------");
        while (true) {
            System.out.println("輸入當前密碼");
            String passwd = sc.next();

            //判斷密碼
            if(acc.getPasswd().equals(passwd)){
                //正確
                //輸入密碼
                while (true) {
                    System.out.println("輸入新密碼");
                    String newpasswd = sc.next();
                    System.out.println("再次輸入密碼");
                    String newpasswd2 = sc.next();

                    if(newpasswd.equals(newpasswd2)){
                        //兩次輸入一致，可以修改了
                        acc.setPasswd(newpasswd2);
                        System.out.println("修改成功");
                        return;
                    }else {
                        System.out.println("兩次密碼不一致");
                    }
                }
            }else {
                System.out.println("當前密碼不正確");
            }
        }

    }

    /**
     * 轉賬
     * @param sc 掃描
     * @param acc 自己賬戶
     * @param accounts 全部賬戶集合
     */
    private static void transferMoney(Scanner sc, Account acc, ArrayList<Account> accounts) {
        System.out.println("-----------用戶取錢-----------");
        // 1.分析系統是否足夠兩個賬戶
        if(accounts.size() < 2){
            System.out.println("不夠兩個賬戶，不能轉賬");
            return;
        }

        //判斷自己賬戶是否有錢
        if(acc.getMoney() == 0){
            System.out.println("自己沒錢");
            return;
        }

        //3.開始轉賬

        while (true) {
            System.out.println("輸入對方卡號");
            String  cardId = sc.next();

            //卡號不能自己
            if(cardId.equals(acc.getCardid())){
                System.out.println("不能給自己轉賬");
                continue;//結束當此執行，進行下一次
            }

            //根據卡號查賬戶
            Account a = getAccountByCardId(cardId, accounts);
            if(a == null){
                System.out.println("輸入賬戶不存在");
            }else {
                //賬戶存在，繼續認證姓氏
                String userName = a.getUsername();
                String tip = '*' + userName.substring(1);
                System.out.println("輸入" + tip + "姓氏");
                String preName = sc.next();

                //檢查
                if(userName.startsWith(preName)){
                    while (true) {
                        //通過
                        //開始轉賬
                        System.out.println("輸入轉賬金額");
                        double money = sc.nextDouble();
                        //判斷余額
                        if(money > acc.getMoney()){
                            System.out.println("余額不足，最多轉賬" + acc.getMoney());
                        }else {
                            //余額足夠
                            acc.setMoney(acc.getMoney() - money);
                            a.setMoney(a.getMoney() + money);
                            System.out.println("轉賬成功，賬戶剩余" + acc.getMoney());
                            return;  //轉賬結束，干掉方法
                        }
                    }
                }else {
                    System.out.println("輸入錯誤");
                }
            }
        }
    }

    /**
     * 取錢
     * @param acc 當前賬戶對象
     * @param sc 掃描器
     */
    private static void drawMoney(Account acc, Scanner sc) {
        System.out.println("-----------用戶取錢-----------");
        //判斷是否有錢
        if(acc.getMoney() < 100){
            System.out.println("錢不夠100，不能取");
            return;
        }
        // 提示用戶輸入取錢金額
        while (true) {
            System.out.println("輸入取款金額");
            double money = sc.nextDouble();
            //判斷金額
            if(money > acc.getQuotaMoney()){
                System.out.println("不能取，每次最多可取" + acc.getQuotaMoney());
            }else {
                //沒超過限額
                // 判斷是否超過總余額
                if(money > acc.getMoney()){
                    System.out.println("余額不足，還有" + acc.getMoney());
                }else {
                    //可以取錢
                    System.out.println("取錢成功" + money);
                    //跟新余額
                    acc.setMoney(acc.getMoney() - money);
                    showAccount(acc);
                    return;
                }
            }
        }
    }

    /**
     * 存錢
     * @param acc 當前賬戶對象
     * @param sc 掃描器
     */
    private static void depositMoney(Account acc, Scanner sc) {
        System.out.println("-----------用戶存錢-----------");
        System.out.println("輸入存款金額");
        double Money = sc.nextDouble();

        //跟新賬戶余額，原來的+存的
        acc.setMoney(acc.getMoney() + Money);
        System.out.println("存錢成功");
        showAccount(acc);

    }

    /**
     * 展示賬戶信息
     */
    private static void showAccount(Account acc) {
        System.out.println("--------當前賬戶信息如下--------------");
        System.out.println("卡號" + acc.getCardid());
        System.out.println("姓名" + acc.getUsername());
        System.out.println("余額" + acc.getMoney());
        System.out.println("限額" + acc.getQuotaMoney());
    }

    /**
     * 用戶注冊功能的實現
     * @param accounts，接收賬戶的集合
     */
    private static void register(ArrayList<Account> accounts, Scanner sc) {
        System.out.println("------------注冊功能---------------");
        //創建賬戶對象，用于后期封裝賬戶信息
        Account account = new Account();

        //錄入當前賬戶的信息，注入到賬戶中
        System.out.println("輸入用戶名");
        String usereanme = sc.next();
        account.setUsername(usereanme);

        while (true) {
            System.out.println("輸入密碼");
            String passwd = sc.next();
            System.out.println("輸入密碼");
            String okpasswd = sc.next();
            if(okpasswd.equals(passwd)){
                //密碼一樣
                account.setPasswd(passwd);
                break;//錄入成功，退出循環
            }else {
                System.out.println("兩次密碼不一樣");
            }
        }

        System.out.println("輸入賬戶限額");
        double quotamoney = sc.nextDouble();
        account.setQuotaMoney(quotamoney);


        //隨機一個，8位不重復的號碼（獨立成方法）
        String cardId = getRandomCardId(accounts);
        account.setCardid(cardId);


        //把賬戶對象添加到賬戶集合中
        accounts.add(account);
        System.out.println(usereanme + "注冊成功" + cardId);


    }

    /**
     * 為賬戶生成8位，不重復的卡號
     *
     */
    private static String getRandomCardId(ArrayList<Account> accounts) {
        Random r = new Random();
        while (true) {
            //生成八位數字
            String cardId = "";
            for (int i = 0; i < 8; i++) {
                cardId += r.nextInt(10);
            }

            //判斷卡號是否重復
            //根據卡號查詢賬戶對象
            Account acc = getAccountByCardId(cardId, accounts);
            if(acc == null){
                //cardid,沒有重復，可以使用
                return cardId;//return可以立即跳出尋循環，并停止當前方法
            }
        }
    }

    /**
     * 根據卡號查詢賬戶
     * @param cardId 卡號
     * @param accounts 全部賬戶集合
     * @return 賬戶對象
     */
    private static Account getAccountByCardId(String cardId, ArrayList<Account> accounts){
        for (int i = 0; i < accounts.size(); i++) {
            Account acc = accounts.get(i);
            if(acc.getCardid().equals(cardId)){
                return acc;
            }
        }
        return null;
    }

}

package ATM;

/**
 * 賬戶類
 */
public class Account {
    private String cardid;//卡號
    private String username;//用戶名
    private String passwd;//密碼
    private double money;//余額
    private double quotaMoney;//每次取現額度

    public String getCardid() {
        return cardid;
    }

    public void setCardid(String cardid) {
        this.cardid = cardid;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public double getQuotaMoney() {
        return quotaMoney;
    }

    public void setQuotaMoney(double quotaMoney) {
        this.quotaMoney = quotaMoney;
    }
}

posted @ 2022-04-27 20:39 5rem 閱讀(59) 評論(0) 收藏舉報

刷新頁面返回頂部

Loading

5rem

java學習筆記part2

面向對象oop

設計對象并使用

對象在內存中的運行機制

面向對象練習

構造器

注意事項：

this 關鍵字

封裝

標準javabean

面向對象案例

常用api

String類

String創建對象的兩種方式

String類常用api

案例

ArrayList集合

泛型

常用api，遍歷

ArrayList案例

ATM系統

公告