Java 学习--黑马徐老师一--200

总结：
类名的首字母大写

方法55-62
return在无返回值的方法中不需要写；

返回数组的索引

public class method1 {
    public static void main(String[] args) {
        int[] arr = {1, 4, 7, 9};
        System.out.println(getIndex(arr, 8));
    }

    public static int getIndex(int[] arr, int n) {
        for (int i = 0; i < arr.length; i++) {
            if (n == arr[i]) {
                return i;
            }
        }
        return -1;
    }
}

判断两个整型数组是否相等

public class method1 {
    public static void main(String[] args) {
        int[] arr1 = {1, 4, 9, 7};
        int[] arr2 = {1, 4, 9, 7};
        System.out.println(isSame(arr1, arr2));
        System.out.println(compare(arr1, arr2));
    }

    public static boolean compare(int[] arr1, int[] arr2) {
        if (arr1.length == arr2.length) {
            for (int i = 0; i < arr1.length; i++) {
                if (arr1[i] != arr2[i]) {
                    return false;
                }
            }
            return true;
        } else {
            return false;
        }
    }

    public static boolean isSame(int[] arr1, int[] arr2) {
        if (arr1.length != arr2.length) { //先判断长度不相等就return false
            return false;
        } else {
            for (int i = 0; i < arr1.length; i++) {
                if (arr1[i] != arr2[i]) {
                    return false;//数组对应位置的值进行比较，不等就返回false
                }
            }
            return true;
        }
    }
}

方法重载

return关键字的使用


63-69编程训练

public class test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入机票原价");
        double money = sc.nextDouble();
        System.out.println("请输入机票的月份1-12");
        int month = sc.nextInt();
        System.out.println("请输入舱位类型");
        String type = sc.next();
        System.out.println(calc(money, month, type));
    }

    /**
     * 定义方法按接受信息统计优惠价格
     */
    public static double calc(double money, int month, String type) {
        if (month >= 5 && month <= 10) {
            switch (type) {
                case "头等舱":
                    money *= 0.9;
                    break;
                case "经济舱":
                    money *= 0.85;
                    break;
                default:
                    System.out.println("输入的舱位类型有误");
                    money = -1; //表示当前无法计算价格
            }
        } else if (month == 11 || month == 12 || month >= 1 && month <= 4) {
            switch (type) {
                case "头等舱":
                    money *= 0.7;
                    break;
                case "经济舱":
                    money *= 0.65;
                    break;
                default:
                    System.out.println("输入的舱位类型有误");
                    money = -1; //表示当前无法计算价格
            }

        } else {
            System.out.println("您输入的月份有误");
            money = -1; //表示当前无法计算价格
        }
        return money;
    }
}

public class test2 {
    public static void main(String[] args) {
        for (int i = 101; i < 200; i++) {
            //信号位标记
            boolean flag = true;//开始认为是素数
            //2在这些数中找素数
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0) {
                    flag = false;
                    break; //结束循环
                }
            }
            //3输出素数
            if (flag) {
                System.out.println(i + "\t");
            }
        }
    }
}

public class test3 {
    public static void main(String[] args) {
        System.out.println(creatCode(5));
    }

    public static String creatCode(int n) {
        String code = "";
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int type = r.nextInt(3);//0 ,1,2
            switch (type) {
                case 0:
                    char ch = (char) (r.nextInt(26) + 65);
                    code += ch;
                    //生成大写字符
                    break;
                case 1:
                    char ch1 = (char) (r.nextInt(26) + 97);
                    code += ch1;
                    break;
                case 2:
                    code += r.nextInt(10);
                    break;

            }
        }
        return code;
    }
}

数组反转

public class test5 {
    public static void main(String[] args) {
        int[] arr = {1, 9, 8, 3};
        jiaohuan(arr);
        get(arr);

    }

    public static int[] jiaohuan(int[] arr) {
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }
        return arr;
    }

    public static void get(int[] arr) {
        if (arr != null && arr.length > 0) {
            StringBuilder sb = new StringBuilder();
            sb.append("[");
            for (int i = 0; i < arr.length; i++) {
                if (i == arr.length - 1) {
                    sb.append(arr[i]);
                } else {
                    sb.append(arr[i]);
                    sb.append(",");
                }

            }
            sb.append("]");
            System.out.println(sb);
        }
    }
}

70-77面向对象
面向对象案例

public class TestMovie {
    public static void main(String[] args) {
//        Movie m1 = new Movie("长津湖",9.7,"wujing");
        Movie m2 = new Movie("长津湖2", 9.2, "wu2");
        Movie m3 = new Movie("长津湖3", 9.3, "wu3");
        System.out.println(m2.getClass());
        System.out.println(m2.getClass().getName());
        System.out.println(m2.getClass().getSimpleName());

        //定义一个电影的数组，存储电影的对象
        // arr[] arrs = new arr[3];
        Movie[] movies = new Movie[3];
        movies[0] = new Movie("长津湖", 9.7, "wujing");
        movies[1] = m2;
        movies[2] = m3;
        for (int i = 0; i < movies.length; i++) {
            System.out.println(movies[i]); //取得是地址
            System.out.print(movies[i].getName() + "\t");
            System.out.print(movies[i].getScore() + "\t");
            System.out.print(movies[i].getActor() + "\t");
            System.out.println("-------------");

        }
    }
}

import java.util.ArrayList;

