一、基础篇--1.1Java基础-面向对象的特征

• 面向对象的特征

　　封装、继承和多态

　　https://blog.csdn.net/jianyuerensheng/article/details/51602015

　　封装：

　　　　定义：封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。被封装的对象通常被称为抽象数据类型。

　　　　优点：1、保护数据成员，不让类以外的程序直接访问或修改，只能通过提供的公共的接口访问==>数据封装。

　　　　　　　2、方法的细节对用户是隐藏的，只要接口不变，内容的修改不会影响到外部的调用者==>方法封装。

　　　　　　　3、良好的封装可以降低程序的耦合度。

　　　　类成员的修饰符

访问修饰符	同一个类	同包	不同包，子类	不同包，非子类
private	√
default	√	√
protect	√	√	√
public	√	√	√	√

　　继承：
　　　　定义：继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。继承所描述的是“is-a”的关系。

　　　　特点：

　　　　　1、子类拥有父类非private的属性和方法

　　　　　2、子类可以添加自己的方法和属性，对父类进行扩展

　　　　　3、子类可以重新定义父类的方法

　　　　缺点：

　　　　　1、父类变动，子类就会跟着变动

　　　　　2、继承破坏了封装，父类对子类机会是透明的

　　　　　3、继承是强耦合

　　　　《Think in java》中提到：问一问自己是否需要从子类向父类进行向上转型。如果必须向上转型，则继承是必要的，但是如果不需要，则应当好好考虑自己是否需要继承。

　　　　构造函数：

　　　　　1、子类无法继承父类的构造函数

　　　　    2、创建子类时候，编译器会自动调用父类的无参构造函数

　　　　　3、如果父类没有无参构造函数，需要在子类的构造函数中第一行用super调用父类的构造函数

　　多态：

　　　　定义：所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定。

因为是在程序运行期间才能确定，所以不用修改代码就可以让程序选择多个运行状态，这就是多态。

　　　　多态的实现条件：继承、重写、向上转型

　　　　　　对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

　　　　　　例如：　　　　　

public class People {
    public void say(){
        System.out.println("我是人");
    }
}

public class Male extends People {
    @Override
    public void say() {
        System.out.println("我是男人");
    }

    public static void main(String[] args) {
        People people = new Male();
        peopleSay(people);

    }
    private static void peopleSay(People people){
        people.say();
    }
}

　　　　　　peopleSay(People people) 调用的不是引用变量类型people方法里的say，调用的是引用对象类型的即male的say方法。

　　　　实现的形式：在java里实现多态的方式，继承和接口。

　　　　　　继承：对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。

　　　　　　　　　如果父类是抽象类，那么子类必须要实现父类中所有的抽象方法，这样该父类所有的子类一定存在统一的对外接口，但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。

　　　　　　接口：指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

　　　　　　　　　继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

　　　　　　经典实例分析：　　　　

public class A {  
    public String show(D obj) {  
        return ("A and D");  
    }  
  
    public String show(A obj) {  
        return ("A and A");  
    }   
  
}  
  
public class B extends A{  
    public String show(B obj){  
        return ("B and B");  
    }  
      
    public String show(A obj){  
        return ("B and A");  
    }   
}  
  
public class C extends B{  
  
}  
  
public class D extends B{  
  
}  
  
public class Test {  
    public static void main(String[] args) {  
        A a1 = new A();  
        A a2 = new B();  
        B b = new B();  
        C c = new C();  
        D d = new D();  
          
        System.out.println("1--" + a1.show(b));  
        System.out.println("2--" + a1.show(c));  
        System.out.println("3--" + a1.show(d));  
        System.out.println("4--" + a2.show(b));  
        System.out.println("5--" + a2.show(c));  
        System.out.println("6--" + a2.show(d));  
        System.out.println("7--" + b.show(b));  
        System.out.println("8--" + b.show(c));  
        System.out.println("9--" + b.show(d));        
    }  
}  

　　　　结果：

　　　　　　　

　　　　分析：　　

　　　　　　①②③比较好理解，一般不会出错。④⑤就有点糊涂了，为什么输出的不是"B and B”呢？

　　　　　当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。（但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。）

　　　　　　在继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

　　　　　   分析4：

　　　　　　 a2.show(b)，a2是一个引用变量，类型为A，则this为a2，b是B的一个实例，于是它到类A里面找show(B obj)方法，没有找到，于是到A的super(超类)找，而A没有超类，因此转到第三优先级this.show((super)O)，this仍然是a2，这里O为B，(super)O即(super)B即A，因此它到类A里面找show(A obj)的方法，类A有这个方法，但是由于a2引用的是类B的一个对象，B覆盖了A的show(A obj)方法，因此最终锁定到类B的show(A obj)，输出为"B and A”。

　　　　　　分析5：

　　　　　　 a2.show(c)，a2是A类型的引用变量，所以this就代表了A，a2.show(c),它在A类中找发现没有找到，于是到A的超类中找(super)，由于A没有超类（Object除外），所以跳到第三级，也就是this.show((super)O)，C的超类有B、A，所以(super)O为B、A，this同样是A，这里在A中找到了show(A obj)，同时由于a2是B类的一个引用且B类重写了show(A obj)，因此最终会调用子类B类的show(A obj)方法，结果也就是B and A。

　　　　　　分析8：

　　　　　　 b.show(c)，b是一个引用变量，类型为B，则this为b，c是C的一个实例，于是它到类B找show(C obj)方法，没有找到，转而到B的超类A里面找，A里面也没有，因此也转到第三优先级this.show((super)O)，this为b，O为C，(super)O即(super)C即B，因此它到B里面找show(B obj)方法，找到了，由于b引用的是类B的一个对象，因此直接锁定到类B的show(B obj)，输出为"B and B”。

　　　　　 按照同样的方法我也可以确认其他的答案。
  　　　　　 当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这我们用一个例子来说明这句话所代表的含义：a2.show(b)；

　　　　　这里a2是引用变量，为A类型，它引用的是B对象，因此按照上面那句话的意思是说有B来决定调用谁的方法,所以a2.show(b)应该要调用B中的show(B obj)，产生的结果应该是“B and B”，但是为什么会与前面的运行结果产生差异呢？这里我们忽略了后面那句话“被调用的方法必须是在超类中定义过的”，那么show(B obj)在A类中存在吗？根本就不存在！所以这句话在这里不适用？那么难道是这句话错误了？非也！其实这句话还隐含这这句话：它仍然要按照继承链中调用方法的优先级来确认。所以它才会在A类中找到show(A obj)，同时由于B重写了该方法所以才会调用B类中的方法，否则就会调用A类中的方法。