Day 21 学习分享 - 异常处理和String类

1. 异常处理

1.1 Exception的两种处理方式概述

【捕获】
	有能力处理就捕获, 自己的问题也捕获
【抛出】
	没有办法处理就抛出, 或者, 不是自己的问题,和自己无关因别人导致的错误也抛出

1.2 捕获异常

1.2.1 基本格式

格式:
	try {
		// 有可能出现问题的代码
	} catch (异常类型) {
		// 对应当前异常类型的处理方式
	}

1.2.2 细节问题和注意事项

1. 代码中出现异常, JVM会终止代码运行, 如果使用try catch捕获处理异常, JVM会认为当前代码中不存在异常, 可以继续运行

2. 在try大括号内或者catch大括号内定义的变量都是局部变量, 处理操作数据时要小心

3. try catch 捕获处理异常, 可以处理多种异常情况, 而且建议异常处理分门别类

4. 代码中存在多种隐患, 存在多个异常情况的时候, try catch捕获有且只能处理第一个出现异常的代码, 因为JVM从异常代码开始直接进入异常捕获阶段

5. Exception作为Java中所有异常的超类, 在捕获异常处理时如果直接使用Exception进行捕获处理, 无法做到异常对症下药操作

6. Exception可以作为try catch最后一个代码, 用于处理其他异常捕获之后没有对症方式的遗留问题[不多见]

1.3 抛出异常

1.3.1 基本格式

关键字:
	thorw
		在方法内特定条件下抛出指定异常
	throws
		在【方法声明】位置, 告知调用者, 当前方法有哪些异常抛出

	用于处理非当前方法操作问题, 导致出现的异常, 一般情况下是用于处理方法运行过程中因为传输传入, 参数处理, 运算结果导致的问题, 抛出异常
	throw是一个高级的参数合法性判断

/*
	 * throws 关键字在方法声明位置告知当前方法的调用者, 这里存在异常信息
	 */
	/**
	 * 测试方法
	 * @param num1 int类型参数
	 * @param num2 int类型参数
	 * @throws ArithmeticException 如果除数为0, 当前方法抛出算数异常
	 */
	public static void test(int num1, int num2) 
			throws ArithmeticException {
		
// 		参数合法性判断之前的方式 low
//		if (0 == num2) {
//			System.out.println("错误");
//			System.exit(0);
//		}
		
		// 参数合法性判断, 如果num2 为0, 这里存在隐患
		if (0 == num2) {
			/*
			 * 存在异常, 这里创建一个异常对象抛出, 这里构造方法中
			 * 存在无参数构造方法和有参数构造方法
			 * 无参数构造方法异常信息为null
			 * 有参数构造方法可以传入一个String类型数据, 异常信息为指定字符串内容
			 */
			throw new ArithmeticException("除数不能为0");
		}
		int ret = num1 / num2;
		System.out.println(ret);
	}

1.3.2 细节问题和注意事项

1. 代码如果运行到throw抛出异常, 之后的代码不再运行, 之后的代码会成为无法触及代码

2. 代码中存在多种隐患, 按照隐患的情况, 分门别类处理, 不能再一个条件内抛出两个异常, 并且在方法的声明位置, throw之后, 不同的异常使用逗号隔开

3. 当调用带有异常抛出的方法时, 对于方法抛出的异常, 有两种处理方式, 可以捕获处理也可以抛出处理

1.4 抛出处理和捕获处理选择

情况分析:
	用户查询指定路径指定名字的文件, 存在的异常处理分析过程

1.5 异常分类

运行时异常
	RuntimeException diamante运行过程中出现的异常, 没有强制处理的必要性
        ArrayIndexOutOfBoundsException 数组下标越界异常
        NullPointerExcetpion 空指针异常
        ArithmeticException 算术异常
	
	运行时异常不强制要求捕获和抛出!
	JVM会处理RuntimeException, 也就是告知异常的前因后果
	
	
其他异常
	强制要求处理, 不管是捕获处理, 还是抛出处理, 都需要进行操作
	如果未处理, 直接报错!

1.6 自定义异常

KFC 
	情侣套餐半价
	但是你单身
	业务逻辑存在需求, 但是Java中没有合适的异常来描述对应情况, 自定义异常
	
自定义单身狗异常
	PFSP
		private final static Person
		
自定义异常格式:
	class MyException extends Exception {
		// 无参数构造方法
		public MyException() {}
		// 有参数构造方法, 且参数数据类型为String类型
		public MyException(String message) {
			super(message);
		}
	}
【注意】
	Eclipse会提示要求完成一个ID号, 可以忽略 存在一个警告

package com.qfedu.a_exception;

public class Demo3 {
	public static void main(String[] args) 
			throws SingleDogException {
		try {
			buyOneFreeOne(false);
		} catch (SingleDogException e) {
			
		}
		
		buyOneFreeOne(true);
	}
	