public class TestMovie2 {
    public static void main(String[] args) {
        Movie m1 = new Movie("长津湖", 9.7, "wujing");
        Movie m2 = new Movie("长津湖2", 9.2, "wu2");
        Movie m3 = new Movie("长津湖3", 9.3, "wu3");
        ArrayList<Movie> movies = new ArrayList<>();
        movies.add(m1);
        movies.add(m2);
        movies.add(m3);
        System.out.println(movies); //打印的是地址
        for (int i = 0; i < movies.size(); i++) {
            System.out.println(movies.get(i).getName());
        }
    }
}

package xulaoshi.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

public class TestMovie3 {
    public static void main(String[] args) {
        Movie m1 = new Movie("长津湖", 9.7, "wujing");
        Movie m2 = new Movie("长津湖2", 9.2, "wu2");
        Movie m3 = new Movie("长津湖3", 9.3, "wu3");
        Collection<Movie> movies = new ArrayList<>();
        movies.add(m1);
        movies.add(m2);
        movies.add(m3);
        movies.forEach(new Consumer<Movie>() {
            @Override
            public void accept(Movie movie) {
                System.out.println(movie.getName());
            }
        });

        movies.forEach(movie -> System.out.println(movie.getName()));
    }
}

package xulaoshi.demo;

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() {
    }

    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;
    }
}

78-85 API String&ArrayList

常用stringAPI

public class TestString {
    public static void main(String[] args) {
        char[] ch = {'a', 'b'};
        String s = new String(ch);
        System.out.println(s); //ab
    }
}

随机生成验证码

public class TestString {
    public static void main(String[] args) {
        //定义一个可能出现的字符信息
        String data = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        //循环5次，每次生成一个随机
        String code = "";
        Random r = new Random();
        for (int i = 0; i < 5; i++) {
            int index = r.nextInt(data.length());
            char ch = data.charAt(index);
            code += ch;
        }
        System.out.println(code);
    }
}

模拟用户登录

手机号屏蔽

遍历并删除数据

package xulaoshi.api;

import java.util.ArrayList;

public class TestList {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(23);
        list.add(56);
        list.add(46);
        list.add(96);
        list.add(22);
        list.add(21);
        list.add(576);
        System.out.println(list);

        for (int i = 0; i < list.size(); i++) {
            int score = list.get(i);
            if (score < 50) {
                list.remove(i);
                i--; //删除成功必须往前退一步
            }

        }
        System.out.println(list);

        for (int i = list.size() - 1; i >= 0; i--) {
            int score = list.get(i);
            if (score < 50) {
                list.remove(i);
            }
        }
        System.out.println(list);
    }
}

package xulaoshi.api;

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

public class Test6 {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("01", "xiaoming", 20, "class1"));
        students.add(new Student("02", "xiaom2", 22, "class2"));
        students.add(new Student("03", "xiaom3", 23, "class3"));
        students.add(new Student("04", "xiaom4", 24, "class4"));
        //遍历学生信息
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            System.out.println(s.getStudyNumber() + "\t" + s.getName() + "\t" + s.getAge() + "\t" + s.getClassName());
        }
        //定义方法完成学号的搜索功能
        Scanner sc = new Scanner(System.in);
        while (true) {  //死循环，可以无数次查询
            System.out.println("请您输入学号查询学生对象");
            String studyNumber = sc.next();
            //调用方法查询
            Student s = getStudentById(students, studyNumber);
            //判断是否存在学生对象地址
            if (s == null) {
                System.out.println("对不起，查无此人");
            } else {
                System.out.println("您查询的信息如下");
                System.out.println(s);
                System.out.println(s.getStudyNumber() + "\t" + s.getName() + "\t" + s.getAge() + "\t" + s.getClassName());
            }
        }

    }

    /**
     * 根据学生的学号，查询学生对象返回
     *
     * @param students    存储全部学生对象的集合
     * @param studyNumber 搜索的学生的学号
     * @return 学生对象|null
     */
    public static Student getStudentById(ArrayList<Student> students, String studyNumber) {
        //遍历学生对象
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            //询问当前遍历的学号是否是要找的学号
            if (s.getStudyNumber().equals(studyNumber)) {
                //这个s代表的学生对象，就是要找的，返回他
                return s;
            }
        }
        //查无此人
        return null;

    }
}

93-95面向对象进阶课程

96

package d1;

public class Student {
    /**
     * 实例成员变量，误static修饰，属于对象
     */
    private String name;

    /**
     * 静态成员方法，有static修饰，归属于类，可以被共享使用，用类名或者对象名都可以访问
     */
    public static int getMax(int age1, int age2) {
        return age1 > age2 ? age1 : age2;
    }

    /**
     * 实例方法时属于对象的，只能用对象触发访问
     */
    public void study() {
        System.out.println(name);
    }

    public static void main(String[] args) {
        //1类名.静态成员方法
        System.out.println(Student.getMax(1,2));
        //注意，同一个类中，访问静态方法类名可以不写，
        System.out.println(getMax(3,9));

        //2对象要用实例方法
        Student s = new Student();
        s.name = "lily";
        s.study();
    }

}

97

98

package d2;

import java.util.Random;

/**
 * 工具类
 */
public class Utils {
    /**
     * 注意：由于工具类无需创建对象，所以把其构造器私有化显得专业
     */
    private Utils(){}
    /**
     * 静态方法
     */
    public static String createVerifyCode(int n) {
        //开发一个验证码
        //1定义一个变量记住验证码
        String code = "";
        //2定义一个变量记住全部验证码字符
        String data = "abcdefghijkABCDEFGHIJK0123456789";
        //3定义一个循环生成几个随机索引，去得到几个字符
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            //4获取随机索引对应的字符，链接给code
            int index = r.nextInt(data.length());
            code = code + data.charAt(index);
        }
        System.out.println("验证码：" + code);
        return code;
    }

    public static void main(String[] args) {
        createVerifyCode(3);
    }
}

