Day 5 2021.3.5异常补充-常用类

最新推荐文章于 2024-07-12 20:09:26 发布

hc1235

最新推荐文章于 2024-07-12 20:09:26 发布

阅读量148

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/hc1235/article/details/114415441

版权

java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

Day 5 ：2021.3.5

面向对象编程（opp）

异常体系

自定义异常

创建自定义异常类
在方法中通过throw关键字抛出异常对象
如果再当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
在出现异常方法的调用者中捕获并处理异常

自定义异常类:

package com.hong.Day005.Demo01;
//自定义的异常类
public class Demo01 extends Exception{
    //传递数字>10
    private int detail;
    public Demo01(int a){
        this.detail = a;
    }
    //toString:异常的打印信息(alt + shift + 0)

    @Override
    public String toString() {
        return "Demo01{" +
                "detail=" + detail +
                '}';
    }
}

调试代码：

package com.hong.Day005.Demo01;

public class Test {
    //可能会存在异常的方法
    static void test(int a)throws Demo01{
        System.out.println(a);
        if (a>10){
            throw new Demo01(a);//抛出
        }
        System.out.println("OK");
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (Demo01 demo01) {
            //增加一些处理异常的代码
            System.out.println(demo01);
        }
    }
}

添加知识

Static类

静态、非静态的变量与方法

package com.hong.Day004.Demo09;

public class Student {
    private static int age;//静态的变量
    private double score;//非静态的变量

    public void run(){

    }

    public static void go(){

    }
    public static void main(String[] args) {
        //非静态方法能够调用静态方法，静态方法也能够调用静态方法，但是不能调用非静态方法
        Student.go();
        new Student().run();
        //Student s1 = new Student();
        //System.out.println(Student.age);
        //System.out.println(s1.age);
        //System.out.println(s1.score);
    }
}

匿名代码块，静态代码块，构造代码

package com.hong.Day004.Demo09;

public class Person {
    {
        System.out.println("匿名代码块");
        //2.代码块（匿名代码块）:可以附一些初始值
    }
    static {
        System.out.println("静态代码块");
        //1.静态代码块  只执行一次
    }
    public Person(){
        //3.构造方法
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("================");
        Person person2 = new Person();
    }
}

静态导入包

package com.hong.Day004.Demo09;
//静态导入包
import static java.lang.Math.random;

public class Text {
    public static void main(String[] args) {
        System.out.println(random());
    }
}

修饰成员变量

主程序：

package com.hong.Day005.Demo06;

public class Demo01 {
    public static void main(String[] args) {
        Student one = new Student("郭靖",19);
        one.room = "101教室";
        System.out.println("姓名" + one.getName() + ",年龄" + one.getAge() + ",所在教室:" + one.room
                + ",学号:" + one.getId());
        Student two = new Student("黄蓉",16);
        System.out.println("姓名" + two.getName() + ",年龄" + two.getAge() + ",所在教室:" + two.room
                + ",学号:" + two.getId());
    }
}

Student：

package com.hong.Day005.Demo06;

public class Student {
    private int id;//学号
    private String name;//姓名
    private int age;//年龄
    static String room;//所在教室
    private static int idCounter = 0;//学号计数器
//    public Student(){
//        idCounter ++;
//    }
    public Student(String name, int age ) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

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

抽象类

abstract修饰符可以用来修饰方法也可以用来修饰类，如果修饰方法那该方法就是抽象方法；如果修饰类那该类就是抽象类。

抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

子类继承抽象类，那么就不虚要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

主程序:

package com.hong.Day004.Demo10;
//abstract 抽象类；类 extends 单继承   （接口可以多继承）
public abstract class Demo01 {
    //约束~有人帮我们实现
    //abstract,抽象方法,只有名字，没有实现
    public abstract void doSomething();

