java小记（九）

快来打我* 2024-01-15 06:37 10阅读 0赞

1、instanceof关键字  
instanceof是用于检查对象是否为指定的类型，通常在把父类引用强制转换为子类引用时要使用，以避免发生类型转换异常（ClassCastException）。  
语法格式如下：  
对象 instanceof 类型 ———返回boolean类型值

示例：

if(homeChicken instanceof Chicken){
        
    	//...
    }

该语句一般用于判断一个对象是否为某个类的实例，是则返回true，否则返回false。

父类通常情况下都设计为抽象类或接口，其中优先考虑接口，如接口不能满足才考虑抽象类。

class Demo{
        
    	public static void main(String[] args) {
        
    	}
    	public static void eat(Chicken c) {
        
    		System.out.println("鸡吃饭");
    		c.eat();
    		//当我们需要把父类的实例强制转换为子类引用时，为了避免类型转换异常  java.lang.ClassCastException
    		//那么我们需要在转换之前做类型检查（判断）
    		if(c instanceof JianJiaoChicken){
        
    			JianJiaoChicken jjc = (JianJiaoChicken)c;//大的类型转换为小的类型，强制转换（向下转换）
    			jjc.song();
    		}
    	}
    }
    //鸡
    abstract class Chicken{
        
    	private String name;
    	public Chicken() {
        }
    	public Chicken(String name) {
        
    		this.name = name;
    	}
    	public void setName(String name) {
        
    		this.name = name;
    	}
    	public String getName() {
        
    		return name;
    	}
    	public abstract void eat();
    }
    class JianJiaoChicken extends Chicken{
        
    	public JianJiaoChicken(String name) {
        
    		super(name);
    	}
    	public void eat() {
        
    		System.out.println(this.getName()+",我不吃东西");
    	}
    	public void song() {
        
    		System.out.println("唧唧复唧唧，我是尖叫鸡");
    	}
    }

2、包用于对多个java源文件的管理，就像我们的文件目录一样。  
定义一个包：

package com.vince;

该语句只能出现在代码中的第一句。

访问修饰符：

访问修饰符	同一个类		 同包	  不同包子类		不同包非子类
    public		   √		  √		      √				 √
    protected	   √		  √		      √
    默认	       √		  √
    private		   √

3、try与catch关键字  
在程序中出现异常，就必须进行处理，处理格式如下：

try(...){
        //JDK1.7以后直接释放资源
    	//有可能发生异常的代码段
    }catch(异常类型 对象) {
        
    	//异常的处理操作
    }catch(异常类型 对象) {
        
    	//异常的处理操作
    }...
    finally {
        
    	//异常的统一出口
    }

若不确定捕获的异常是什么类型，则用父类Exception（表示总的）。  
示例：

try{
        
    
    }catch(ArithmeticException e){
        //子类
    
    }catch(NullPointerException e){
        //子类
    
    }catch(Exception e){
        //父类
    
    }

注意：排前面的catch语句范围要小，范围大的放后面（从子类到父类），否则就会短路，导致后面的catch语句无法执行。

4、异常的部分相关内容：  
（1）Throwable是异常的基类，分为Error和Exception，在编程中我们关注Exception。  
（2）Exception分为编译期异常（受检）和运行期异常（非受检）。

异常处理过程分析：  
（1）一旦产生异常，则系统会自动产生一个异常类的实例化对象。  
（2）此时如果存在了try语句，则会自动找到匹配的catch语句执行，如果没有异常处理，则程序将退出，并由系统报告错误。  
（3）所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由此catch进行处理。

5、面试题：  
以下程序的finally语句会不会执行：

public class app{
        
    	public static void main(String agrs[]) {
        
    		method();
    	}
    	private static int method() {
        
    		int a = 10;
    		int b = 5;
    		try {
        
    			int c = a/b;
    			System.out.println("a/b="+c);
    			return c;
    		}catch(Exception e) {
        
    			e.printStackTrace();//打印出现的异常类型，用于代码测试
    		}finally {
        
    			System.out.println("finally");
    		}
    		return -1;
    	}
    }

输出结果：

a/b=2
    finally

解释：在执行第11行的return语句之前，会判断第11行是否在try语句块内，如果在，就会去找finally语句，如果找到了，就执行finally语句，再执行第11行。