package d3;

/**
 * 完成数组工具类的设计
 */
public class ArrayUtils {
    /**
     * 私有构造器
     */
    private ArrayUtils() {
    }

    /**
     * 工具方法：静态方法
     */
    public static String toString(int[] arr) {
        //1一些校验
        if (arr == null) {
            return null;
        }
        //2拼接内容并返回,兼容arr=[]
        String result = "[";
        for (int i = 0; i < arr.length; i++) {
            result += (i == arr.length - 1 ? arr[i] : arr[i] + ",");
        }
        result += "]";
        return result;
    }

    public static void main(String[] args) {
        int[] arr = null;
        int[] arr1 = {};
        int[] arr2 = {1, 2, 3};
        System.out.println(ArrayUtils.toString(arr));  //null
        System.out.println(ArrayUtils.toString(arr1));  //[]
        System.out.println(toString(arr2));  //[1,2,3]
    }
}

99代码块

package d3;


import java.util.ArrayList;

public class StaticTest {
    /**
     * 定义一个静态集合，因为这个集合只要加载一次，系统也只需要一副牌
     */
    public static ArrayList<String> cards = new ArrayList<String>();

    /**
     * 在main方法之前，把54张牌加载进去，后续游戏就可以直接使用了
     */
    static {
        //3正式做牌，放大集合里去
        //定义一个数组存储点数，类型确定，个数确定
        String[] sizes = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        String[] colors = {"♥", "♠", "♦", "♣"};
        //遍历点数，四个3就放一起了
        for (int i = 0; i < sizes.length; i++) {
            //sizes[i]
            //遍历花色
            for (int j = 0; j < colors.length; j++) {
                //colors[j]
                //一张牌
                String card = sizes[i] + colors[j];
                //把牌添加到集合里去
                cards.add(card);
            }

        }
        //单独加入大王，小王
        cards.add("🃏大");
        cards.add("🃏小");
    }

    public static void main(String[] args) {
        //模拟游戏启动前，初始化54张牌
        System.out.println("新牌" + cards);
    }
}

100

101-101

103-104

105

106

107

108

109

抽象类案例

package d7_abstract;

/**
 * 抽象父类
 */
public abstract class Card {
    private String name;  //主人名称
    private double money;

    /**
     * 每个子类一定要支付，但是支付情况不一样，所以父类把支付定义成抽象方法，交给具体子类实现
     */
    public abstract void pay(double moneyPay);

    public String getName() {
        return name;
    }

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

    public double getMoney() {
        return money;
    }

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

package d7_abstract;

public class GoldCard extends Card {
    @Override
    public void pay(double moneyPay) {
        //优惠后的金额计算出来
        double rs = moneyPay * 0.88;
        double lastMoney = getMoney() - rs;
        System.out.println(getName() + "当前账户总金额" + getMoney() + ",当前消费了" + rs + ",消费后剩余" + lastMoney);
        setMoney(lastMoney);  //更新当前账户余额
    }
}

package d7_abstract;

public class Test {
    public static void main(String[] args) {
        GoldCard c = new GoldCard();
        c.setMoney(10000);
        c.setName("lily");
        c.pay(300);
        System.out.println("余额" + c.getMoney());
    }
}

110

public final static handle ，模板方法需要用final关键字修饰，因为模板方法不希望被重写

111接口

package d11;

public interface SportMan {
    public void run();

    void competition();

}

package d11;

public interface Law {
    void rule();

}

package d11;

/**
 * 实现类，子类
 */
public class PingPangMan implements SportMan,Law{
    private String name;

    public PingPangMan(String name) {
        this.name = name;
    }

    @Override
    public void rule() {
        System.out.println(name+"需要遵守法律");
    }

    @Override
    public void run() {
        System.out.println(name+"需要跑步");
    }

    @Override
    public void competition() {
        System.out.println(name+"需要比赛");
    }
}

package d11;

public class Test {
    public static void main(String[] args) {
        PingPangMan p = new PingPangMan("zhang");
        p.rule();
        p.run();
        p.competition();
    }
}

接口多继承，整合多个接口为一个接口，便于子类实现

package d11;

public interface Law {
    void rule();

}

package d11;

public interface People {
    void eat();
}

package d11;

public interface SportMan extends Law,People{
    public void run();

    void competition();

}

package d11;

/**
 * 实现类
 */
//public class BasketMan implements People,Law,SportMan{
public class BasketMan implements SportMan{
    @Override
    public void rule() {

    }

    @Override
    public void eat() {

    }

    @Override
    public void run() {

    }

    @Override
    public void competition() {

    }
}

112-113

113-114
多态综合案例

package d4;

/**
 * usb接口规范
 */
public interface USB {
    //接入 拔出
    void connect();
    void unconnect();
}

package d4;

/**
 * 实现类
 */
public class KeyBoard implements USB{
    private String name;

    public KeyBoard(String name) {
        this.name = name;
    }

    @Override
    public void connect() {
        System.out.println(name+"接入");
    }

    /**
     * 独有功能
     */
    public void keyDown(){
        System.out.println(name+"独有功能");
    }
    @Override
    public void unconnect() {
        System.out.println(name+"拔出");
    }

    public String getName() {
        return name;
    }

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

package d4;

public class Mouse implements USB{
    private String name;

    public Mouse(String name) {
        this.name = name;
    }

    @Override
    public void connect() {
        System.out.println(name+"接入");
    }

