异常|常用类

最新推荐文章于 2024-05-14 13:59:20 发布

小小小太阳001

最新推荐文章于 2024-05-14 13:59:20 发布

阅读量559

点赞数

本文链接：https://blog.csdn.net/yudi1523/article/details/100974726

版权

异常

Error:错误:一般是由虚拟机生成并脱出的,程序员无法解决
Exception: 异常
CheckException 编译时异常: 编译时期就会出现的异常 ,如果出现了编译时异常不处理,程序无法运行
RuntimeException 运行时异常 : 运行时期会出现的异常 ,所有的运行时异常都会直接或者间接的继承自RuntimeException,可通过增强程序的健壮性处理 if判断

常见的运行时异常:
1.空指针异常 java.lang.nullpointerexception
简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。
2. java.lang.classnotfoundexception
　　这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。
　　3. java.lang.arithmeticexception
　　这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。
　　4. java.lang.arrayindexoutofboundsexception
　　这个异常相信很多朋友也经常遇到过，异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。
　　5. java.lang.illegalargumentexception
　　这个异常的解释是"方法的参数错误"，很多j2me的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setcolor(int red,int green,int blue)这个方法中的三个值，如果有超过２５５的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。
　　6. java.lang.illegalaccessexception
　　这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。

算术异常类：ArithmeticExecption

空指针异常类：NullPointerException

类型强制转换异常：ClassCastException

数组负下标异常：NegativeArrayException

数组下标越界异常：ArrayIndexOutOfBoundsException

违背安全原则异常：SecturityException

文件已结束异常：EOFException

文件未找到异常：FileNotFoundException

字符串转换为数字异常：NumberFormatException

操作数据库异常：SQLException

输入输出异常：IOException

方法未找到异常：NoSuchMethodException

throw 制造异常

throws 异常抛出 ***

try…catch 异常捕获 ***

   	try{
   		可会出现异常的代码...
   	}catch(NullPointerException e){
   		如果出现这个异常,需要执行的代码
   	}catch(FileNotFoundException e){
   	 ...
   	}catch(Exception e){
   	 ...
   	}
   	...
   	finally{
   		无论是否出现异常,都会执行的代码
   	}

try中一旦出现异常,不会继续向下执行,会执行对应的catch中的内容
一个try中可以跟1~多个 catch,小范围catch放在放在上面,大范围的catch放下面

运行时异常可以使用增强程序的健壮性或者异常处理方式的两种,抛出或者捕获处理
编译时异常必须使用异常处理方式的两种,抛出或者捕获处理

	public class ExceptionDemo02 {
		public static void main(String[] args) {
			/*String str1=null;
			str1.charAt(1);*/
			
			try {
				//InputStream is=new FileInputStream("D:/text.txt");
				String str=null;
				//str.charAt(1);
				System.out.println("try结束了");
			} /*catch (FileNotFoundException e) {
				e.printStackTrace();
				System.out.println("文件未找到");
			}*/ catch (Exception e) {
				e.printStackTrace();
			} finally{
				System.out.println("最后的最后...");
			}
			
			System.out.println("try..catch结束了");
			
			test(5);
		}
	
		static void test(int a){
			//手动制造异常
			//throw new NullPointerException();
			//System.out.println("test------------");
			
			try{
				if(a==5){
					return;
				}
			}catch(Exception e){
				
			}finally{
				System.out.println("haha");
			}
		}
	}
	
	/*
	 * 重写方法抛出异常问题: 子类小于等于父类
	*/
	class Fu{
		void haha() throws Exception{}
	}
	
	class Zi extends Fu{
		void haha() throws FileNotFoundException{}
	}

自定义异常

现在使用的都是java提供的异常类,可以自定义异常类
自定义的异常类必须直接或者间接的继承自Exception类

public class DefinedException03 {
	public static void main(String[] args) {
		Person p =new Person();
		p.setName("双双");
		int age=-10;
		/*if(age>0 && age<150){
			p.setAge(age);
		}else{
			p.setAge(18);
		}*/
		
		try {
			p.setAge(-11);
		} catch (AgeException e) {
			e.printStackTrace();
		}
		
		System.out.println(p);
	}
}

//自定义异常类  年龄不合法异常,在出现年龄<=0或者年龄>=150时候出现
class AgeException extends Exception{
	public AgeException() {
		// TODO Auto-generated constructor stub
	}
	
	public AgeException(int age) {
		super(age+"岁年龄不合法");
	}
}

class Person{
	private String name;
	private int age;
	
	public Person() {
		// TODO Auto-generated constructor stub
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) throws AgeException {
		if(age>0 && age<150){
			this.age = age;
		}else{
			//System.out.println("年龄不合法");
			throw new AgeException(age);
		}
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}	
}

常用类

字符串 String :