	/**
	 * 买一送一方法, 如果有女朋友满足要求, 如果没有不满足要求
	 * @param hasGirlFriend boolean类型数据, 判断是否有女朋友
	 * @throws SingleDogException SingleDog 单身狗异常
	 */
	public static void buyOneFreeOne(boolean hasGirlFriend) 
			throws SingleDogException {
		if (false == hasGirlFriend) { // !hasGirlFriend
			throw new SingleDogException("路见不平一声吼, 你还没有女朋友");
		}
		
		System.out.println("3RMB甜筒 买一送一");
	}
}

1.7 异常处理总结

1. 异常存在的必要性! 因为数据大多数来源于用户, 所以我们的数据是不可靠的, 需要我们的程序有一定的错误意识, 反馈机制和处理机制

2. 异常处理方式
	捕获
	抛出
	要根据使用情况, 操作方法, 反馈形式来选择对应的处理方式

3. 自定义异常, 了解异常的构造, 基本在开发中用到自定义异常的情况不多见, 但是要了解关于异常信息保存的方式

2. String 类

2.1 字符串类型概述

	字符串基本上就是数据的保存, 传输, 处理, 非常重要的一种手段, 但是同时, 他的解析过程很繁琐, 需要掌握熟记很多的方法, 同时需要一定的技巧和灵性
	
	String 字符串类型是Java中的引用数据类型, 并且String类型是使用final修饰的, 没有自己的子类

2.2 字符串内存分析和equals方法

package com.qfedu.b_string;

public class Demo1 {
    public static void main(String[] args) {
        String str1 = "烤羊排";
        String str2 = "烤羊排";
        String str3 = new String("烤羊排");
        String str4 = new String(str1);
        
        /*
		 * tfff
		 * == 等于判断是比较两个变量中保存的数据是否一致
		 * String str1 str2 str3 str4 都是引用数据类型的变量, 也就是==判断比			   较的是str1 ~ str4中保存的空间首地址
		 */
		System.out.println("str1 == str2 :" + (str1 == str2));
		System.out.println("str2 == str3 :" + (str2 == str3));
		System.out.println("str3 == str4 :" + (str3 == str4));
		System.out.println("str4 == str1 :" + (str4 == str1));
        
        /*
		 * 字符串如何比较是否一致?
		 * 
		 * Java中规定, 字符串比较要采用equals方法来完成, 并且使用的equals方法是			  String类
		 * 重写Object类内的方法, 比较方式是比较字符串内容
		 * tttt
		 */
		
		System.out.println("str1.equals(str2) :" + str1.equals(str2));
		System.out.println("str2.equals(str3) :" + str2.equals(str3));
		System.out.println("str3.equals(str4) :" + str3.equals(str4));
		System.out.println("str4.equals(str1) :" + str4.equals(str1));
    }
}

2.3 获取方法

int length();
    获取字符串的长度
   
char charAt(int index);
	从字符串中获取对应下标位置的字符(存在下标越界问题)

int indexOf(String str);
	找出指定字符串在当前字符串中的下标位置
    "ABCDEFGABCDEFG"
    查询"DE" ==> result 3
        
int lastIndexOf(char ch);
	找出指定字符最后一次出现的下标位置
    "ABCDABCD"
    查询"B" ==> result 5

package com.qfedu.b_string;

public class Demo2 {
	public static void main(String[] args) {
		String str = "ABCDEFGABCDEFG";
		
		// length方法
		System.out.println("str.length():" + str.length());
		
		// charAt方法
		System.out.println("str.charAt(5):" + str.charAt(5));
		System.out.println("str.charAt(0):" + str.charAt(0));
		
		// StringIndexOutOfBoundsException 字符串下标操作越界异常 字符串长度为14, 有效下标为0 ~ 13
		// System.out.println("str.charAt(14):" + str.charAt(14));
		
		// indexOf方法
		System.out.println("str.indexOf(\"CD\"): " + str.indexOf("CD"));
		System.out.println("str.indexOf(\"CD\"): " + str.indexOf('C'));
		
		// lastIndexOf方法
		System.out.println("str.lastIndexOf(\"CD\"): " + str.lastIndexOf("CD"));
		System.out.println("str.lastIndexOf(\"CD\"): " + str.lastIndexOf('C'));
	}
}

2.4 判断方法

Boolean endsWith(String str);
	判断当前字符串是不是自定字符串结尾, 如果是返回true, 如果不是返回false
       
boolean startsWith(String str);
	判断当前字符串是不是自定字符串开头, 如果是返回true, 如果不是返回false
        
boolean isEmpty();
	判断当前字符串是否为空, 空字符串是指" " 双引号什么都没有
        
boolean contain(CharSequence);
	判断该指定字符串是否是当前字符串的子字符串
        当前字符串
        	"ABCDEFG";
		参数字符串
            "CDE"; ==> result true;
		参数字符串
            "CE"; ==> result false
    原码是调用String类的indexOf方法, 找出指定字符串的下标位置, indexOf方法下标为大于等于0, 返回true, 否则返回false
        
boolean equals(Object object);
	重写 Override Object类内的方法, 判断两个字符串是否一致
        
boolean equalsIgnoreCase(String anotherString);
	忽略大小写比较, 不考虑英文大小写方式比较两个字符串是否一致

package com.qfedu.b_string;