    /**
     * 独有功能
     */
    public void dbClick(){
        System.out.println(name+"鼠标双击");
    }
    @Override
    public void unconnect() {
        System.out.println(name+"拔出");
    }

    public String getName() {
        return name;
    }

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

package d4;

public class Computer {
    private String name;

    public Computer(String name) {
        this.name = name;
    }
    public void start(){
        System.out.println(name+"开机了");
    }

    /**
     * 提供安装USB的入口
     */
    public void installUSB(USB usb){
        //多态   usb==鼠标还是键盘
        usb.connect();
        //独有功能，先判断，在强转
        if (usb instanceof KeyBoard){
            KeyBoard k=(KeyBoard) usb;
            k.keyDown();
        }else if (usb instanceof Mouse){
            Mouse m= (Mouse) usb;
            m.dbClick();
        }
        usb.unconnect();
    }
    public String getName() {
        return name;
    }

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

package d4;

public class Test {
    public static void main(String[] args) {
        //创建电脑对象
        Computer c = new Computer("电脑1");
        c.start();
        //2创建鼠标对象，键盘对象
        USB u = new KeyBoard("键盘1");
        c.installUSB(u);
        USB m = new Mouse("罗技");
        c.installUSB(m);
    }
}

115 内部类

116 匿名内部类

package d8;

public class Test {
    public static void main(String[] args) {
//        Animal a = new Tiger();
//        a.run();

        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("run run");
            }
        };
        a.run();
    }

}
//class Tiger extends Animal{
//    @Override
//    public void run() {
//        System.out.println("老虎跑的快");
//    }
//}

abstract class Animal{
    public abstract void run();
}

之前的写法

package d8;

public class Test2 {
    public static void main(String[] args) {
        Student student = new Student();
        go(student);
    }
    /**
     * 学生、老师、运动员可以一起参加游泳
     */
    public static void go(Swimming s){
        System.out.println("开始");
        s.swim();
    }
}
class Student implements Swimming{
    @Override
    public void swim() {
        System.out.println("比赛开始");
    }
}
interface Swimming{
    void swim();
}

匿名内部类

package d8;

public class Test2 {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生游泳");
            }
        };
        go(s);
       
        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("teacher游泳");
            }
        });
    }
    /**
     * 学生、老师、运动员可以一起参加游泳
     */
    public static void go(Swimming s){
        System.out.println("开始");
        s.swim();
    }
}

interface Swimming{
    void swim();
}

117 object

package d9;

public class Student {
    private String name;
    private char sex;
    private int age;

    public Student() {
    }

    public Student(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //重写object方法，可以打印出子类内容
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }

    /**
     * 自己重写equals，自己指定规则，两个对象的内容一样，就认为时相等的
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (sex != student.sex) return false;
        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

}

package d9;

/**
 * 掌握object类中toString方法的使用
 */
public class Test {
    public static void main(String[] args) {
        Student s = new Student("lily", '女', 20);
        String res = s.toString();
        System.out.println(res);
        //默认可以省略toString()不写，都是返回地址
        System.out.println(s.toString());
        System.out.println(s);
        Student s2 = new Student("lily", '女', 20);
        //比较地址
        System.out.println(s.equals(s2));
        System.out.println(s==s2);
    }
}

package d10;

import java.util.Objects;

public class TestObject {
    public static void main(String[] args) {
        String s1=null;
        String s2= new String("hello");
        System.out.println(s1.equals(s2));  //可能出现空指针异常
        System.out.println(Objects.equals(s1,s2));
        //两种写法一样
        System.out.println(Objects.isNull(s1));  //true
        System.out.println(s1==null);  //true
    }
}

118 stringbuilder

package d10;

public class StringBuilderTest {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("s");
        sb.append(2);
        System.out.println(sb);
        //支持链式编程
        sb.append(3).append("r");
        System.out.println(sb);  //s23r
        //反转
        sb.reverse().append(110);
        System.out.println(sb);  //r32s110
        System.out.println(sb.length());  //7
        //恢复成String,因为一些场景传参需要String
        String s = sb.toString();
        check(s);  //r32s110
    }

    public static void check(String data) {
        System.out.println(data);
    }
}

package d10;

public class StringBuilderTest2 {
    public static void main(String[] args) {
        int[] arr1=null;
        System.out.println(toStringMethod(arr1));  //null
        int[] arr2 ={1,4,7,8};
        System.out.println(toStringMethod(arr2));  //[1,4,7,8]

    }
    /**
     * 定义一个方法接收整形数组，返回数组内容格式
     */
    public static String toStringMethod(int[] arr){
        if (arr!=null){
            //开始拼接数组
            StringBuilder sb = new StringBuilder("[");

            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]).append(i==arr.length-1? "":",");
            }
            sb.append("]");
            return sb.toString();
        }else {
            return null;
        }
    }
}

119 math system

120 date

package d10;

import java.util.Date;

public class DataDemo {
    public static void main(String[] args) {
        //创建一个Date类对象，代表系统此刻日期时间对象
        Date d = new Date();
        System.out.println(d);
        //获取时间毫秒值
        long time =d.getTime();
        System.out.println(time);
        
        System.out.println("---------计算当前时间往后走1小时121秒后的时间-------------");
        Date d1 = new Date();
        System.out.println(d1);
        //得到当前时间的毫秒值
        long time2= System.currentTimeMillis();
        time2+=(60*60+121)*1000;
        //把时间毫秒值转换成对应的日期对象
        Date d2 = new Date(time2);
        System.out.println(d2);
        Date d3 = new Date();
        d3.setTime(time2);
        System.out.println(d3);
//        Tue Mar 15 21:49:59 CST 2022
//        1647352199519
//        ---------计算当前时间往后走1小时121秒后的时间-------------
//        Tue Mar 15 21:49:59 CST 2022
//        Tue Mar 15 22:52:00 CST 2022
//        Tue Mar 15 22:52:00 CST 2022
    }
}

