java 三大特性--封装、继承和多态理解

[color=red][size=x-large]封装[/size][/color]

/**
 * 所谓封装，就是将对象具有的成员变量和成员函数包装和隐藏起来，让外界无法直接使用，
 * 被封装的成员只能通过某些特定的方式才能访问。 
 * 实现封装有两个步骤：
 *   1、将不能暴露的成员隐藏起来，我们就不能让其在类的外部被直接访问或赋值。
 *   	实现方法是将该成员定义为私有的，在成员定义前加上private访问权限修饰符。
 *   2、用公共方法来暴露对该隐藏成员的访问，可以给成员加上public修饰符，将该成员定义为公共的
 */
package com.study.feature;

/**   
 * 
 * @className ：Package  
 * @package : com.study.feature 
 * @Description ：封装性的测试   
 * @author：lgf   
 * @date ：2012 三月 12  10:20:35          
 * @version : 1.0
 */
public class Package {
	// 使用private隐藏
	private String strValue;

	// 通过get和set进行访问
	public String getStrValue() {
		return this.strValue;
	}
	public void setStrValue(String strValue) {
		this.strValue = strValue;
	}
}

[color=red][size=x-large]继承[/size][/color]
[color=green][size=large]父类 ExtendsFather.java[/size][/color]

/**
 * 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
 * 对象的一个新类可以从现有的类中派生。
 * 1. 为什么要使用继承？
 * 	a.提高程序的扩展性。
    b.提高了代码的重用性。

   2. 子类能继承到父类的那些方法和属性
   	第一种：所有的属性和方法都被子类继承到了。
    第二种：
    a、子类和父类在同一个包下：
    公有的受保护的属性和方法被子类继承到了。
    b、子类和父类不在同一个包下：
    公有的方法和属性被子类继承到了。

   3. 子类的对象能调用父类的那些方法和属性？
    a、子类和父类在同一个包下：
    公有的受保护的属性和方法能被子类调用。
    b、子类和父类不在同一个包下：
    公有的方法和属性能被子类调用。
    在类和抽象类中，默认的就是受保护的。
    在接口中，默认的就是公有的。
 */
package com.study.feature;

/**   
 * 父类
 * @className ：ExtendsFather  
 * @package : com.study.feature 
 * @Description ：继承测试   
 * @author：lgf   
 * @date ：2012 三月 12  10:33:02          
 * @version : 1.0
 */
public class ExtendsFather {
	// 定义不同四种修饰符的属性
	private 	String privateValue;
	protected 	String protectedValue;
				String defaultValue;
	public 		String publicValue;

	// 定义不同四种修饰符的方法
	private void privateFunction(){
		System.out.println("privateFunction");
	}

	protected void protectedFunction(){
		System.out.println("protectedFunction");
	}

	void defaultFunction(){
		System.out.println("defaultFunction");
	}

	public void publicFunction(){
		System.out.println("publicFunction");
	}
}

[color=green][size=large]同包下的子类 ExtendsChildrenSamePackage.java[/size][/color]

package com.study.feature;
/**
* 
* 
* @className ：ExtendsChildrenSamePackage  
* @package : com.study.feature 
* @Description ： 同一个包下面的继承关系   
* @author：lgf   
* @date ：2012 三月 12  10:51:23          
* @version : 1.0
 */
public class ExtendsChildrenSamePackage extends ExtendsFather{
	public static void main(String[] args) {
		ExtendsFather children = new ExtendsChildrenSamePackage();
		//children.privateValue = "no"; 无法访问到
		children.defaultValue = "ok";
		children.protectedValue = "ok";
		children.publicValue = "ok";

		//除了private修饰的方法,其他都继承到了
		//children.privateFunction();
		children.defaultFunction();
		children.protectedFunction();
		children.publicFunction();
	}
}

[color=green][size=large]不同包下的子类 ExtendsChildrenOtherPackage.java[/size]
[/color]

/**
 * 
 */
package com.study.featureSecond;
import com.study.feature.ExtendsFather;

/**   
 * 
 * @className ：ExtendsChildrenOtherPackage  
 * @package : com.study.featureSecond 
 * @Description ：不同包下面的继承关系   
 * @author：lgf   
 * @date ：2012 三月 12  10:50:47          
 * @version : 1.0
 */
public class ExtendsChildrenOtherPackage extends ExtendsFather{
	public static void main(String[] args) {
		ExtendsFather children = new ExtendsChildrenOtherPackage();
		//children.privateValue = "no"; 无法访问到
		//children.defaultValue = "no"; 无法访问到
		//children.protectedValue = "no"; 无法访问到
		children.publicValue= "ok";

		//除了public修饰的方法,其他都未继承到了
		//children.privateFunction();
		//children.defaultFunction();
		//children.protectedFunction();
		children.publicFunction();
	}
}

[color=green][size=large]重载和重写 ExtendsOverRideLoad.java[/size]
[/color]

/**
 * 
 */
package com.study.feature;

/**   
 * 
 * @className ：ExtendsClass  
 * @package : com.study.feature 
 * @Description ：重载和重写   
 * @author：lgf   
 * @date ：2012 三月 12  11:00:35          
 * @version : 1.0
 */