public class Demo3 {
	public static void main(String[] args) {
		String str = "ABCDEFGABCDEFG";
		
		// endsWith方法
		System.out.println("str.endsWith(\"FG\") :" + str.endsWith("FG"));
		System.out.println("str.endsWith(\"GF\") :" + str.endsWith("GF"));
		
		// startsWith方法
		System.out.println("str.startsWith(\"AB\") :" + str.startsWith("AB"));
		System.out.println("str.startsWith(\"AB\") :" + str.startsWith("BA"));
		
		// isEmpty方法
		System.out.println("str.isEmpty() :" + str.isEmpty());
		System.out.println("\"\".isEmpty() :" + "".isEmpty());
		
		// contains方法
		System.out.println("str.contains(\"ABCD\") :" + str.contains("ABCD"));
		System.out.println("str.contains(\"ABCD\") :" + str.contains("ACBD"));
		
		// equalsIgnoreCase方法
		System.out.println("ABCDEFG".equalsIgnoreCase("AbcDeFg"));
	}
}

2.5 转换字符

String(char[] value);
	将字符串数组转换为字符串
        
String(char[] value, int offset, int count);
	将字符串数组转换为字符串, 从指定offset位置开始, 计数count
        例如:
			char[] arr = {'A', 'B', 'C', 'D', 'E'};
		调用方法参数:
			new String(arr, 2, 3); ==> result "CDE"
                
static String valueOf(char[] data);
	同理 String(char[] value);
	tips: 底层代码是 return new String(data)
        
static String valueOf(char[] data, int offset, int count)
    同理 String(char[] value, int offset, int count);
	tips: 底层代码是 return new String(data, offset, count)
        
char[] toCharArray()
    将字符串转换为字符数组
        例如:
			"ABCDE";
		返回值:
			{'A', 'B', 'C', 'D', 'E'};

package com.qfedu.b_string;

public class Demo4 {
	public static void main(String[] args) {
		char[] arr = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
		
		String str = new String(arr);
		System.out.println(str);
		
		String str2 = new String(arr, 3, 3);
		System.out.println(str2);
		
		String str3 = String.valueOf(arr);
		System.out.println(str3);
		
		String str4 = String.valueOf(arr, 3, 3);
		System.out.println(str4);
		
		char[] charArray = "你好这里是骚磊电台".toCharArray();
		for (int i = 0; i < charArray.length; i++) {
			System.out.println(charArray[i]);
		}
	}
}

2.6 其他方法

String replace(char oldChar, char newChar);
	替换使用newChar字符类型, 替换当前字符串内的所有自定字符oldChar
        例如:
			"ABCDEABCDE";
		调用方法:
			"ABCDEABCDE".replace('A', '你');
		返回值结果:
			"你BCDE你BCDE"; 【注】 原字符串不变
                
String[] split(String regex); 
	【重点】切割, 将当前字符串按照指定字符串切割成String类型数组
        例如:
			String str = "你好, 他好, 大家好, 广州好迪";
            调用方法:
                str.split(", ");
            返回值结果:
                String[] arr = {"你好", "他好", "大家好", "广州好迪"}
		例如2:
			String str = "你好, 他好, 大家好, 广州好迪";
			调用方法:
				str.split("好");
			返回值结果:
				String[] arr = {"你", ", 他", ", 大家", ", 广州", "迪"} 

String substring(int beginIndex);
	从指定beginIndex开始, 到字符串结尾, 截取字符串
        例如:
			String str = "ABCDEFG";
		调用方法:
			str.substring(3);
		返回值结果:
			"DEFG";

String substring(int beginIndex, int endIndex);
	从指定beginIndex开始, 到endIndex结束, 截取字符串
    要头不要尾 beginIndex <= 结果范围 < endIndex
    	例如:
			String str = "ABCDEFG";
		调用方法:
			str.substring(3, 5);
		返回值结果:
			"DE";
                                         
String toUpperCase();
	将字符串中的小写英文字符转换为大写
                                         
String toLowerCase();
	将字符串中的大写英文字符转换为小写                                        
String trim();
	去除字符串[两边]的空格

package com.qfedu.b_string;

import java.util.Arrays;

public class Demo5 {
	public static void main(String[] args) {
		String str = "ABCDEFGABCDEFG";
		
		String replace = str.replace('A', '你');
		
		System.out.println(str);
		System.out.println(replace);
		
		String str1 = "你好, 他好, 大家好, 广州好迪";
		String[] split = str1.split(", ");
		// Arrays数据工具类的toString方法, 数组中的元素会使用, 分割
		System.out.println(Arrays.toString(split));
		for (int i = 0; i < split.length; i++) {
			System.out.println(split[i]);
		}
		
		String substring = str.substring(5);
		System.out.println(substring);
		
		String substring2 = str.substring(5, 9);
		System.out.println(substring2);
		
		System.out.println("abcdefg".toUpperCase());
		System.out.println("ABCDEFG".toLowerCase());
		
		String str2 = "           asdf          asdfasfd             ";
		System.out.println(str2);
		System.out.println(str2.trim());
	}
}