121 日期时间date

public class date {
    public static void main(String[] args) {
        //拿到系统此刻日历对象
        Calendar ca = Calendar.getInstance();
        System.out.println(ca);
        //获取日历的信息
        int year = ca.get(Calendar.YEAR);
        System.out.println(year);
        //为某个时间段加减时间
        ca.add(Calendar.DAY_OF_YEAR,+2);
        ca.add(Calendar.HOUR,1);
        //拿到此时日期对象
        Date time = ca.getTime();
        System.out.println(time);

    }

}

122 jdk date新增api

demo3

demo4


instant

dateTimeformatter







123 包装类


124 正则表达式

125 arrays

public class ArrayDemo {
    public static void main(String[] args) {
        int[] ages = {12, 34, 32, 43, 3, 5};
        Arrays.sort(ages);
        System.out.println(Arrays.toString(ages));

        Integer[] ages1={3,4,54,64,77};
        Arrays.sort(ages1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(ages1));

    }
}

对象比较排序，自定义比较器

126

127 lambda 表达式

package oop.d7;

import java.util.Arrays;
import java.util.Comparator;

public class Lambda {
    public static void main(String[] args) {
        Animal animal = new Animal() {
            @Override
            public void run() {
                System.out.println("-----run1");
            }
        };
        go(animal);

        Animal animal2 = ()-> {
                System.out.println("--------run2");
        };
        go(animal2);

        go(new Animal() {
            @Override
            public void run() {
                System.out.println("-----run3");
            }
        });

        go(() -> {System.out.println("------run4");
        });
    }

    public static void go(Animal animal){
        System.out.println("---go1---");
        animal.run();
        System.out.println("---go2---");
    }
}

128-132128collection集合体系

package xulaoshi.collection;

import java.util.*;

public class collection {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("ssd");
        list.add("ssw");
        list.add("ss3");
        list.add("ss4");
        System.out.println(list);
        //将list转换成数组
        Object[] objects = list.toArray();
        System.out.println(Arrays.toString(objects));
        //将数组转换成list
        List<Object> list1 = Arrays.asList(objects);
        System.out.println(list1);
    }
}

129 Collection 迭代器

collection集合三种遍历方式

package xulaoshi.collection;

import java.util.*;
import java.util.function.Consumer;

public class collection {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("ssd");
        list.add("ssw");
        list.add("ss3");
        list.add("ss4");
        System.out.println(list);
        //遍历一
        //得到当前集合的迭代器对象
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        //遍历二
        for (String s : list) {
            System.out.println(s);
        }
        //遍历三 lamda foreach
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //简化写法
        list.forEach(s -> System.out.println(s));
        //简化写法
        list.forEach(System.out::println);
    }
}

131 list集合 集合并发修改异常

132

自定义泛型类

泛型方法

泛型接口

泛型的上下限

134 set集合的特点：
无序、
不重复、
无索引：``没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素
set集合实现类的特点：
Hashset：无序、（一次无序）不重复、无索引
linkedHashset：有序、不重复、无索引
Treeset：排序、不重复、无索引
set集合打印出来都是元素内容

package set;

import java.util.HashSet;
import java.util.Set;

/**
 * set集合把重复的内容去掉一个，需要重写对象的equals和hashcode方法
 */
public class SetDemo {
    public static void main(String[] args) {
        Set<Student> sets = new HashSet<>(); //采用多态方式创建
        Student s1 = new Student("xiao1",20,'男');
        Student s11 = new Student("xiao1",20,'男');
        Student s2 = new Student("xiao2",22,'女');
        Student s3 = new Student("xiao3",23,'男');
        sets.add(s1);
        sets.add(s11);
        sets.add(s2);
        sets.add(s3);
        System.out.println(sets);  //没有重写equals和hashcode打印四个值，重写之后去重 
        // [Student{name='xiao2', age=22, sex=女}, Student{name='xiao1', age=20, sex=男}, Student{name='xiao3', age=23, sex=男}]
    }
}

package set;

public class Student {
    private String name;
    private int age;
    private char sex;

    public Student() {
    }

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        if (sex != student.sex) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        result = 31 * result + (int) sex;
        return result;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}

TreeSet集合默认规则
对于数值类型：Integer Double，按照大小进行升序排序；
对于字符串类型：按照首字符的编号进行升序排序
对于自定义类型，如Student对象，无法直接排序，需要制定规则
方式一：让自定义的类，student实现comparable接口，重写里面的compare To 方法来制定比较规则
方式二：TreeSet集合有参构造器，可以设置comparator接口对应的比较器对象，来制定比较规则

package set;

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

/**
 * TreeSet排序，方式一：让自定义的类，student实现comparable接口，重写里面的compare To 方法来制定比较规则
 */
public class SetDemo {
    public static void main(String[] args) {
        Set<Student> sets = new TreeSet<>();
        Student s1 = new Student("xiao1",25,'男');
        Student s11 = new Student("xiao1",20,'男');
        Student s2 = new Student("xiao2",22,'女');
        Student s3 = new Student("xiao3",23,'男');
        sets.add(s1);
        sets.add(s11);
        sets.add(s2);
        sets.add(s3);
        System.out.println(sets);
    }
}

package set;

public class Student implements Comparable<Student>{ //传参Student，alt+enter重写compare To方法
    private String name;
    private int age;
    private char sex;