public class ExtendsOverRideLoad extends ExtendsFather {
	@Override
	public void publicFunction() {
		//super.publicFunction(); 可以调用父类的方法
		System.out.println("Override publicFunction");
	}

	public void publicFunction(String str) {
		//super.publicFunction(); 可以调用父类的方法
		System.out.println("overload publicFunction");
	}

	public static void main(String[] args) {
		ExtendsFather child= new ExtendsOverRideLoad();

		//Override publicFunction
		child.publicFunction();

		//child.publicFunction("s");  仅仅只能使用到父类有的方法,重载的方法无法调用

		ExtendsOverRideLoad childSecond = new ExtendsOverRideLoad();

		//Override publicFunction
		childSecond.publicFunction();

		//overload publicFunction
		childSecond.publicFunction("overLoad");
	}
}

[color=red][size=x-large]多态[/size][/color]

[color=green][size=large]父类 Animal.java[/size]
[/color]

/**
 * 1. Java中除了static和final方法外，其他所有的方法都是运行时绑定的
 * 2. 构造方法是被隐式声明为static方法
 * 3. 动态绑定
 *	将一个方法调用和一个方法主体连接到一起称为绑定（Binding）。 
 *	根据绑定的时机不同，可将绑定分为“早期绑定”和“后期绑定”两种。 
 *	如果在程序运行之前进行绑定（由编译器和链接程序完成），称为早期绑定。 
 *	如果在程序运行期间进行绑定，称为后期绑定，后期绑定也称为“动态绑定”或“运行时绑定”。 
 *	在Java中，多态性是依靠动态绑定实现的，即Java虚拟机在运行时确定要调用哪一个同名方法。 
 *
 *	4. 多态总结
 *		一、使用父类类型的引用指向子类的对象
 *		二、该引用只能调用父类中定义的方法和变量
 *		三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，
 *			将会调用子类中的这个方法；（动态连接、动态调用）
 *		四、变量不能被重写（覆盖），”重写“的概念只针对方法，
 *			如果在子类中”重写“了父类中的变量，那么在编译时会报错。
 *  5. 多态详解 多态是通过: 
 *		5.1 接口 和 实现接口并覆盖接口中同一方法的几不同的类体现的 
 *		2 父类 和 继承父类并覆盖父类中同一方法的几个不同子类实现的.
 *
 *	6. 一个类型引用只能引用引用类型自身含有的方法和变量
 */
package com.study.feature;

/**   
 * @className ：Animal  
 * @package : com.study.feature 
 * @Description ：多态的测试   
 * @author：lgf   
 * @date ：2012 三月 12  13:50:36          
 * @version : 1.0
 */
public class Animal {
	public void eat(){
		System.out.println("eating");
	}
}

[color=green][size=large]多态实现[/size][/color]

/**
 * 
 */
package com.study.feature;

/**   
 * 
 * @className ：Cat  
 * @package : com.study.feature 
 * @Description ：猫   
 * @author：lgf   
 * @date ：2012 三月 12  13:54:01          
 * @version : 1.0
 */
public class Cat extends Animal{
	public void eat(){
		System.out.println("eating fish");
	}
}

/**
 * 
 */
package com.study.feature;

/**   
 * 
 * @className ：Dog  
 * @package : com.study.feature 
 * @Description ：狗   
 * @author：lgf   
 * @date ：2012 三月 12  13:55:38          
 * @version : 1.0
 */
public class Dog extends Animal{
	public void eat(){
		System.out.println("eating Bone");
	}
}

[color=green][size=large]结果[/size][/color]

/**
 * 
 */
package com.study.feature;

/**   
 * 
 * @className ：Main  
 * @package : com.study.feature 
 * @Description ：多态测试   
 * @author：lgf   
 * @date ：2012 三月 12  13:57:11          
 * @version : 1.0
 */
public class Main {

	public static void main(String[] args) {
		Animal animal = null;
		animal = new Animal();
		animal.eat();//eating
		Animal cat = new Cat();
		cat.eat();//eating fish
		Animal dog = new Dog();
		dog.eat();//eating Bone
	}
}

[color=green][size=large]例子2[/size][/color]

/**
 * 
 */
package com.study.feature;

/**   
 * 
 * @className ：Father  
 * @package : com.study.feature 
 * @Description ：多态   
 * @author：lgf   
 * @date ：2012 三月 12  14:53:41          
 * @version : 1.0
 */
public class Father {
	public void functionOne(){
		functionSecond();
	}
	public void functionSecond(){
		System.out.println("Father functionSecond");
	}
}

/**
 * 
 */
package com.study.feature;

/**   
 * 
 * @className ：Children  
 * @package : com.study.feature 
 * @Description ：测试   
 * @author：lgf   
 * @date ：2012 三月 12  14:55:15          
 * @version : 1.0
 */
public class Children extends Father{
	public void functionSecond(){
		System.out.println("Children functionSecond");
	}

	public static void main(String[] args) {
		Father c = new Children();
		c.functionOne();//Children functionSecond
	}
}