Java中面向对象三大特征总结

JAVA中面向对象的三大特征：

        面向对象具有继承性（Inheritance）

        面向对象具有多态性（Polymorphism）

        面向对象具有封装性（Encapsulation）

一、继承

         多个类具有共同的属性（成员变量）与行为（成员方法）的时候，将这些共同的部分抽取出来定义到一个公共的类中，其他及各类可以与这个公共的类形成继承关系，从而在多个类中不需要重 复定义公共部分!这个公共的类就是父类，也称为超类或者基类，其他的类就是子类。子类可以直接访问父类的非私有化成员变量，访问父类的私有化成员变量可以使用super.get()方法。

     1、 Java继承的特点：
      A、Java只存在单个继承不存在多个继承，即：一个类只能有一个父类
      B、Java可以多层继承，多重继承

     2、Java继承的优点
     A、继承是基于存在多个重复代码的时候提出的，那么继承能很好的提高复用率！
     B、使类与类之间存在继承关系，是实现多态操作的前提！
     C、继承关键字：extends
     3、Java继承的缺点
     A、继承使得多个类之间具有了子父类关系，当一个类存在多个子类的时候，如果父类发生变化，那么这些子
           类会跟着一同变化，造成类与类之间的“强耦合”关系！

    4、Java继承注意点
    A、不要仅仅为了获取某个类的某个功能而去继承这个类
    B、类与类之间要存在所属关系，不能够随意继承
           例：人与狗都具有吃饭的动作，
           class Person
           {
             public void eat(){}
           }
           class Dog extends Person
           {
             //此时为了实现吃饭的动作，而继承人，这是不合适的！
           }
                  所谓的所属关系是is--a的关系，也就是说AAA is BB 的....
           class Person
           {
             public void eat(){}
           }
           class Student extends Person
           {
             //学生是人的某一个群体，可以同时具有吃饭的动作
           }
           
     5、何时使用继承
     A、具有公共的属性与行为操作的时候，提高复用性
     B、具有is--a的所属关系的类与类之间

    6、类的主要组成部分的子父类继承关系中的特点！
    A、成员变量
    a、继承关系中同名的子类成员变量、局部变量、父类的成员变量这三者之间
                使用顺序：
                       在具有相同变量名的这种情况下，不使用this、super等关键字进行调用时，即成员变量前什么
                       都不写调用顺序按照由局部变量位置---当前类成员变量位置---父类成员变量位置
                       依次进行查找变量，什么位置先有值，就会使用这个值！
                调用方式：this，super
 
  B、成员方法
    a、继承中的成员方法
                使用顺序：当子类具有与父类同名成员方法时，进行调用过程中不使用this、super等关键字，即成
                                  员方法前什么都不写方法的有效顺序：当前类的成员方法---父类的成员方法
                                  子类中有方法实现，则按照子类的实现进行，若在子类中使用super调用了父类的方法，那
                                  么父类方法也要执行！但是默认成员方法内是没有super调用的！！！
    b、重写
                 概念：子类中出现与父类一模一样的方法时，会出现子类方法将父类方法覆盖的情况，这种情况成为重
                            写或者复写
    
    c、重写注意事项
       - 父类中的私有方法不可以被重写，覆盖！
       - 子类重写父类方法后，继续使用父类的方法时候，可以使用super调用
       - 重写时，子类的方法的访问权限要大于或者等于父类成员方法的访问权限
       - 静态方法只能被静态方法覆盖
       - 子类对于父类的功能有增强需求的时候，可以重写父类的方法以增强其功能！
       
    d、重写与重载的区别
    
                 重写：子父类之间，方法完全相同（返回值、方法名、参数列表），
                            但是子父类之间的方法体必须不同，否则没有意义！
                 重载：同一个类中，方法名相同，参数列表不同，与返回值无关！
                          （参数列表：包括两项：参数个数，对应参数的数据类型）
                            重载何时使用：当一个类中需要完成某个相同功能，但是方法的参数不同需要分别进行操作时！
    
  C、构造方法
 
    a、子类中所有的构造方法默认都访问父类中无参构造
    b、每个构造方法的第一行是super();super(参数列表);如果把这两行代码放在非第一行位置会报错
    c、根据构造方法的特性，在手动给出任意一个构造方法的时候，之前默认的无参构造会被覆盖，此时具有
                 继承关系的时候，子类之前默认存在的每个构造都调用无参构造super();失效，
                 此时必须在每个构造方法中手动给出super(参数列表);的方式直接或间接调用之前手动在父类中给出
                 的构造！
    d、构造方法执行了一定会创建相应对象吗？
                 不一定，当具有继承关系的类时，子类创建对象的时候会调用父类的构造方法，用来初始化父类的成员变
                 量这个时候父类的构造执行了，但是内存中并没有父类的对象！
    e、构造方法是否可以被重写或者继承？
                 不可以，因为构造方法名需要与类名相同，假如出现继承或者重写关系，就会有子类中有一个与父类的类
                 名相同的构造方法，但是又由于构造方法需要与类名相同，此时子类类名需要与构造相同，这个时候就会
                 出现父类与子类的类名相同，父类类名==构造方法名==子类类名，不能存在同名的类！

     二、多态

          java程序中定义的引用变量所指向的具体类型和通过该引用类型发出的方法在调用时不确定，该引用变量发出的方法到底调用哪个类的实现的方法，必须在程序运行期间才能决定，这就是多态。

      1、多态存在的前提

       A.必须有子类和父类，具有继承或实现

      B.子类必须重写父类的方法

      C.父类的引用变量指向子类的对象

      2、多态的优点

      A. 可替换性，多态对一存在的代码具有可替代性

      B. 可扩充性：增加的子类不影响已存在的类的特性的运行和操作

      C. 接口性：多态时超类通过方法签名想子类提供了一个公共的接口，由子类来完善或者覆盖它而实现的

      D. 灵活性：在应用中体现了灵活多样的操作，提高了使用的效率

      E. 简化性： 多态简化对应用软件的代码的编写和修改过程，尤其在处理大量的对象的运算和操作时，这个特点尤为突出和重要

     3、多态的缺点

     A. 只能使用父类的引用访问父类的成员

     4、多态中的成员特点：
     成员变量：编译与运行时期都看父类！
     成员方法：编译时期看父类，运行时期看子类