    public Student() {
    }

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
    
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

    @Override
    public int compareTo(Student o) {
//        return this.age-o.age;// 如果==0认为重复，会去掉
        return this.age-o.age>=0?1:-1;// 如果有相等的也显示
    }
}

package set;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

/**
 * TreeSet排序
 */
public class SetDemo {
    public static void main(String[] args) {
//        Set<Student> sets = new TreeSet<>(new Comparator<Student>() {
//            //方式二，默认使用


//            @Override
//            public int compare(Student o1, Student o2) {
//                return o1.getAge()-o2.getAge();//升序
                return o2.getAge()-o1.getAge();//降序
//                //浮点型使用Double。compare
                return Double.compare(o1.getAge(),o2.getAge());//升序
//            }
//        });

        Set<Student> sets = new TreeSet<>(( o1, o2)->  Double.compare(o1.getAge(),o2.getAge()));

        Student s1 = new Student("xiao1",25,'男');
        Student s11 = new Student("xiao1",20,'男');
        Student s2 = new Student("xiao2",22,'女');
        Student s3 = new Student("xiao3",23,'男');
        sets.add(s1);
        sets.add(s11);
        sets.add(s2);
        sets.add(s3);
        System.out.println(sets);
    }
}

package set;

public class Student {
    private String name;
    private int age;
    private char sex;

    public Student() {
    }

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

}

135 集合的操作工具类Collections

package xulaoshi.collections;

import java.util.ArrayList;
import java.util.Collections;

public class CollectionDemo1 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
//        arrayList.add("ss");
//        arrayList.add("as");
//        arrayList.add("de");
//        arrayList.add("rfss");
        Collections.addAll(arrayList,"ss","kkk","hjk","jkk"); //批量添加
        System.out.println(arrayList);
        Collections.shuffle(arrayList);
        System.out.println(arrayList);
        Collections.sort(arrayList);  //升序排序
        System.out.println(arrayList);
    }
}

collection 排序

package xulaoshi.collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class CollectionDemo2 {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("11", "xiao", 33, "class1"));
        students.add(new Student("12", "xia2o", 21, "class2"));
        students.add(new Student("13", "xia3o", 29, "class3"));
        students.add(new Student("14", "xia4o", 18, "class4"));
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Integer.compare(o1.getAge(), o2.getAge());
            }
        });
        System.out.println(students);
        Collections.sort(students, (o1, o2) -> Integer.compare(o1.getAge(), o2.getAge()));
        System.out.println(students);
    }
}

137 map

import java.util.HashMap;
import java.util.Map;

public class MapDemo {
    public static void main(String[] args) {
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("红星艾克",3);
        hashMap.put("ss",1);
        hashMap.put("apple",2);
        hashMap.put("ss",2);  //键不能重复
        hashMap.put(null,null);
        System.out.println(hashMap); //{ss=2, null=null, apple=2, 红星艾克=3}
    }
}

import java.util.HashMap;
import java.util.Map;

public class MapDemo {
    public static void main(String[] args) {
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("红星艾克",3);
        hashMap.put("ss",1);
        hashMap.put("apple",2);
        hashMap.put("ss",2);  //键不能重复
        hashMap.put(null,null);
        System.out.println(hashMap); //{ss=2, null=null, apple=2, 红星艾克=3}
    }
}

map遍历方式一

package xulaoshi.map;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;

public class MapDemo {

    public static void main(String[] args) {
        Map<String, Integer> maps = new LinkedHashMap<>();
        maps.put("红星艾克",3);
        maps.put("python",1);
        maps.put("apple",2);
        maps.put(null,null);
        System.out.println(maps);
        //一键找值，先找到所有的键
        Set<String> keys = maps.keySet();
        for (String key : keys) {
            Integer value = maps.get(key);
            System.out.println(key+":"+value);
        }
        //二键值对,不推荐
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+":"+value);
        }
        //foreach遍历
        maps.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String key, Integer value) {
                System.out.println(key+":"+value);
            }
        });
        //foreach遍历简化写法
        maps.forEach((k, v)-> {
            System.out.println(k+":"+v);
                    });
    }
}

138

package xulaoshi.map;

import java.util.HashMap;
import java.util.Random;

public class MapDemo2 {
    public static void main(String[] args) {
        //把80个学生的数据拿过来
        String[] selects={"A","B","C","D"};
        StringBuilder sb = new StringBuilder();
        Random r = new Random();
        for (int i = 0; i < 80; i++) {
            sb.append(selects[r.nextInt(selects.length)]);
        }
        System.out.println(sb);
        //定义一个map集合定义最终的结果
        HashMap<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < sb.length(); i++) {
            char c = sb.charAt(i);
            //判断map集合是否存在键
            if (map.containsKey(c)){
                //让值加一
                map.put(c,map.get(c)+1);
            }else {
                map.put(c,1);
            }
        }
        //输出map
        System.out.println(map);
    }
}

139集合嵌套

package xulaoshi.map;

import java.util.*;

public class MapDemo3 {
    public static void main(String[] args) {
        //记录每个学生选择的情况
        HashMap<String, List<String>> data = new HashMap<>();
        //单个学生的选择情况
        ArrayList<String> selects = new ArrayList<>();
        Collections.addAll(selects, "A", "B");
        data.put("ss", selects);
        System.out.println(data);
        //单个学生的选择情况
        ArrayList<String> selects1 = new ArrayList<>();
        Collections.addAll(selects1, "A", "B", "D");
        data.put("er", selects1);
        System.out.println(data);
        //单个学生的选择情况
        ArrayList<String> selects2 = new ArrayList<>();
        Collections.addAll(selects2, "A", "C", "D");
        data.put("sanr", selects2);
        System.out.println(data);
        //统计每个景点选择的人数
        HashMap<String, Integer> infos = new HashMap<>();
        //提权所有人选择的经典信息
        Collection<List<String>> values = data.values();
        for (List<String> value : values) {
            for (String s : value) {
                if (infos.containsKey(s)) {
                    infos.put(s, infos.get(s) + 1);
                } else {
                    infos.put(s, 1);
                }
            }
        }
        System.out.println(infos);
    }

}

