Javase面向对象9：异常、常用类

疯丰

已于 2022-05-12 07:49:06 修改

阅读量125

点赞数 2

分类专栏：大数据之javase基础文章标签： java 开发语言

于 2022-05-07 13:57:04 首次发布

本文链接：https://blog.csdn.net/weixin_43498449/article/details/124628870

版权

大数据之javase基础专栏收录该内容

29 篇文章 7 订阅

订阅专栏

1. 笔记

1.2 异常

1、什么是异常：
 指的是程序在执行过程中，出现的非正常的情况，如果不处理最终会导致JVM的非正常停止

2、异常处理方式
 （1）遇到错误就终止程序的运行
 （2）程序员编写代码处理

3、java异常体系结构
（1）Throwable顶层异常类
（2）Throwable两个子类
   Error：编译时候出现
   Exception（运行时异常）：执行时候出现
（3）两个常用方法
  getMessage() ：得到异常基本内容
  printStackTrace() ：得到异常详细信息

4、常见异常
（1）栈溢出异常：StackOverflowError
    //演示StackOverflowError
    @Test
    public void testStackOverflowError() {
        digui();
    }
    public void digui() {
        digui();
    }

（2）数组下标越界 ArrayIndexOutOfBoundsException
    //1 感受异常
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1,2,3};

        System.out.println(arr[3]);
    }

（3）空指针异常NullPointerException
    //空指针异常
    @Test
    public void testNullPointerException() {
        String[] names = new String[5];
        System.out.println(names[0].length());//字符串的长度
    }

（4）类型转换异常 ClassCastException
    //类型转换
    @Test
    public void testClassCastException() {
        Object obj = new Object();
        String str = (String) obj;
    }

（5）类型不匹配异常InputMismatchException
        //InputMismatchException
        Scanner input = new Scanner(System.in);
        System.out.print("请输入一个整数：");
        int num = input.nextInt();

（5）数学操作异常 ArithmeticException
    @Test
    public void test05(){
        int i = 1/0;
    }

5、运行时异常可以不处理，编译时异常必须进行处理

6、java异常抛出机制
（1）当前方法如果处理异常，后面调用者直接使用了
    如果当前方法不处理异常，由调用者处理

7、java异常处理-throw抛出异常
（1）throw  new  异常类名称(参数)
//throw抛出异常
public class ExceptionDemo2 {

    public static void main(String[] args) {

        //创建一个数组
        int[] arr = {2,4,52,2};  //null
        //根据索引找对应的元素
        int index = 4;
        //调用
        int arrayValue = getArrayValue(arr, index);
        System.out.println(arrayValue);
    }

    //根据下标获取数组值
    //int[] arr  数组 ,int index 数组下标
    public static int getArrayValue(int[] arr,int index) {
        //判断数组如何为空，抛出空指针异常
        if(arr == null) {
            //throw  new  异常类名称(参数)
            throw new NullPointerException("要访问的arr数组不存在");
        }
        //判断数组下标是否越界，如果越界抛出数组下标越界异常
        //数组最大下标 arr.length-1
        if(index < 0 || index > arr.length-1) {
            throw new ArrayIndexOutOfBoundsException("哥们，角标越界了");
        }
        //根据下标获取数组值
        int value = arr[index];
        return value;
    }
}


8、java异常处理-throws声明异常
//throws声明异常
public class ExceptionDemo3 {

    public static void main(String[] args) throws Exception {
       add();
    }

    //声明异常
    public static void add() throws Exception{
        System.out.println("add......");
    }
}
（1）将问题标识出来，报告给调用者。如果方法内通过throw抛出了**编译时异常**，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。
运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

（2）如果方法出现异常，可以在方法里面进行处理，如果方法不进行处理，异常声明出来，由调用者进行处理


9、java异常处理-try catch捕获异常
（1）捕获异常 try  catch
public class ExceptionDemo4 {

    public static void main(String[] args)  {
        //获取方法异常信息
        try {
            //正常执行代码
            add();
        } catch (Exception e) {
            //捕获异常
            System.out.println("异常.......");
//            String message = e.getMessage();
//            System.out.println(message);
           e.printStackTrace();
        }
    }

    //声明异常
    public static void add() throws Exception{
        //System.out.println("add......");
        int i = 1/0;
    }
}

（2）如果程序可能会出现多个异常，一般建议分别处理；或者直接写Exception进行处理
        try {

      } catch (FileNotFoundException e) {

      } catch (IllegalAccessException e) {
         e.printStackTrace();
      }


