Java 面向对象的三大特性

    封装

      封装通常基于4种访问修饰符来实现:缺省、private、public和protected

       假如我们想描述人的属性,可以把人的相关属性name,age...封装成一个人类,属于类层次的封装,用一组相关属性描述一类东西.

      public class Teacher{  //老师类
         public String name;//老师的名字
         public Family family;//家庭类
         List<Student> students;//老师名下的学生集合
      }

   一般情况下,这样的数据封装还不够,我们还需要限制访问权限

成员变量的封装

        class Bank{ 
           private String money;//存款数目
           public String getMoney() {
              return money;//银行人员执行取款操作
           }
           public void setMoney(String money) {
             this.money = money;//银行人员执行存款操作
           }
        }

成员方法的封装:

/**
 * @author QinGuan
 * @date:2016-3-1 上午10:39:40
 * @version :3.0
 *
 */
package com.cloneTest;

public class vocation implements Cloneable{
	public String name;

	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
	public void setLoad(){
		getLoad();//调用类中私有方法
	}
	private void getLoad(){   //此方法被封装,仅仅可以内部方法调用
		System.out.println("load");
	}
}

   以上的封装是在属性和方法的层次上,还有一种更加有意思的封装形式是内部类,规则是:

成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）, 这个规则结合继承,就巧妙的解决了Java单继承的问题:

    public class External extends Father { 
    	private String Exname;
    	//内部类
    	class internal {
    		private String inname;
    
    		public void print() {
    			System.out.println(Exname);
    			fatherPrint();//可以直接访问Father类的打印方法
    		}
    	}
    
    	public void get() {
    		System.out.println(internal.class);
    	}
    
    	public String getExname() {
    		return Exname;
    	}
    
    	public void setExname(String exname) {
    		Exname = exname;
    	}
    }

    继承

       Java中的继承通过关键字 extends 实现,子类继承父类全部内容,但是可访问的内容仅仅限于非 private 修饰的内容.

     子类在实例化的时候,默认先调用父类的无参构造方法,所以父类一般会提供一个无参的构造方法以供子类调用,当然了,子类也可以通过 super(参数列表);来指定调用的父类构造方法

        public class Father {
	       public String name;

           Father() {
        
           }

           Father(String name) {
             this.name = name;
           }
	
        public class Son extends Father {
          private String name;
        
          Son (String name){
        	super(name);//调用父类的有参构造方法
          }

    多态

      在继承的基础上的实现,父类的变量指向子类实例化的内容

     参考资料：http://blog.youkuaiyun.com/thinkGhoster/archive/2008/04/19/2307001.aspx。

      百度文库：http://wenku.baidu.com/view/73f66f92daef5ef7ba0d3c03.html

方法的重写和重载

    重载，属于同一个类中的方法,方法名一样，参数列表不同，返回值类型可以相同也可以不相同。

    重写,子类对继承自父类的方法进行重新实现.相同的方法签名,相同的返回值,不小于父类方法的访问权限