Java 面向对象的基本特征

前言： 

　　在刚开始接触Java的时候，那时候面对Java面向对象的几大特征一直理解的不是很理解，借着空闲时间在这里整理一下，同时在加深一下印象。

一、封装：

　　　　Java面向对象的特征之封装，所谓的封装就是指一个类把自己内部的实现细节隐藏，对外提供set/get方法，封装又分为属性的封装和方法的封装。把属性定义为私有的，它们通过setter和getter方法来对属性的值进行设定和获取，在我们实际的代码开发正分装用到的地方非常广泛，举个最简单的例子就是我们的pojo　

public class User {

    private Integer userID;

    private String userName;

    private String address;

    public Integer getUserID() {
        return userID;
    }

    public void setUserID(Integer userID) {
        this.userID = userID;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

　　　　在上面类中，定义了三个成员变量，它们的访问修饰都是private私有的，通过setter和getter方法对这些变量进行设值以及取值。那么这么做有什么好处呢？封装的意义就是增强类的信息隐藏与模块化，提高安全性。封装的主要作用也是对外部隐藏具体的实现细节，增加程序的安全性。

二、继承：

　　在Java中如果现有类无法满足我们所需的字段或方法时、同时我们又不想或无法更改现有类是，这时我们则需要重新创建一个新的类同时继承之间的类，新创建的类我们称为（子类），子类可以拥有父类的成员变量以及成员方法（非私有）继承的作用就是能提高代码的复用性。子类拥有父类中的一切，它可以访问和使用父类中的非私有成员变量，以及重写父类中的非私有成员方法。

　　定义一个父类Person其中有如下方法和字段：　　　　

public class Person {
    private Integer age;

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void test(){
        System.out.println("父类test方法");
    }

    public void mowen(){
        System.out.println("父类莫问方法");
    }
}

　　定义一个子类User并且继承Person类：　　　

public class User extends Person{

    private Integer userID;

    private String userName;

    private String address;

    public void test(){
        System.out.println("子类test方法");
    }

    public Integer getUserID() {
        return userID;
    }

    public void setUserID(Integer userID) {
        this.userID = userID;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

　　执行测试：

public class Test {

    public static void main(String[] args){
        User user = new User();
        user.setAge(12);
        user.test();
        user.mowen();
        System.out.println(user.getAge());
    }
}

　　测试结果：

子类test方法
父类莫问方法
12

Process finished with exit code 0

　　我们很清楚的看到子类中可以调用父类中的莫问()方法，且在子类中重写了父类的test()方法，执行结果以子类为准，且子类继承了父类的字段age。

三、抽象：

　　当一个类中有一个abstract修饰符（但要注意只要有抽象方法的类就是抽象类）、父类中存在抽象方法（也可以没有）抽象方法没有方法体并且修饰符一定要是public或者protected，且抽象类不能不能实例化

　　所有子类都必须实现这些抽象方法（如果没实现就必须把它也定义成一个抽象方法） 虽然不能new出来但是它可以有自己的static方法。

　　抽象类中可以定义抽象方法和不同方法，也可以定义变量，但如果抽象类存在抽象方法（注：抽象方法不能用private私有化），继承他的子类必须要实现该方法，否则编译就无法通过

四、多态：

　　在面向对象的四个基本特征中多态是非常重要的，同时相比较其他的特征稍微复杂一点，下面就重点说一下Java中的多态

　　　　多态存在的必要条件：

　　　　　　1、有继承关系　　

　　　　　　2、子类重写父类方法　　

　　　　　　3、父类引用指向子类对象

　　　　多态存在必须要有“子类重写父类方法”这一条件，name就要注意下面三种情况是没有办法表现出多态特性的（因为不能被重写）：

　　　　　　1、static方法，因为被static修饰的方法是属于类的，而不是属于实例的

　　　　　　2、final方法，因为被final修饰的方法无法被子类重写

　　　　　　3、private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个不能被外部引用的方法，怎么能谈多态呢

 　　先来编写两个类Father、Children，同时Children继承Father类

public class Father {

   private Integer age;

   public Integer getAge() {
      return age;
   }  

   public void setAge(Integer age) {
      this.age = age;
   }
}

public class Children extends Father{

    private String userName;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
}

　　向上转型：（子类进行类的提升转换为父类）

public class Test {

    public static void main(String[] args){
       Father father = new Children();
        father.setAge(22);
        ((Children) father).setUserName("逝清雪");
        System.out.println(father.getAge() + "\n" + ((Children) father).getUserName());
    }
}

　　测试结果：

22
逝清雪

Process finished with exit code 0

　　　　通过测试我们可以发现，当子类进行类的提升后，原本父类（Father）中并没有UserName字段，而UserName这个字段原本是出现在子类中的，但现在父类却可以对子类的中的字段进行操作，由此可以看出：多态中的向上转型后，父类拥有了子类的特性，换句话说，向上转型后还是子类自己本身。

　　向下转型：（在java中Children c = new Father()是无法编译通过的，在这里必须强行转换）

public class Test {

    public static void main(String[] args){
       Father father = new Children();
       Children children = (Children) father;
       children.setAge(22);
       children.setUserName("逝清雪");
       System.out.println(father.getAge() + "\n" + ((Children) father).getUserName());
    }
}

　　测试结果：　　　　

22
逝清雪

Process finished with exit code 0

　　　　向下转型，我们必须要进行强转，同时可以看到子类可以操作父类中的字段，由此可以看出：向下转型子类拥有了父类的特性，

　　由此我们可以看出：在Java中的多态不管是向上转型、还是向下转向，最后都还是子类本身。