141 Stream流的作用？
简化集合数组的api，结合了lambda表达式

package stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class StreamDemo1 {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        Collections.addAll(names,"张三丰","张无忌","赵敏");
        System.out.println(names);
        //从集合中找出姓张的放到集合中
        List<String> zhangList = new ArrayList<>();
        for (String name : names) {
            if(name.startsWith("张")){
                zhangList.add(name);
            }
        }
        System.out.println(zhangList);
        //找名称长度是三的姓名
        List<String> zhangThreeList = new ArrayList<>();
        for (String name2 : zhangList) {
            if (name2.length()==3){
                zhangThreeList.add(name2);
            }
        }
        System.out.println(zhangThreeList);

        //使用Stream流实现
        names.stream().filter(s -> s.startsWith("张")&&s.length()==3).forEach(s -> System.out.println(s));
    }
}

package stream;

import java.util.*;
import java.util.stream.Stream;

public class StreamDemo2 {
    public static void main(String[] args) {
        /**------------Collection获取Stream------------------*/
        List<String> list = new ArrayList<>();
        Stream<String> s = list.stream();
        /**------------Map集合获取Stream------------------*/
        Map<String, Integer> maps = new HashMap<>();
        //键流
        Stream<String> keyStream = maps.keySet().stream();
        //值流
        Stream<Integer> valueStream = maps.values().stream();
        //键值对流
        Stream<Map.Entry<String, Integer>> keyAndValueStream = maps.entrySet().stream();
        /**------------数组获取Stream------------------*/
        String[] names = {"zhaomin", "xiaoWang"};
        Stream<String> nameStream = Arrays.stream(names);
        Stream<String> nameStream2 = Stream.of(names);
    }
}

常用api使用

package stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;

public class StreamDemo3 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰","张无忌","赵敏","周芷若","张三丰");
        list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
        long count = list.stream().filter(s -> s.length() == 3).count();
        System.out.println(count);
        //limit取前几个
        list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(System.out::println);
        //skip前几个
        list.stream().filter(s -> s.startsWith("张")).skip(2).forEach(System.out::println);
        //Map加工方法
        //给集合元素前面加上一个”黑马“
        list.stream().map(s -> "黑马"+s).forEach(System.out::println);
        //把所有的名称都加工成一个学生对象
//        list.stream().map(s -> new Student(s)).forEach(System.out::println);
        list.stream().map(Student::new).forEach(System.out::println);
    }
}

综合案例练习

package stream;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamDemo4 {
    public static double allMoney;
    public static double allMoney2;

    public static void main(String[] args) {
        List<Employee> one = new ArrayList<>();
        one.add(new Employee("猪八戒", '男', 30000, 25000, null));
        one.add(new Employee("孙悟空", '男', 25000, 1000, "顶撞上司"));
        one.add(new Employee("沙僧", '男', 20000, 20000, null));
        one.add(new Employee("小白龙", '男', 20000, 25000, null));

        List<Employee> two = new ArrayList<>();
        two.add(new Employee("猪八戒2", '男', 15000, 25000, null));
        two.add(new Employee("孙悟空2", '男', 20000, 1000, "顶撞上司"));
        two.add(new Employee("沙僧2", '男', 50000, 20000, null));
        two.add(new Employee("小白龙2", '女', 20000, 25000, "被打"));
        two.add(new Employee("小白龙22", '女', 20000, 0, null));
        //开发一部的最高工资
        //制定大小规则
//        Employee e = one.stream().max((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(), e2.getSalary() + e2.getBonus())).get();
//        System.out.println(e);
        TopperFormer topperFormer = one.stream().max((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(), e2.getSalary() + e2.getBonus()))
                .map(e -> new TopperFormer(e.getName(), e.getSalary() + e.getBonus())).get();
        System.out.println(topperFormer);

        //统计平均工资，去掉最高工资最低工资
        one.stream().sorted((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(), e2.getSalary() + e2.getBonus()))
                .skip(1).limit(one.size() - 2).forEach(e -> {
                    //求综合，剩余员工的总和
                    allMoney += (e.getSalary() + e.getBonus());
                });
        System.out.println("开发一部的平均工资是" + allMoney / (one.size() - 2));

        //合并两个集合，再统计
        Stream<Employee> s1 = one.stream();
        Stream<Employee> s2 = two.stream();
        Stream<Employee> s3 = Stream.concat(s1, s2);
        s3.sorted((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(), e2.getSalary() + e2.getBonus()))
                .skip(1).limit(one.size() + two.size() - 2).forEach(e -> {
                    allMoney2 += (e.getSalary() + e.getBonus());
                });
//        System.out.println("开发部门的平均工资是："+allMoney2/(one.size()+ two.size()-2));
        //解决精度问题
        BigDecimal a = BigDecimal.valueOf(allMoney2);
        BigDecimal b = BigDecimal.valueOf(one.size() + two.size() - 2);
        System.out.println("开发部门的平均工资是：" + a.divide(b, 2, RoundingMode.HALF_UP));
    }
}

package stream;