    //1.不能new这个抽象类，只能靠子类去实现他；约束
    //2.抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中
}

子类：

package com.hong.Day004.Demo10;
//抽象类的所有方法，继承了它的子类，都要实现它的抽象方法
public class A extends Demo01{
    @Override
    public void doSomething() {

    }
}

接口

普通类：只有具体的实现

抽象类：只有具体实现和规范（抽象方法）都有

接口：只有规范

声明接口的关键字是：interface

接口的作用：

约束
定义一些方法，让不同的人实现
```
public abstract //方法修饰
```
```
public static final //静态常量
```
接口不能被实例化，接口中没有构造方法
可以实现多可：implements
实现接口必须要重写接口中的方法

主程序

package com.hong.Day004.Demo11;
//类可以实现接口： implements
//实现了接口的类，必须要实现接口中的方法
//侧面实现了多继承
public class UserImpl implements User , Time {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

User：

package com.hong.Day004.Demo11;

//定义的关键字：interface,接口都要有实现类
public interface User {
    //属性默认常理
    int AGE = 99;
    //接口中的所有定义其实都是抽象的 public
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

Time:

一元数组打印：

System.out.println(Arrays.toString(a));

多元数组打印：

快捷键： array.for + ints.for

for (int[] ints : array1) {
    for (int anInt : ints) {
    }
}

random 类

取随机数：

package com.hong.Day005.Demo02;

import java.util.Random;

public class RandmoDemo1 {
    public static void main(String[] args) {
        Random random = new Random();
        int a = random.nextInt();//范围很大
        System.out.println(a);
        //random为左闭右开，即random.nextInt(3)，代表[0,3)
        double b = random.nextDouble();//0~1
        System.out.println(b);

    }
}

猜数字小游戏：

package com.hong.Day005.Demo02;

import java.util.Random;
import java.util.Scanner;

// 用代码模拟猜数字的小游戏
public class RandomDemo2 {
    public static void main(String[] args) {
        Random random = new Random();
        int a = random.nextInt(100)+1;
        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("请输入猜测的数字");
            int b =scanner.nextInt();
            if (b > a ){
                System.out.println("偏大了");
            }else if (b < a){
                System.out.println("偏小了");
            }else {
                System.out.println("恭喜答对");
                break;
            }
        }
    }
}

对象数组

主程序：

package com.hong.Day005.Demo02;

//定义一个数组，用来存储三个Person对象
public class Demo03Array {

    public static void main(String[] args) {
        Person[] array = new Person[3];
        Person one = new Person("迪丽热巴",18);
        Person two = new Person("古力娜扎",20);
        Person three = new Person("马尔扎哈",25);
        array[0] = one;
        array[1] = two;
        array[2] = three;
        System.out.println(array[0]);//地址值
        System.out.println(array[1]);//地址值
        System.out.println(array[2]);//地址值
        Person person = array[1];
        System.out.println(person.getName());//古力娜扎
    }
}

Person:

package com.hong.Day005.Demo02;

public class Person {
    private String name;
    private int age;

    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
}

ArrayList 类

ArrayList 的基础操作（String）

package com.hong.Day005.Demo03;

import java.util.ArrayList;

/*
数组的长度不可以发生改变
ArrayList的长度可以发生改变
对于ArrayList来说，有一个尖括号<E>代表集合内的元素类型相同
 add: 添加
 public boolean  add(E e):向集合当中添加元素，参数的类型和泛型一致。
 public E get(int index):从集合当中获取元素，参数就是索引的编号
 public E remove(int index):从集合当中删除元素，参数就是索引的编号
 public int size():获取集合的尺寸长度，返回值是集合中包含的元素个数
 */
public class Demo03 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);
        //添加元素  add 索引值从0开始
        list.add("0");
        list.add("1");
        list.add("2");
        System.out.println(list);
        //获取元素  get 索引值从0开始
        String name = list.get(1);
        System.out.println(name);
        //删除元素  remove
        String who = list.remove(1);
        System.out.println(who);
        System.out.println(list);
        //获得长度  size()
        int size = list.size();
        System.out.println(size);
        //遍历集合  (感觉必要不大)
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
        }
    }
}

Array基本类型操作

package com.hong.Day005.Demo03;

