JAVA第七章 内部类与异常类

第七章 内部类与异常类

小结
（1）JAVA支持在一个类中声明另一个类，这样的类称作内部类，而包含内部类的类称为内部类的外嵌类。
（2）和某类有关的匿名类就是该类的一个子类，该子类没有明显地用类声明来定义，所以称作匿名类。
（3）和某接口有关的匿名类就是实现该接口的一个类，该子类没有明显地用类声明来定义，所以称作匿名类。
（4）JAVA的异常可以出现在方法调用过程中，即在方法调用过程中抛出异常对象，导致程序运行出现异常，并等待处理。JAVA使用try-catch语句来处理异常，将可能出现的异常操作放在try-catch语句的try部分，当try部分中的某个方法调用发生异常后，try部分将立刻结束执行，转向执行相应的catch部分。

1.内部类

Java支持在一个类中声明另一个类，这样的类称作内部类，而包含内部类的类称为内部类的外嵌类。
某种类型的农场饲养了一种特殊种类的牛，但不希望其他农场饲养这种特殊种类的牛，那么这种类型的农场就可以将创建这种特殊种牛的类作为自己的内部类。

注意

• 内部类的类体中不可声明类变量的和类方法，外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。
• 内部类仅供它的外嵌类使用，其他类不可以用某个类的内部类声明对象。
• 内部类可以直接访问外部类的成员，包括私有。
• 外部类要访问内部类的成员，必须要创建对象
• 内部类可以被修饰为static内部类，static内部类不能操作外嵌类中的实例成员变量。
• 如何直访问成员内部类的成员？
  外部类名.内部类名 对象名=外部类对象.内部类对象
• 成员内部类被静态修饰后的访问方式是：
  外部类名.内部类名 对象名=new 外部类名.内部类名();

  class RedCowForm {
   static String formName;
   RedCow cow;  //内部类声明对象
   RedCowForm() {
   }
   RedCowForm(String s) {
      cow = new RedCow(150,112,5000);
      formName = s;
   }
   public void showCowMess() {
      cow.speak();
   }
   class RedCow {  //内部类的声明
      String cowName = "红牛";
      int height,weight,price;
      RedCow(int h,int w,int p){
          height = h;
          weight = w;
          price = p;
      }
      void speak() {
         System.out.println("偶是"+cowName+",身高:"+height+"cm 体重:"+weight+"kg,生活在"+formName);
      }
   }    //内部类结束
}      //外嵌类结束
public class Example7_1 {
	   public static void main(String args[]) {
	      RedCowForm form = new RedCowForm("红牛农场");
	      form.showCowMess();
	      form.cow.speak();
	      //RedCowForm.RedCow redCow = new RedCowForm.RedCow(180,119,6000);
	      //redCow.speak();
	   }   
	}
/*运行结果
偶是红牛,身高:150cm 体重:112kg,生活在红牛农场
偶是红牛,身高:150cm 体重:112kg,生活在红牛农场
*/

2.匿名类

• 匿名内部类
  就是内部类的简化写法
• 前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
• 格式
  new 类名或者接口名（）{
  重写方法；
  }
• 匿名类的本质：是一个继承了该类或实现了该接口的子类匿名对象

（1）和子类有关的匿名类
Java允许我们直接使用一个类的子类的类体创建一个子类对象。
创建子类对象时，除了使用父类的构造方法外还有类体，此类体被认为是一个子类去掉类声明后的类体，称作匿名类。
假设Bank是类，那么下列代码就是用Bank的一个子类（匿名类）创建对象：
new Bank () {
匿名类的类体
};

• 匿名类可以继承父类的方法，也可以重写父类的方法。
• 使用匿名类时，必然是在某个类中直接用匿名类创建对象，所以匿名类一定是内部类。
• 匿名类可以访问外嵌类中的成员变量和方法，匿名类的类体不可以声明static成员变量和static成员方法。

（2）和接口有关的匿名类

interface Person{
	public  abstract void study();
}

class PersonDemo{
	//接口名作为形式参数
	//其实这里需要的不是接口，而是该接口的实现类的对象
	public void method(Person p) {
		p.study();
	}	
}

//实现类
class Student implements Person{
	public void study() {
		System.out.println("舒舒服服学JAVA");
	}
}


 class InnerClassTest2 {

	public static void main(String[] args) {
		// 测试
		PersonDemo pd=new PersonDemo();
		Person p=new Student();
		pd.method(p);
        System.out.println("-----------");
        //匿名内部类在开发中的使用
        //匿名内部类的本质是继承类或者实现了接口的子类匿名对象
        pd.method(new Person() {
        	public void study() {
        		System.out.println("舒舒服服学JAVA");
        	}
        });
	}
}

3.try-catch语句

Java使用try-catch语句来处理异常，将可能出现的异常操作放在try~catch语句的try部分，将发生异常后的处理放在catch部分。
try~catch语句的格式如下：
try {
包含可能发生异常的语句
}
catch(ExceptionSubClass1 e) {
…
}
catch(ExceptionSubClass2 e) {
…
}

public class Example7_4 {

	public static void main(String[] args) {
		int n=0,m=0,t=1000;
		try {
			m=Integer.parseInt("8888");
			n=Integer.parseInt("ab89");//发生异常，转向catch
			t=7777;//t没有机会被赋值
		}
		catch(NumberFormatException e) {
			System.out.println("发生异常:"+e.getMessage());
		}
		System.out.println("n="+n+",m="+m+",t="+t);
		try {
			System.out.println("故意抛出I/O异常！");
			throw new java.io.IOException("我是故意的");
			//System.out.println("整个输出语句肯定没有机会执行，所以必须注释掉，否则编译错误")
		}
		catch(java.io.IOException e) {
			System.out.println("发生异常："+e.getMessage());
		}
	}
}

4.自定义异常类

我们也可以扩展Exception类定义自己的异常类，然后规定哪些方法产生这样的异常。
一个方法在声明时可以使用throws关键字声明要产生的若干个异常，并在该方法的方法体中具体给出产生异常的操作，即用相应的异常类创建对象，并使用throw关键字抛出该异常对象，导致该方法结束执行。

 class BankException extends Exception{
	String message;
	public BankException(int m,int n) {
		 message="入账资金"+m+"是负数或支出"+n+"是正数，不符合系统要求.";
	}
	public String warnMess() {
		return message;
	}
}

 class Bank{
	private int money;
	public void income(int in,int out)throws BankException{
		if(in<=0||out>=0||in+out<=0) {
			throw new BankException(in,out);//方法抛出异常，导致方法结束
		}
		int netlncome=in+out;
		System.out.printf("本次计算出的纯收入是:%d元\n",netlncome);
		money=money+netlncome;
	}
	public int getMoney() {
		return money;
	}
}


public class Example7_5 {

	public static void main(String[] args) {
       Bank bank=new Bank();
       try {
    	   bank.income(200, -100);
    	   bank.income(300, -100);
    	   bank.income(400, -100);
    	   System.out.printf("银行目前有%d元\n",bank.getMoney());
    	   bank.income(200, 100);
    	   bank.income(99999, -100);
       }
       catch(BankException e) {
    	   System.out.println("计算收益的过程出现如下问题");
    	   System.out.println(e.warnMess());
       }
       System.out.printf("银行目前有%d元\n",bank.getMoney());

	}

}