public class Employee {
    private String name;
    private char sex;
    private double salary;
    private double bonus;
    private String punish;

    public Employee() {
    }

    public Employee(String name, char sex, double salary, double bonus, String punish) {
        this.name = name;
        this.sex = sex;
        this.salary = salary;
        this.bonus = bonus;
        this.punish = punish;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public String getPunish() {
        return punish;
    }

    public void setPunish(String punish) {
        this.punish = punish;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", punish='" + punish + '\'' +
                '}';
    }
}

package stream;

public class TopperFormer {
    private String name;
    private double money;

    public TopperFormer() {
    }

    public TopperFormer(String name, double money) {
        this.name = name;
        this.money = money;
    }

    public String getName() {
        return name;
    }

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

    public double getMoney() {
        return money;
    }

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

    @Override
    public String toString() {
        return "TopperFormer{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

收集Stream流到集合或数组中去

package stream;

import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 收集Stream流到集合或数组中去
 */
public class StreamDemo5 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰","张无忌","赵敏");
        Stream<String> stream = list.stream().filter(s -> s.startsWith("张"));
        stream.toList();
//        List<String> zhangList = stream.collect(Collectors.toList());
//        System.out.println(zhangList);

        //注意流只能使用一次
        Set<String> zhangSet = stream.collect(Collectors.toSet());
        System.out.println(zhangSet);

        Stream<String> s3= list.stream().filter(s -> s.startsWith("张"));
        Object[] arrs = s3.toArray();
        System.out.println("数组内容"+ Arrays.toString(arrs));
    }
}

142-143

运行时异常，parse下面报错，alt+enter有两种处理异常方式
第一：throws，最终抛到jvm，出现问题仍然会运行失败
第二：try–catch

package Exception;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo {
    public static void main(String[] args) throws ParseException {
        String date = "2015-01-12 10:11:12";
        //创建一个简单的格式化日期类
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //解析字符串时间为日期对象
        Date d = sdf.parse(date);
        System.out.println(d);
    }
}

package Exception;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo {
    public static void main(String[] args) {
        String date = "2015-01-12 10:11:12";
        //创建一个简单的格式化日期类
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //解析字符串时间为日期对象
        Date d = null;
        try {
            d = sdf.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(d);
    }
}

143 处理方式一：如果有多个异常，可连续抛出，但实际上只执行了一个，先抛出去一个之后后面的代码就不会执行了，可一只抛出一个异常处理throws Exception；这种方式不好，发现异常不处理，最终还是抛给虚拟机，引起程序死亡。

处理方式二：try–catch，发生异常的方法自己独自去处理，程序可以继续往下执行

处理方式三：前两者结合，可以知道底层的调用情况
方法直接将Throws抛出给调用者
调用者收到异常后直接捕获处理 try-catch

package Exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo2 {
    public static void main(String[] args) {
        System.out.println("========开始========");
        parseTime("2011-11-11 01:12:13");
        System.out.println("========结束========");
    }
    public static void parseTime(String date){
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d = sdf.parse(date);
            System.out.println(d);
            FileInputStream fileInputStream = new FileInputStream("E:/ha.png");
        } catch (ParseException e) {
            e.printStackTrace();  //打印日常栈信息
            System.out.println("日期格式不对");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("您的文件没有");
        }
    }

}

建议写法，try-catch后抛Exception异常一次即可

package Exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo2 {
    public static void main(String[] args) {
        System.out.println("========开始========");
        parseTime("2011-11-11 01:12:13");
        System.out.println("========结束========");
    }
    public static void parseTime(String date){
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d = sdf.parse(date);
            System.out.println(d);
            FileInputStream fileInputStream = new FileInputStream("E:/ha.png");
        } catch (Exception e) {
            e.printStackTrace();  //打印日常栈信息
        }
    }

}

方式三推荐使用，底层异常往外抛，上层调用者捕获

package Exception;

import java.io.FileInputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo3 {
    public static void main(String[] args) {
        System.out.println("========开始========");
        try {
            parseTime("2011-11-11 01:12:13");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println("========结束========");
    }
    public static void parseTime(String date) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(date);
        System.out.println(d);
        FileInputStream fileInputStream = new FileInputStream("E:/ha.png");
    }
}

144自定义异常
使用try-catch包一层，解决，转换成Double类型的价格的错误，即使用户输入字符串，程序仍运行直到输入正常价格

package Exception;

import java.util.Scanner;

public class ExceptionDemo4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            try {
                System.out.println("请输入合法的价格");
                String priceStr = sc.nextLine();
                //转换成Double类型的价格
                Double price = Double.valueOf(priceStr);
                //判单价格是否大于0
                if (price > 0) {
                    System.out.println("定价" + price);
                    break;  //退出while
                } else {
                    System.out.println("价格必须是正数");
                }
            } catch (NumberFormatException e) {
                System.out.println("用户输入的数据有误，请输入正数");
            }
        }
    }
}

自定义异常案例

package Exception;

public class AgeilleageException extends Exception{
    /**
     * 继承Exception
     * 重写构造其
     */
    public AgeilleageException() {
    }

    public AgeilleageException(String message) {
        super(message);
    }
}

package Exception;

public class ExceptionDemo5 {
    public static void main(String[] args) {
        try {
            checkAge(-9);
        } catch (AgeilleageException e) {
            e.printStackTrace();
        }
    }
    public static void checkAge(int age) throws AgeilleageException {
        if (age<0||age>200){
            //抛出异常,用throw new 自定义对象抛出
            throw new AgeilleageException(age+"不合法");
        }else{
            System.out.println("年龄合法");
        }
    }
}