import java.util.ArrayList;
/*
基本类型     包装类（引用类型）
 short      Short
 byte       Byte
 int        Integer
 long       Long
 float      Float
 boolean    Boolean
 char       Character
 */
public class Demo04 {
    public static void main(String[] args) {
        ArrayList<String> a = new ArrayList();
        ArrayList<Integer> b = new ArrayList();
        ArrayList<Character> c = new ArrayList();


    }
}

练习题

生成随机整数，并添加

package com.hong.Day005.Demo03;

import java.util.ArrayList;
import java.util.Random;

public class Demo05 {
    public static void main(String[] args) {
        Random random = new Random();
        ArrayList<Integer> a =new ArrayList<>();
        for (int i = 0; i < 6; i++) {
           int b =random.nextInt(33)+1;
           a.add(b);
        }
        System.out.println(a);
        //遍历
        for (int i = 0; i < a.size(); i++) {
            System.out.println(a.get(i));
        }
    }
}

自定义对象并添加进集合

package com.hong.Day005.Demo03;

import java.util.ArrayList;

public class Demo06 {
    public static void main(String[] args) {
        ArrayList<Student> list =new ArrayList<>();
        Student b = new Student("1",1);
        Student c = new Student("2",2);
        Student d = new Student("3",3);
        list.add(b);
        list.add(c);
        list.add(d);
        //遍历
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(list.get(i).getName()+list.get(i).getAge());
        }
    }
}

打印集合方法

package com.hong.Day005.Demo04;

import java.util.ArrayList;

/*
定义以指定格式打印集合的方法（ArrayList类型作为参数），使用｛｝扩起集合，使用@分隔每个元素。
（元素@元素@元素）
 */
public class Demo01 {
    public static void main(String[] args) {
        ArrayList<String> list =  new ArrayList<>();
        list.add("张三丰");
        list.add("宋远桥");
        list.add("张无忌");
        list.add("张翠山");
        printArrayList(list);
    }

    public static void printArrayList(ArrayList<String> list) {
        System.out.print("{");
        for (int i = 0; i < list.size(); i++) {
            if (i == list.size()-1){
                System.out.print(list.get(i)+"}");
            }if (i == 0){
                System.out.print(list.get(i));
            } else{
                System.out.print("@"+list.get(i));
            }
        }
    }
}

筛选集合中的随机数

package com.hong.Day005.Demo04;

import java.util.ArrayList;
import java.util.Random;

/*
用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合中
 */
public class Demo02 {
    public static void main(String[] args) {
        ArrayList<Integer> a = new ArrayList<>();
        ArrayList<Integer> b = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 20; i++) {
            int aa = random.nextInt();
            a.add(aa);
            if (aa%2 == 0 ){
                b.add(aa);
            }
        }
        System.out.println(a);
        System.out.println(b);
    }
}

String 类

字符串的内容用不可变。
正是因为字符串不可改变，所以字符串是可以共享的。
字符串效果上相当于char[]字符数组，但底层原理是byte[]字节数组

字符串的创建

package com.hong.Day005.Demo04;

/*
常见的三种字符串构造方法
三种构造方法：
public String()
public String(char[] array),根据字符数组的内容，来创建对于的字符串
public String(byte[] array),根据字节数组的内容，来创建对于的字符串
直接创造
String str = "";
 */
public class Demo03 {
    public static void main(String[] args) {
        //使用空参构造
        String str = new String();
        System.out.println(str);
        //根据字符数组
        char[] a = { 'A', 'B', 'C' };
        String str2 = new  String(a);
        System.out.println(str2);
        //根据字节数组
        byte[] b = {97,98,99};
        String str3 = new String(b);
        System.out.println(str3);
    }
}

字符串的常量池

package com.hong.Day005.Demo05;
/*
字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中

对于基本类型来说，==是进行述职的比较
对于引用类型来说，==是进行地址值的比较
 */
public class Demo01 {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        char[] charArray = {'a','b','c'};
        String str3 = new String(charArray);
        System.out.println(str1 == str2);//true
        System.out.println(str1 == str3);//false
        System.out.println(str2 == str3);//false
    }
}

