java学习总结（16.06.10~16.06.17）面向对象的三大特征——封装、继承、多态

面向对象的程序设计语言有三大特征，分别是封装、继承、多态

特征一：封装

封装，简单来说就是将数据和方法包装在类这种特殊的数据类型中。具备封装性（Encapsulation）的面向对象程序设计隐藏了某一方法的具体运行步骤，取而代之的是通过消息传递机制发送消息给它。封装是通过限制只有特定类的对象可以访问这一特定类的成员，而它们通常利用接口实现消息的传入传出。（摘自Wikipedia）

封装的关键在于如何将类的特定成员隐藏，例如

public class Point {
	//点的坐标
	private float x,y;
	//点的名字
	private char name;
	//三个数据成员的get和set方法
	public float getX() {
		return x;
	}
	public void setX(float x) {
		this.x = x;
	}
	public float getY() {
		return y;
	}
	public void setY(float y) {
		this.y = y;
	}
	public char getName() {
		return name;
	}
	public void setName(char name) {
		this.name = name;
	}
	
	public static void main(String[] args) {
		Point point=new Point();
		point.setX(10);
		point.setY(15);
		point.setName('A');
		System.out.println(point.getName()+"点坐标为("+point.getX()+","+point.getY()+")");
	}
}

运行结果如下：
A点坐标为(10.0,15.0)

上面的点类中，点的坐标，点的名字都设置成了private被隐藏起来，这个数据成员只能在类内访问，类外无法访问，只能通过get和set的方法进行读写。

封装的好处：
①良好的封装可以降低程序的耦合度
②可以隐藏类的成员，保护其不被外部修改
③封装后，程序的修改更为方便（只需修改类对应的方法成员即可）

ps:在eclipse中选中数据成员，右击-source-generate getters and setters可以快速生成数据成员的get和set方法。

特征二：继承

继承也是面向对象程序设计语言的一大特性继承使得程序的代码拥有了复用性。通过继承子类可以拥有父类的所有数据成员和方法成员，如此就不用再写有关这些成员的代码了。

如何声明一个子类：

法1，在eclipse中新建一个类文件时可以在superclass一栏指定相应的父类（每一个类都默认是Object类的子类），点击browse

在choose a type一栏打上父类名即可。

法2，在类声明时直接使用关键字extends指定父类，如：class SubClass extends BaseClass{}    这里将SubClass声明为BaseClass的一个子类

子类继承父类后，可以增加新的数据成员或方法成员，也可以对父类原有的方法进行重写（override）

方法重载和方法重写

方法重载：当两个方法方法名相同，参数列表不同时（即参数类型或参数个数或参数类型的顺序不同时），这两个方法即为重载，虽然方法名一样，但这的确是两个不同的方法。系统在编译时如果遇到重载方法，就会根据调用方法时的实参来匹配一个参数列表最符合的方法。例：

public class BaseClass {
      public void fun(int a){
      System.out.println(a);
      }
}

public class SubClass extends Base {
      public void fun(int a,int b){
            System.out.println(a+","+b);
      }
      public static void main(String[] args) {
            Child child=new Child();
            child.fun(10);
            child.fun(10,20);
      }
|

运行结果如下：
10
10,20

这里SubClass的fun方法重载了父类BaseClass的fun方法，因为父类的fun方法是公有的，子类SubClass的对象也可以调用此方法，编译时系统就会根据实参列表自行匹配出并使用最适合的方法。

方法重写：
对父类方法进行重写的要求（语法规则上）：
①重写后的方法的方法名，参数列表，返回值必须与父类方法一致
②子类重写后的方法的访问权限不可以比父类方法的访问权限小，否则会抛出“Cannot reduce the visibility of the inherited method from XXX”的错误

注：

①子类的对象或方法体中会优先调用重写后的子类方法
②在eclipse中若要重写父类的某一个方法，只需在子类中输入要重写的方法名代码提醒出就会有完整的方法声明，敲一下回车即可将整个重写方法的声明写好。

③父类中的静态方法不可重写

在子类中访问和调用父类的数据成员和方法成员（super关键字）

①对于没有重名的数据成员和没有重写的方法成员，只需根据成员的访问权限可直接访问或通过父类提供的方法（接口）访问
②对于重名的数据成员和被重写过的方法成员，则可以使用super关键字，super关键字与this关键字类似，它指向当前类的父类的对象。在父类中通过[super.成员名]可以访问到父类的成员。注：在静态方法中无法使用super关键字。

③若想在子类中访问父类的静态成员，只需 [父类名.静态成员]即可

特征三：多态

多态分为编译时的多态和运行时的多态

编译时的多态：编译时通过参数列表不同来区分重载方法，而在编译完成后，具体调用哪一个方法已经被确定下来了

运行时的多态：运行时，通过根据所引用的对象的实际类型来判断调用哪一个类的方法成员

通常多态指的是后者

多态是一种现象:当编译时的类型和运行时的类型不一致时就会出现

多态产生的条件：使用父类的引用指向子类，并调用子类中重写后的方法。如：

public class Base {
	public  void fun(){
		System.out.println("调用了父类的fun方法");
	}
}

public class SubClass extends Base {
	@Override
	public void fun() {
		// TODO Auto-generated method stub
		//super.fun();
		System.out.println("子类的fun方法");
	}
	public static void main(String[] args) {
		Base p=new SubClass();//用父类的引用创建一个子类的对象
		p.fun();
	}
}

运行结果如下：
子类的fun方法

父类的引用对子类具有兼容性，因此可以使用父类的引用创建一个子类对象，如此，程序运行时，系统检测到引用和对象类型不一致，若调用某个有重写过的方法时，系统就会调用子类重写后的方法。

注：使用父类引用指向子类对象时，不能通过父类引用访问或调用子类中父类所没有的成员。因为编译时，系统会把父类引用指向的对象当成父类对象，因此访问或调用父类对象没有的成员会报错。当然，如果把父类引用强制类型转换成子类类型就不会出现这样的错误。

多态的好处：通过多态，可以时不同类型的对象对同一个消息作出不同的响应。例如发出“将要地震了”的信号，不同动物有不同反应，就会出现“鸡飞鼠遁狗跳墙”的场景。之后有空的话，我会用代码来模拟一下这个场景，具体代码以后有空再填坑，这里先挖一个坑。