10、finally块
（1）try  catch  finally  或者 try  finally
（2）finally里面代码总会被执行，一般在finally放关闭资源代码
//捕获异常 try  catch finally
public class ExceptionDemo5 {

    public static void main(String[] args)  {
        try {
            System.out.println("程序开始执行了.......");
            int i = 1/0;
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            //总会被执行
            System.out.println("finally.......");
        }
    }
}


11、自定义异常
（1）异常类如何定义:**
   自定义一个编译期异常: 自定义类 并继承于`java.lang.Exception
   自定义一个运行时期的异常类:自定义类 并继承于`java.lang.RuntimeException

（2）继承Exception实现自定义异常
//自定义异常类
class RegisterException extends Exception {
    //无参数构造
    public RegisterException() {
    }

    //有参数构造
    public RegisterException(String message) {
        super(message);
    }
}

    //模拟注册 用户名重复判断
    public static boolean checkName(String name) throws RegisterException {
        //用户名是admin，提示已经存在
        if("admin".equals(name)) {
            //抛出异常
            throw new RegisterException("用户名已经存在");
        }
        return true;
    }

（3）继承RuntimeException实现自定义异常
//自定义异常类
class RegisterException extends RuntimeException {
    //无参数构造
    public RegisterException() {
    }

    //有参数构造
    public RegisterException(String message) {
        super(message);
    }
}

1.2 常用类

（前面已经写过一些数学类，这里主要完整介绍字符串，非常重要）

 1、 字符串 ☆☆☆☆☆
（1）字符串不是基本数据类型，字符串使用双引号包起来 "abcd"

（2）字符串String类型本身是final声明的，不能继承String。

（3）字符串的对象也是不可变对象，意味着一旦进行修改，就会产生新对象

（4）创建字符串
    public static void main(String[] args) {
        //第一种
        String str1 = "abc";

        //第二种
        String str2 = new String("www");

        //第三种
        char data[] = {'a', 'b', 'c'};
        String str3 = new String(data);
    }

（5）jvm结构：栈   堆   方法区
JDK1.6及其之前：常量池放到方法区
JDK1.7：常量池放到堆
JDK1.8：常量池放到元空间（没有方法区）

（6）如果使用String str1 = "abc";创建字符串，存储结构
* 在方法区创建对象 abc
* 在栈指向方法区对象（引用）
* 方法区对象可以被共享

（7）如果使用String str2 = new String("www");创建字符串，存储结构
* 首先在方法区创建对象 www
* 在堆创建方法对象副本 www
* 方法区对象和堆里面指向同一个数组
* 在栈在栈指向堆对象（引用）

2、字符串操作常用方法
public class StringDemo2 {

    public static void main(String[] args) {
       //  获取字符串长度 length()
        String str1 = "abcd";
        int length = str1.length();
        //System.out.println(length);

        //String concat(xx)：拼接，等价于+
        String str2 = "atguigu";
        String newStr = str2.concat(str1);
        //System.out.println(newStr);

        //toUpperCase
        String str3 = "lucymary";
        String newStr1 = str3.toUpperCase();
       // System.out.println(newStr1);

        //contains(xx)：是否包含xx
        boolean flag = str3.contains("l");
       // System.out.println(flag);

        //indexOf(xx)：查找字符串中字符位置
        String str4 = "lucymary";
        int c = str4.indexOf("c");
        //System.out.println(c);

        //lastIndexOf(xx)：最后一个查找字符位置
        String str5 = "l-u-c-y";
        int i = str5.lastIndexOf("-");
        //System.out.println(i);

       //substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
        String str6 = "lucy";
        //String substring = str6.substring(1);
       // System.out.println(substring);

        //substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

        String str7 = "lucymary";
//        String substring = str7.substring(1,3);
//        System.out.println(substring);

        // charAt(index)：返回[index]位置的字符
        char c1 = str7.charAt(2);
        System.out.println(c1);

    }
}


3、字符串拼接相关问题
（1）java字符串拼接约定原则
   第一、常量+常量：结果是常量池
   第二、常量与变量 或 变量与变量：结果是堆
   第三、拼接后调用intern方法：结果在常量池
   第四、concat方法拼接，结果都是在堆

4、字符串操作其他方法
（1）charAt方法：获取指定位置字符
    public static void main(String[] args) {
        //charAt方法：获取指定位置字符
        String str = "abcd";
        char c = str.charAt(2);
        System.out.println(c);
    }