不可变长的字符序列 ,Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。

String : 不可变长的字符序列
StringBuilder : 可变长的字符序列 ,线程不安全,效率高

StringBuffer : 可变长的字符序列 , 线程安全的,效率较低是字符数组形式存储的

 public class StringDemo02 {
 	public static void main(String[] args) throws UnsupportedEncodingException {
 		//空串
 		String str1=new String();
 		System.out.println(str1.length());
 		
 		//字符数组转为字符串
 		//static String copyValueOf(char[] data) 
 		//String(char[] value)    分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
 		char[] ch=new char[]{'a','b','c','d','e','f'};
 		String str2=new String(ch);
 		System.out.println(str2);
 		
 		//String(char[] value, int offset, int count)  分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
 		String str3=new String(ch,2,3);
 		System.out.println(str3);
 		
 		//String(String original) 
 		String str4=new String("abc");
 		System.out.println(str4);
 		
 		byte[] arr="因为你好".getBytes("gbk");
 		//String(byte[] bytes)   平台默认
 		String str5=new String(arr);
 		System.out.println(str5);
 		System.out.println(Arrays.toString(arr));
 		
 		//String(byte[] bytes, String charsetName)  通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
 		String str6=new String(arr,"gbk");
 		System.out.println(str6);
 		
 		//String(byte[] bytes, int offset, int length, String charsetName) 
 		String str7=new String(arr,2,4,"gbk");
 		System.out.println(str7);
 		
 		//char charAt(int index) 返回指定索引处的 char 值。 
 		System.out.println(str6.charAt(2));
 		
 		// int compareTo(String anotherString)  按字典顺序比较两个字符串。 
 		System.out.println("ab".compareTo("A")); //32
 		
 		// String concat(String str)将指定字符串连接到此字符串的结尾。 
 		System.out.println(str6.concat("哈哈"));
 		//boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 
 		System.out.println(str6.concat("哈哈"));
 		
 		// boolean contains(CharSequence s) 当且仅当此字符串包含指定的 char 值序列时，返回 true。
 		System.out.println(str6.contains("你好"));
 		
 		//byte[] getBytes()  
 		//byte[] getBytes(String charsetName)  
 		System.out.println(str6.getBytes());
 		
 		//void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)  将字符从此字符串复制到目标字符数组。 
 		char[] c=new char[5];
 		str6.getChars(0, 4, c, 1);  //结束位置不包含
 		System.out.println(c);
 		
 		//int indexOf(String str) 
 		System.out.println("abcababc".indexOf('a'));
 		System.out.println("abcababc".lastIndexOf('a'));
 		
 		//String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 
 		String s="  abca babc  ";
 		System.out.println(s.replace('a', 'A'));
 		
 		// String[] split(String regex) 
 		 String ss="name=zhangsan";
 		 System.out.println(Arrays.toString(ss.split("=")));
 		 
 		 //String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。 
 		 //String substring(int beginIndex, int endIndex)  endIndex结束位置索引不包含
 		 System.out.println(s.substring(5));
 		 System.out.println(s.substring(3,5));
 		 //char[] toCharArray()   将此字符串转换为一个新的字符数组。 
 		 System.out.println(s.toCharArray());
 		 
 		 //String toLowerCase() 
 		 // String trim() 返回字符串的副本，忽略前导空白和尾部空白 
 		 System.out.println(s.trim());
 		 
 		 //valueOf(参数) 任意类型参数转为字符串
 
 	}
 }

StringBuilder:单线程环境下大量操作字符串,效率较高
StringBuffer : 多线程环境系大量操作字符串,线程安全,同步
String : 表示少量操作字符串 ,简单,功能较多

可以相互转换

  public class StringDemo03 {
 	public static void main(String[] args) {
 		//StringBuilder(String str)
 		StringBuilder sb=new StringBuilder("haha");  //默认16大小
 		System.out.println(sb);
 		//int capacity() 
 		 // length()
 		System.out.println(sb.capacity());
 		System.out.println(sb.length());
 		
 		//重点方法:
 		//StringBuilder append(int i)   追加
 		StringBuilder s=sb.append(true);
 		System.out.println(sb);
 		System.out.println(sb==s);
 		
 		// StringBuilder delete(int start, int end)   end不包含 删除
 		System.out.println(sb.delete(4, 6));
 		
 		//StringBuilder insert(int offset, char c)   插入
 		System.out.println(sb.insert(3, 123));
 		
 		 //StringBuilder reverse()  翻转
 		System.out.println(sb.reverse());
 		
 		String str="abcdef";
 		char[] arr=str.toCharArray();
 		System.out.println(Arrays.toString(arr));
 		String str2="";
 		for(int i=arr.length-1;i>=0;i--){
 			str2+=arr[i];
 		}
 		System.out.println(str2);
 		
 		String str3=new String(sb);
 		System.out.println(str3);
 	}
 }

