面向对象编程的四大特征(封装、多态、抽象)

封装

(1).概念(实现代码的重用)：封装是指类中的成员变量都是private，并提供public方法访问这些成员变量的技术。如果一个成员变量被声明为private，那么它就不能被其它类访问，从而隐藏了类中的成员变量。因此，封装也被称为数据隐藏。

(2).访问修饰符：                             本类                  同包中不同类                  不同包               子类

                      public                       Y                            Y                             Y                     Y 

                      protected                  Y                            Y                                                    Y

                      default(不写)             Y                             Y

                      private                     Y

                      (确保数据安全性，隐藏实现细节) private     这些访问修饰符访问权限由大到小

---

(3).优点：类的成员变量可以变成只读或只写的。

              类可以对存储在其成员变量中的内容有一个整体的控制。

              类的用户不需要知道类是如何存储数据的。

补充：

A:理解静态成员

指类和类的多个对象共同拥有的一个属性或者是方法，静态成员可以通过类名.静态成员名或者是对象名.静态成员名调用，需要注意的是，如果你定义了一个静态成员public static int A = 10，类调用了这个静态成员并且将10改成了20，那么其它的对象再调用这个A此时他们得到的值就是20，因为他们和类共同拥有一个静态成员。

B:访问静态成员变量和方法

C:静态方法不能访问实例成员

D:静态初始化块

E:内部类

a:静态内部类，作为类的静态成员，存在于某个类的内部

b:成员内部类，作为类的成员，存在于某个类的内部

c:局部内部类，存在于某个方法内部的类

d:匿名内部类，存在于某个类的内部，但是无类名的类

eg：

package com.lovo.chap08.demo;

public class Outter {
    int i = 1;
    static int j = 2;

    /**
     * 成员内部类
     * @author Administrator
     *
     */
    class Inner1{
        int k = 3;
        
        public void show(){
            System.out.println("k=" + k);
            System.out.println("i=" + i);
        }
    }
    
    /**
     * 静态内部类
     * @author Administrator
     *
     */
    static class Inner2{
        int k = 3;
        
        public void show(){
            System.out.println("k = " + k);
            System.out.println("j = " + j);
        }
    }
    
    public void show(){
        final int k = 3;
        /**
         * 局部内部类
         * @author Administrator
         *
         */
        class Inner3{
            int m = 4;
            
            public void show(){
                System.out.println("m=" + m);
                System.out.println("k=" + k);
            }
        }
        
        new Inner3().show();
    }
    
    public void print(Inter inter){
        inter.printfInterface();
    }
}

interface Inter{
    void printfInterface();
}

多态

(1).分类：静态多态：指程序在编译时，系统就能决定调用哪个方法，所以也称编译时多态，实现方法为方法重载

              动态多态：指在运行中系统才能动态确定方法所指的对象，所以也称为运行时多态，实现方式是重写父类中的同名成员方法

(2).多态技术基础：向上转型技术、向下转型技术、instanceof关键字【前面的类型是否是后面类型的实例】、动态绑定技术

(3).多态的应用

a.多态参数：就是当方法的某个形式参数是一个引用的时候，与该引用兼容的任何对象都可以传递给方法，从而允许方法接受不同数据类型的形式参数。

eg：public void payEmployee(Employee e){}

b.异构集合：不同对象的集合

eg：Salary[] salary=new Salary[n];

(4).实现多态的步骤：编写父类、子类；子类重写父类方法；用父类的数据类型去引用子类对象。

抽象

(1).抽象类：使用关键字abstract声明，不能被实例化，需要子类继承，因为实例化对象无意义

(2).抽象方法：子类被约束，父类无意义

     将一个方法声明为抽象方法有两个结果：类必须声明为抽象类

                                                         任何子类必须重写抽象方法，除非子类本身也是抽象的

将一个抽象方法放在父类中，可以强制任何子类实现一个特别的行为。