（2）Arrays类相关方法

（3）boolean startsWith(xx)：是否以xx开头

（4）boolean endsWith(xx)：是否以xx结尾


5、字符串编码问题
    //演示字符串编码操作
    @Test
    public void test01() throws UnsupportedEncodingException {
        String str = "尚硅谷";
        System.out.println(new String(str.getBytes("ISO8859-1"), "ISO8859-1"));// 乱码
        System.out.println(new String(str.getBytes("GBK"), "GBK"));// 中国
        System.out.println(new String(str.getBytes("UTF-8"), "UTF-8"));// 中国
    }

iso8859-1  gbk  utf-8


6、正则匹配
- 定义：一组验证数据的规则

- 常用语法格式：

  **第一种** **直接定义**

   验证规则

  **第二种** **（使用这种方法）**

  ^[验证规则]{验证次数}$

   @Test
   public void test1(){
      //简单判断是否全部是数字，这个数字可以是1~n位
      String str = "12a345";

      //正则不是Java的语法，它是独立与Java的规则
      //在正则中\是表示转义，
      //同时在Java中\也是转义
      boolean flag = str.matches("\\d+");
      System.out.println(flag);
   }


7、字符串操作其他方法
（1）替换方法
replace("要替换内容","替换成内容")：不支持正则
replaceFirst("要替换内容（正则）","替换成内容")：替换第一个匹配部分
repalceAll("要替换内容（正则）","替换成内容")：替换所有匹配部分
    //替换
    @Test
    public void test2() {
        String str = "abcd-ddew-ewdd-sssw";
        String newStr = str.replaceAll("-", "");
        System.out.println(newStr);
    }

（2）拆分方法
    //拆分
    @Test
    public void test3() {
        String str = "a-b-c-d";
        String[] values = str.split("-");
        System.out.println(Arrays.toString(values));
    }


8、可变字符操作
（1）StringBuffer Bulider
public class StringMethod2 {

    public static void main(String[] args) {

    }

    //删除
    @Test
    public void test03(){
        StringBuilder s = new StringBuilder("helloworld");
        //s.delete(1, 3);  //[1,3)
        s.deleteCharAt(1);
        System.out.println(s);
    }

    //insert
    @Test
    public void test02() {
        StringBuilder stringBuilder = new StringBuilder("helloworld");
        stringBuilder.insert(2,"atguigu");
        System.out.println(stringBuilder);
    }

   //追加
    @Test
    public void test01() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("hello").append(true).append('a').append(12).append("atguigu");
        //.toString(
        System.out.println(stringBuilder);
    }
}

9、日期时间操作
public class DateTimeDemo {

    //获取当前系统日期时间
    @Test
    public void test01() {
        Date date = new Date();
        System.out.println(date);
    }

    //获取当前时间毫秒数
    @Test
    public void test02() {
        long mill = System.currentTimeMillis();
        System.out.println(mill);
        //当前系统时间距离1970-1-1 0:0:0 0毫秒的时间差，毫秒为单位
    }

    //获取当前时间毫秒数
    @Test
    public void test03() {
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);
    }

    //获取当前系统日期时间，格式
    @Test
    public void test04() {
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new
               SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        String dateTime = simpleDateFormat.format(date);
        System.out.println(dateTime);
    }
}

2. 练习

2.1 异常练习

练习一：

1、声明Husband类，包含姓名和妻子属性，属性私有化，提供一个Husband(String name)的构造器，重写toString方法，返回丈夫姓名和妻子的姓名

2、声明Wife类，包含姓名和丈夫属性，属性私有化，提供一个Wife(String name)的构造器，重写toString方法，返回妻子的姓名和丈夫的姓名

3、声明TestMarry类，在main中，创建Husband和Wife对象后直接打印妻子和丈夫对象，查看异常情况，看如何解决