字符串的比较equals

equals：比较，严格区分大小写

equalsIgnoreCase：比较，不区分大小写

package com.hong.Day005.Demo05;
/*
==是进行对象的地址值比较，如果需要字符串的内容比较，可以使用两个方法
1. equals
public boolean equals(Object obj):参数可以是任何对象
备注：
1.任何对象都能用object进行接收
2.equals方法具有对称性，也就是a.equal(b)和b.equal(a)效果一样
3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面

2.public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较
 */
public class Demo02 {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] charArray = {'H','e','l','l','o'};
        String str3 = new String(charArray);
        System.out.println(str1.equals(str2));//true
        System.out.println(str1.equals(str3));//true
        System.out.println(str1.equals("Hello"));//true
        System.out.println(str1 == str3);//False

        String A = "java";
        String B = "Java";
        System.out.println(A.equals(B));//大小写严格区分
        System.out.println(A.equalsIgnoreCase(B));//不区分大小写
    }
}

字符串获取的相关方法

length()：获取字符串中含有字符的个数，即长度

concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串

charAt(int index)：获取指定索引位置的单个字符

indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值

package com.hong.Day005.Demo05;
/*
public int length()：获取字符串中含有字符的个数，即长度
public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串
public char charAt(int index)：获取指定索引位置的单个字符。(从0开始)
public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值
 */
public class Demo03 {
    public static void main(String[] args) {
        //获取字符串的长度
        int length = "asdafacacsa".length();
        System.out.println(length);

        //拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1);//Hello
        System.out.println(str2);//World
        System.out.println(str3);//HelloWorld
        System.out.println("===========================");

        //获取索引的单个字符
        char ch = "Hello".charAt(1);
        System.out.println(ch);
        System.out.println("===============================");
        //查找参数字符串在本来字符串当中出现的第一次索引值，若没有则返回-1
        String original = "HelloWorld";
        int index = original.indexOf("llo");
        System.out.println(index);


    }
}

字符串的截取方法

package com.hong.Day005.Demo05;
/*
public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串；
public String substring(int begin,int end)：截取从begin开始到end中间的字符串；
备注:[begin,end)，包含begin，不包含end
 */
public class Demo04 {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1);//HelloWorld
        System.out.println(str2);//World
        System.out.println("=================");
        String str3 = str1.substring(2,5);
        System.out.println(str3);//llo
    }
}

字符串的转换相关字符

package com.hong.Day005.Demo05;
/*
String当中与转换相关的常用方法：
public char[] toCharArray():将当前字符串拆分成为字符数组作为返回值
public byte[] getBytes():获得当前字符串底层的字节数组；
public String replace(CharSequence oldString, CharSequence newString):
将所有出现的老字符串替换成为新的字符串，返回替换后的结果新字符串
 */
public class Demo05 {
    public static void main(String[] args) {
        //转换为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars.length);//5
        System.out.println("=====================");

        //转换为字节数组
        byte[] bytes = "Hello".getBytes();
        System.out.println(bytes.length);//5
        System.out.println("=========================");

        //老字符替换新字符replace
        String str1 = "How do you do?";
        String str2 = str1.replace("o","*");
        System.out.println(str1);//How do you do?
        System.out.println(str2);//H*w d* y*u d*?
        System.out.println("=========================");
    }
}

字符串的分割方法

package com.hong.Day005.Demo05;
/*
分割字符串：
public String[] split(String regex):按照参数的规则，将字符串切分为若干部分
 split方法的参数其实是一个正则表达式
如果要用“.”进行切分必须使用“\\.”进行切分
 */
public class Demo06 {
    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
        System.out.println("================");
        String str2 = "aaa.bbb.ccc";
        String[] array2 = str2.split(".");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
        String str3 = "aaa.bbb.ccc";
        String[] array3 = str3.split("\\.");
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }
    }
}

练习：按指定格式拼接字符串

package com.hong.Day005.Demo05;

