java的三大特性之封装

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

以前对于java基础的掌握太差，以至于现在有些东西还不知道，前几天看到一篇文章颇有感触，今天写出来给大家分享一下：

• 封装
• 继承
• 多态

---

详解封装

对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。

使用封装的好处：

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。
• 可以对成员进行更精确的控制。
• 隐藏信息，实现细节。

我们来一起看一下下段这个代码：

public class test(){
  private String name;//定义私有属性
  private String sex;
  private int age;


   /* 
     * setter()、getter()是该对象对外开发的接口 
     */  
    public String getName() {  
        return name;  
    }  

    public void setName(String name) {  
        this.name = name;  
    }  

    public String getSex() {  
        return sex;  
    }  

    public void setSex(String sex) {  
        this.sex = sex;  
    }  

     public int getAge() {  
        return age;  
    }  

    public void setAge(int age) {  
        if(age > 120){  
            System.out.println("ERROR：error age input....");    //提示錯誤信息  
        }else{  
            this.age = age;  
        }  
    }   
}

以上就是对 test.java 类的一个简单封装，类内定义了一些私有属性以及其setter()和getter()方法。这样定义的好处就是：这里定义的每一个属性和数据库字段意义对应，在我们后期将查询数据封装成对象属性以便于对数据的操作。

详解继承

继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。

同时在使用继承时需要记住三句话：
1、子类拥有父类非private的属性和方法。
2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
3、子类可以用自己的方式实现父类的方法。

除了那些private的外还有一样是子类继承不了的—构造器。对于构造器而言，它只能够被调用，而不能被继承。 调用父类的构造方法我们使用super()即可。

我们来看下一段代码：

public class Person {  
    protected String name;  
    protected int age;  
    protected String sex;  

    Person(){  
        System.out.println("Person Constrctor...");  
    }  
}  

public class Husband extends Person{  
    private Wife wife;  

    Husband(){  
        System.out.println("Husband Constructor...");  
    }  

    public static void main(String[] args) {  
        Husband husband  = new Husband();  
    }  
}  

Output:  
Person Constrctor...  
Husband Constructor...

private访问修饰符，对于封装而言，是最好的选择，但这个只是基于理想的世界，有时候我们需要这样的需求：我们需要将某些事物尽可能地对这个世界隐藏，但是仍然允许子类的成员来访问它们。
这个时候就需要使用到protected。
对于protected而言，它指明就类用户而言，他是private，但是对于任何继承与此类的子类而言或者其他任何位于同一个包的类而言，他却是可以访问的。

继承存在如下缺陷：
1、父类变，子类就必须变。
2、继承破坏了封装，对于父类而言，它的实现细节对与子类来说都是透明的。
3、继承是一种强耦合关系。

详解多态

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定， 即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法， 必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码， 就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变， 即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

我们来看下段代码

 public class Wine {  
    public void fun1(){  
        System.out.println("Wine 的Fun.....");  
        fun2();  
    }  

    public void fun2(){  
        System.out.println("Wine 的Fun2...");  
    }  
}  

public class JNC extends Wine{  
    /** 
     * @desc 子类重写父类方法 
     *        父类中不存在该方法，向上转型后，父类是不能引用该方法的 
     * @param a 
     * @return void 
     */  
    public void fun1(String a){  
        System.out.println("JNC 的 Fun1...");  
        fun2();  
    }  

    /** 
     * 子类重写父类方法 
     * 指向子类的父类引用调用fun2时，必定是调用该方法 
     */  
    public void fun2(){  
        System.out.println("JNC 的Fun2...");  
    }  
}  

public class Test {  
    public static void main(String[] args) {  
        Wine a = new JNC();  
        a.fun1();  
    }  
}  
-------------------------------------------------  
Output:  
Wine 的Fun.....  
JNC 的Fun2...  

从程序的运行结果中我们发现，a.fun1()首先是运行父类Wine中的fun1().然后再运行子类JNC中的fun2()。
分析：在这个程序中子类JNC重载了父类Wine的方法fun1()，重写fun2()，而且重载后的fun1(String a)与 fun1()不是同一个方法，
由于父类中没有该方法，向上转型后会丢失该方法，所以执行JNC的Wine类型引用是不能引用fun1(String a)方法。
而子类JNC重写了fun2() ，那么指向JNC的Wine引用会调用JNC中fun2()方法。

另附：

Java实现多态有三个必要条件：继承、重写、向上转型。
继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。.

鄙人第一次写博客，有些的不好地方，还请见谅！