面向对象的三大特征及异常

---

一、面向对象的三大特征

1.封装
从实例中抽象出共同特征，这些特征就形成了类，实例就相当于拥有这些特征并还有自己的特质的对象。类就把数据以及对数据的操作封装在一起，并设置恰当的访问权限，使得类中的方法和变量只让被允许调用的方法调用。

class Tom {
	private float weight;
	private float f(float a,float b){
		return a+b;
	}
}
class Jerry {
	void g(){
		Tom cat = new Tom();
		//cat.weight = 23f;非法
		//float sum = cat.f(3,4);非法
	}
}

以上代码中，Tom类在Jerry类中创建了一个对象cat，因为weight变量以及f方法是private的权限，因此cat对象不能使用这个私有的变量和私有的方法。

对象还可以组合另一个对象，当前对象A只能委托所包含的对象B调用对象B中的方法，对象A就不必知晓方法的具体细节，而且可以随时更换所包含的对象。（对象A和对象B是弱耦合关系）

2.继承

子类继承父类的成员变量和方法，并且可以根据需要来定义自己的成员变量和方法。（子类只有一个父类）
同一包下：子类继承除了private访问权限以外的所有成员变量和方法
不同包下：子类只能继承public和protected访问权限的成员变量和方法（重写父类方法时，访问权限不允许降低）

访问权限：public>protected>默认权限>private

	当前类	同一包	子孙类	其他包
public	√	√	√	√
protected	√	√	√
默认权限	√	√
private	√

3.多态
1、静态多态（编译时多态）

重载（overload）：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同（以下两个条件满足其一）。

• 参数个数不同
• 参数列表中对应的某个参数的类型不同

2、动态多态（运行时多态）

2.1重写/覆盖（override）：（和继承有关的多态）子类对父类方法的重写。重写的方法的方法名、方法类型、参数个数、参数类型与父类的方法完全一样。

class A {
    float computer(float x,float y) {
       return x+y;
    }
}
class B extends A {
    float computer (float x,float y) {//子类A重写了父类B的computer方法
       return x*y;
    }
}
public class E {
    public static void main(String args[]) {
      B b=new B();
      double result=b.computer(8,9);//b调用重写的方法
      System.out.println(result);     
    } 
}

2.2接口：

由接口产生的多态就是指不同的类在实现同一个接口时可能有不同的实现方式，那么接口变量在回调接口方法时就可能有多种形态。
下方的代码中，A类和B类都实现了CompurerAverage接口，但有不同的实现方式。

interface CompurerAverage {
   public double average(double a,double b);
}
class A implements CompurerAverage {
   public double average(double a,double b) {
      double aver=0;
      aver=(a+b)/2;
      return aver;
   }
}
class B implements CompurerAverage {
   public double average(double a,double b) {
      double aver=0;
      aver=Math.sqrt(a*b);
      return aver;
   }
}
public class Average {
   public static void main(String args[]) {
      CompurerAverage computer;
      double a=11.23,b=22.78;
      computer = new A();  
      double result = computer.average(a,b);
      System.out.printf("%5.2f和%5.2f的算术平均值:%5.2f\n",a,b,result);
      computer = new B();  
      result= computer.average(a,b);
      System.out.printf("%5.2f和%5.2f的几何平均值:%5.2f",a,b,result);
   } 
}

2.3抽象类和抽象方法（不能用final修饰）：

抽象类封装了子类必有的行为标准，里面可以有抽象方法也可以没有抽象方法。抽象类声明的对象可以成为其子类的对象的上转型对象，该对象就可以调用子类重写的方法。
抽象方法只允许声明，不允许实现（没有方法体）。不允许用static修饰，只能是实例方法。抽象方法只允许存在于抽象类或接口中。

abstract class A {//抽象类
	abstract int min(int x,int y);//抽象方法
	int max (int x,int y) {
		return x>y?x:y;
	}
}

二、异常

异常：程序运行过程中出现的错误。
异常的分类：错误、一般性异常（受控异常）、运行时异常（非受控异常）

1. 错误
   出现Error，无法恢复，只能重新启动应用程序。典型：OutOfMemoryEorror
2. 受控异常
   编译器强制用try-catch语句处理，或用throws声明继续抛给上层调用方法处理
3. 非受控异常
   RuntimeException，可以处理也可以不处理，编译器不强制用try-catch处理或用throws声明

1、try-catch语句可以有几个catch组成，分别处理发生的相应异常。

try {//包含可能发生异常的语句
}
catch (ExceptionSubClass1 e) {//catch参数中的异常类都是Exception的某个子类
}
catch (ExceptionSubClass2 e) {
}
finally {//不管是否出现异常，此语句都执行
}

异常的捕获一般按照从小到大，即先捕获子异常，再捕获父异常。

2、throws抛出处理
一个方法可以用throws关键字声明要产生的若干个异常，并在该方法的方法体中具体给出产生异常的操作。即用相应的异常类创建对象，并用throw关键字抛出该异常对象，导致方法结束执行。谁调用这个方法谁负责处理异常。