/*
定义一个方法，把数组{1，2，3}按照指定格式拼接成一个字符串，
格式如：[word1#word2#word3]
 */
public class Demo07 {
    public static void main(String[] args) {
        int[] a = {1,2,3};
        String s = pin(a);
        System.out.println(s);
    }
    public static String pin(int[] a ){
        String str = "[";
        for (int i = 0; i < a.length; i++) {
            if (i!=a.length-1){
                str += "word" + a[i] + "#";
            }else {
                str += "word" + a[i] + "]";
            }
        }
        return str;
    }
}

统计输入字符串中各个字符的个数

package com.hong.Day005.Demo05;

import java.util.Scanner;

/*
键盘输入一个字符串，并统计其中各个字符出现的次数
种类有：大写字母、小写字母、数字
 */
public class Demo08 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String a = scanner.next();
        int countUpper = 0;//大写字母
        int countLower = 0;//小写字母
        int countNumber = 0;//数字
        int countOther = 0;//其他字符
        char[] b = a.toCharArray();
        for (int i = 0; i < b.length; i++) {
            char c = b[i];
            if ('A'<= c && c<='Z'){
                countUpper ++ ;
            }else if ('a' <= c && c <= 'z'){
                countLower ++ ;
            }else if ('0' <= c && c <= '9'){
                countNumber ++;
            }else{
                countOther ++;
            }
        }
        System.out.println(countUpper+" ");
        System.out.println(countLower+" ");
        System.out.println(countNumber+" ");
        System.out.println(countOther+" ");
        scanner.close();
    }
}

Arrays类

常用方法

toString:将参数数组变成字符串

sort():按照默认升序对数组的元素进行排列

package com.hong.Day005.Demo07;

import java.util.Arrays;

/*
public static String toString(数组):将参数数组变成字符串（按照默认格式）
public static void sort(数组):按照默认升序对数组的元素进行排列
 */
public class Demo01 {
    public static void main(String[] args) {
        int[] intArray = {10,20,30};
        //将int数组以默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);

        int[] a = {2,1,3,10,6};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

习题：字符串倒序

package com.hong.Day005.Demo07;

import java.util.Arrays;

/*
将一个随机字符串倒序排列
 */
public class Demo02 {
    public static void main(String[] args) {
        String str = "sfscascasfasfvbg";
        //如何进行升序排列:sort
        //必须是一个数组才能进行升序排列
        char[] chars = str.toCharArray();
        Arrays.sort(chars);//对字符数组进行升序排列

        //需要倒序遍历for.rr 倒序快捷键
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
        }

    }
}

数学工具类Math

public static double abs(double num):获得绝对值;
public static double ceil(double num):向上取整;
public static double floor(double num):向下取整;
public static long round(double num):四舍五入;
Math.PI:代表近似的圆周率;

package com.hong.Day005.Demo07;
/*
public static double abs(double num):获得绝对值;
public static double ceil(double num):向上取整;
public static double floor(double num):向下取整;
public static long round(double num):四舍五入;
Math.PI:代表近似的圆周率;
 */
public class Demo3 {
    public static void main(String[] args) {
        //获取绝对值
    }
}

练习题

package com.hong.Day005.Demo07;
/*
计算在-10.8到5.9之间绝对值大于6或者小于2.1的整数有多少个?
 */
public class Demo04 {
    public static void main(String[] args) {
        int Count = 0;
        for (int i = (int) -10.8; i < 5.9; i++) {
            if (Math.abs(i) < 2.1 || Math.abs(i) > 6){
                Count++;
            }
        }
        System.out.println(Count);
    }
}

hc1235

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Day 5 2021.3.5异常补充-常用类

Day 5 ：2021.3.5面向对象编程（opp）异常体系自定义异常创建自定义异常类在方法中通过throw关键字抛出异常对象如果再当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作在出现异常方法的调用者中捕获并处理异常自定义异常类:package com.hong.Day005.Demo01;//自定义的异常类public class Demo01 extends Exc
复制链接

扫一扫