java的三大特性，封装，继承，多态

封装 

/**
 * 所谓封装，就是将对象具有的成员变量和成员函数包装和隐藏起来，让外界无法直接使用，
 * 被封装的成员只能通过某些特定的方式才能访问。
 * 实现封装有两个步骤：
 *   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;
    }
}

继承 
父类 ExtendsFather.java 

/**
 * 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
 * 对象的一个新类可以从现有的类中派生。
 * 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");
    }
}

同包下的子类 ExtendsChildrenSamePackage.java 

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();
    }
}

不同包下的子类 ExtendsChildrenOtherPackage.java 

/**
 *
 */
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();
    }
}

重载和重写 ExtendsOverRideLoad.java 

/**
 *
 */
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");
    }
}

多态 

父类  Animal.java 

/**
 * 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");
    }
}

多态实现 

/**
 *
 */
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");
    }
}

结果 

/**
 *
 */
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
    }
}

例子2 

/**
 *
 */
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
    }
}