Math 数学工具类

public class MathDemo {
	public static void main(String[] args) {
		//static double ceil(double a) 向上取整
		System.out.println(Math.ceil(-3.9));
		//static double floor(double a) 向下取整
		System.out.println(Math.floor(-3.9));
		
		//static long max(long a, long b)  返回两个 long 值中较大的一个。 
		//static double min(double a, double b)  
		System.out.println(Math.max(-3.9,9.9));
		System.out.println(Math.min(-3.9,9.9));
	}
}

枚举类

使用enum关键字定义枚举
表示一种事物的多种可能|所有可能|所有情况
注意:
所有的枚举类都隐式继承自java.lang.Enum类
枚举中的所有成员|实例|字段都是,默认public static final,都是当前类型的一个实例

	public class Employee {
	private int id;
	private String name;
	private Status status;
	
	public Employee() {
		// TODO Auto-generated constructor stub
	}

	public Employee(int id, String name, Status status) {
		super();
		this.id = id;
		this.name = name;
		this.status = status;
	}

	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 Status getStatus() {
		return status;
	}

	public void setStatus(Status status) {
		this.status = status;
	}

	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", status=" + status + "]";
	}
	
}

//状态   A,B,C,D,E 从忙到闲
enum Status{
	A,
	B,
	C,
	D,
	E;
}
//主方法
	public class Test {
	public static void main(String[] args) {
		Employee emp1=new Employee();
		emp1.setId(8888);
		
		emp1.setName("员工1");
		emp1.setStatus(Status.A);
		
		Employee emp2=new Employee(9999,"lisi",Status.B);
		Employee emp3=new Employee(10000,"员工2",Status.E);
		Employee emp4=new Employee(10001,"员工3",Status.A);
		
		Employee[] arr={emp1,emp2,emp3,emp4};
		
		//给公司最忙员工放假三天
		for(Employee emp:arr){
			switch(emp.getStatus()){
			case A:
				System.out.println(emp.getName()+"放假三天!!!!");
				break;
			default:
				System.out.println(emp.getName()+"努力加班,期待下一次放假!!!");
				break;
			}
		}
	}
}

包装类型: 基本数据类型的包装类

基本数据类型包装类

byte — Byte
short — Short
int — Integer
long — Long
float — Float
double— Double
char — Character
boolean — Boolean

转换:
自动装箱: 基本—>包装
自动拆箱: 包装—>基本

public class DataDemo01 extends Object{
	public static void main(String[] args) {
		Integer i1=121;  //自动装箱  Integer.valueOf(121)
		Integer i2=1;
		System.out.println(i1+i2);  //自动拆箱
		int i3=i1;   //自动拆箱  i1.intValue() 
		
		test(2.2,1.1);
		
		System.out.println(Integer.parseInt("123"));
		System.out.println(Integer.reverse(12));
	}
	
	static void test(Double d1,Double d2){
		System.out.println(d1-d2);
	}
}

	//2

	public class DataDemo02 {
		public static void main(String[] args) {
			int i1=121;
			Integer i2=121;  //Integer.valueOf(121)  缓冲区对象 -128~127 之外返回new Integer,之内返回缓冲区对象
			Integer i3=121;
			Integer i4=128;
			Integer i5=128;
			
			Integer i6=new Integer(121);
			Integer i7=new Integer(121);
			
			System.out.println(i1==i2);  //true  自动拆箱
			System.out.println(i2==i3);  //true  
			System.out.println(i4==i5);  //false  
			System.out.println(i2==i6);  //false  
			System.out.println(i7==i6);  //false  
			
			String str1="abc";  //字符串常量池里
			String str2=new String("abc");  //堆中的地址
			System.out.println(str1==str2); //false
			
			/*
			 * 总结:
			 * 	1.如果两个new Integer比较是否相等,肯定不相等,堆中的两个地址
			 * 	2.如果一个Integer,一个new Integer肯定不相等,一个常量池,一个堆中的地址,肯定不相等
			 * 	3.如果int与Integer|new Integer 都会发生自动拆箱,值相等就相等
			 * 	4.如果是两个Integer,判断值是否在[-128,127]之间,之间就相等,否则不等
			 */
		}
	}

小小小太阳001

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
异常|常用类

异常Error:错误:一般是由虚拟机生成并脱出的,程序员无法解决Exception: 异常CheckException 编译时异常: 编译时期就会出现的异常 ,如果出现了编译时异常不处理,程序无法运行RuntimeException 运行时异常 : 运行时期会出现的异常 ,所有的运行时异常都会直接或者间接的继承自RuntimeException,可通过增强程序的健壮性处理 if判断...
复制链接

扫一扫