package polymorphism.first;

/**
 * 这里是一个动物的父类，其中有公共的方法
 * 用来完成动物公共的行为
 *
 */
public class Animal {

    public String name;
    
    /**
     * 动物的公共行为：吃饭
     */
    public void eat(){
        System.out.println("这里是Animal类的eat");
    }
    /**
     * 这个方法是动物的公共行为：活着
     */
    public void live(){
        System.out.println("这里是Animal类的live");
    }
    public void live1(){
        System.out.println("这里是Animal类的live1");
    }
    public void live2(){
        System.out.println("这里是Animal类的live2");
    }
    
}

      package polymorphism.first;

/**
 * 这里是为了解决重复代码过多的问题而创建的工具类，在这个类中将公共的代码进行
 * 抽取，从而减少代码重复度！
 *
 */
public class AnimalTool {

    /**
     * 对于猫的动作的抽取
     * @param ca
     */
    public static void doCat(Cat ca){
        
        ca.eat();
        ca.live();
        ca.live1();
        ca.live2();
    }
    public static void doDog(Dog dog){
        
        dog.eat();
        dog.live();
        dog.live1();
        dog.live2();
    }
    public static void doCat(Pig pig){
    
        pig.eat();
        pig.live();
        pig.live1();
        pig.live2();
    }
    
    /**
     * 以上这些方法仅仅是对某个子类的方法进行了抽取操作
     * 但是仍然重复度比较高
     * 更好思路：
     * 1、当前的这些类Animal、Cat、Dog、Pig之间是具有子父关系的，
     * 2、根据之前提起的“类型转换”的思路，所有子类是归属于Animal这个大类的
     *
     */
    
    /**
     * 将这些子类归属于同一个父类Animal
     * @param an
     */
    public static void doAnimal(Animal an){
        an.eat();
        an.live();
        an.live1();
        an.live2();
    }
    
}

package polymorphism.first;

/**
 * 当前是一个测试类，用来测试Animal系列的类的多态操作！
 * @author HM
 *
 */
public class Test {
    
    public static void main(String[] args) {
        
        /**
         * 现在Animal与Cat、Dog之间构成了多态，子类继承父类，同时对父类的eat方法进行了重写
         * 现在要使用子类重写后的show方法
         */
        Animal an1=new Cat();
        an1.eat();
        an1.live();
        an1.live1();
        an1.live2();
        System.out.println("============");
        Animal an2=new Dog();
        an2.eat();
        an2.live();
        an2.live1();
        an2.live2();
        System.out.println("============");

     }

}

      三、封装

     所谓封装指的是隐藏对象的属性以及实现细节，仅对外提供访问方式，将不需要对外提供的内容进行隐藏，把属性隐藏对外提供访问方式
      
2、封装的优点

      将变化隔离
      便于使用
      提高重用性
      提高安全性
      
  3、封装的缺点：
      将变量等使用private修饰，或者封装进方法内，使其不能直接被访问，增加了访问步骤与难度！
      
3、封装的实现形式
  A、使用访问权限修饰符private
            在定义JavaBean时对于成员变量使用private进行修饰，同时对外提供set、get方法
            使用了private修饰的成员在其他类中不能直接访问，此时需要使用set、get方法进行。
            对比：
            对于成员变量直接使用public修饰与使用private修饰的区别
            使用public修饰时，可以使用对象进行直接访问，访问方便但是不能添加校验逻辑
            使用private修饰时，需要提供set、get方法这个时候在set、get方法中可以书写校验
            逻辑（if、else、for、while等这些逻辑控制操作必须写在方法中） 
  B、定义一个Java类与Java的方法就是最简单最常见的面向对象的封装操作，这些操作符合隐藏
           实现细节，提供访问方式的思路