Day 5 2021.3.5异常补充-常用类

Day 5 :2021.3.5

面向对象编程(opp)

异常体系

自定义异常

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

自定义异常类:

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

接口的作用:

  1. 约束

  2. 定义一些方法,让不同的人实现

  3. public abstract //方法修饰
    
  4. public static final //静态常量
    
  5. 接口不能被实例化,接口中没有构造方法

  6. 可以实现多可:implements

  7. 实现接口必须要重写接口中的方法

主程序

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 类

  1. 字符串的内容用不可变。
  2. 正是因为字符串不可改变,所以字符串是可以共享的。
  3. 字符串效果上相当于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);
    }
}
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 1024 设计师:白松林 返回首页