public class TestException {
	public static void main(String[] args) {
		Husband h = new Husband("张三");
		Wife w = new Wife("李四");
		/*	
		 * 发生空指针异常，因为丈夫的妻子属性和妻子的丈夫属性没有赋值	
		System.out.println(h);
		System.out.println(w);*/
		
		h.setWife(w);
		w.setHusband(h);
		System.out.println(h);
		System.out.println(w);
	}
}
class Husband{
	private String name;
	private Wife wife;
	public Husband(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Wife getWife() {
		return wife;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
	@Override
	public String toString() {
		return "Husband [name=" + name + ", wife=" + wife.getName() + "]";
	}
	
}
class Wife{
	private String name;
	private Husband husband;
	public Wife(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Husband getHusband() {
		return husband;
	}
	public void setHusband(Husband husband) {
		this.husband = husband;
	}
	@Override
	public String toString() {
		return "Wife [name=" + name + ", husband=" + husband.getName() + "]";
	}
	
}

2.2 字符串练习

练习一：模拟一个trim方法，去除字符串两端的空格

	public static void main(String[] args) {
		String str ="    he   llo   ";
		System.out.println(myTrim(str));
		System.out.println(myTrim2(str));
		System.out.println(myTrim3(str));
	}
	
	public static String myTrim3(String str){
		//利用正则表达式
		//^表示开头    \s表示  空白符   *表示0次或多次     |表示或者    $表示结尾
		return str.replaceAll("(^\\s*)|(\\s*$)", "");
	}
	
	public static String myTrim2(String str){
		while(str.startsWith(" ")){
			str = str.replaceFirst(" ", "");
		}
		while(str.endsWith(" ")){
			str = str.substring(0, str.length()-1);
		}
		return str;
	}
	
	public static String myTrim(String str){
		char[] array = str.toCharArray();
		int start =0;
		for(int i=0;i<array.length;i++){
			if(array[i] == ' '){
				start++;
			}else{
				break;
			}
		}
		int end = array.length-1;
		for(int i=end;i>=0;i--){
			if(array[i] == ' '){
				end--;
			}else{
				break;
			}
		}
		
		String result = str.substring(start,end+1);
		
		return result;
	}

练习二：

将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefgho”反转为”abfedcgho”

public static void main(String[] args) {
		String str ="abcdefgho";
		System.out.println(str);
		System.out.println(reverse(str,2,5));

	}
	
	//从第start个字符，到第end个字符
	public static String reverse(String str,int start,int end){
		char[] array = str.toCharArray();
		for(int i = start,j=end;i< j;i++,j--){
			char temp =array[i];
			array[i]=array[j];
			array[j]=temp;
		}
		String s = new String(array);
		return s;
	}

练习三：

获取一个字符串在另一个字符串中出现的次数。

比如：获取"ab"在 “abababkkcadkabkebfkabkskab”中出现的次数

	public static void main(String[] args) {
		String str1="ab";
		String str2="abababkkcadkabkebfkabkskab";
		System.out.println(count(str1,str2));
	}
	
	public static int count(String str1,String str2){
		int count =0;
		do{
			int index = str2.indexOf(str1);
			if(index !=-1){
				count++;
				str2 = str2.substring(index + str1.length());
			}else{
				break;
			}
			
		}while(true);
		return count;
	}

练习四：

获取两个字符串中最大相同子串。比如：

str1 = "abcwerthelloyuiodef“;str2 = "cvhellobnm"

提示：将短的那个串进行长度依次递减的子串与较长的串比较。

	public static void main(String[] args) {
		String str=findMaxSubString("abcwerthelloyuiodef","cvhellobnm");
		System.out.println(str);
	}
	
	//提示：将短的那个串进行长度依次递减的子串与较长的串比较。
	public static String findMaxSubString(String str1,String str2){
		String result="";
		
		String mixStr = str1.length()<str2.length()?str1:str2;
		String maxStr = str1.length()>str2.length()?str1:str2;
		
		//外循环控制从左到右的下标，内循环控制从右到左的下标
		for(int i=0;i<mixStr.length();i++){
			for(int j=mixStr.length();j>=i;j--){
				String str=mixStr.substring(i, j);
				if(maxStr.contains(str)){
					//找出最大相同子串
					if(result.length()<str.length()){
						result = str;
					}
				}
			}
		}
		return result;
	}

疯丰

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Javase面向对象9：异常、常用类

笔记异常1、什么是异常：指的是程序在执行过程中，出现的非正常的情况，如果不处理最终会导致JVM的非正常停止2、异常处理方式（1）遇到错误就终止程序的运行（2）程序员编写代码处理3、java异常体系结构（1）Throwable顶层异常类（2）Throwable两个子类 Error：编译时候出现 Exception（运行时异常）：执行时候出现（3）两个常用方法 getMessage() ：得到异常基本内容 printStackTrace() ：得到异常详
复制链接

扫一扫