【Java基本功】一文了解Java中继承、封装、多态的细节

本节主要介绍Java面向对象三大特性：继承 封装 多态，以及其中的原理。

本文会结合虚拟机对引用和对象的不一样处理来介绍三大特性的原理。

继承

Java中的继承只能单继承，可是能够经过内部类继承其余类来实现多继承。

<pre>

1. public class Son extends Father{
2. public void go () {
3. System.out.println("son go");
4. }
5. public void eat () {
6. System.out.println("son eat");
7. }
8. public void sleep() {
9. System.out.println("zzzzzz");
10. }
11. public void cook() {
12. //匿名内部类实现的多继承
13. new Mother().cook();
14. //内部类继承第二个父类来实现多继承
15. Mom mom = new Mom();
16. mom.cook();
17. }
18. private class Mom extends Mother {
19. @Override
20. public void cook() {
21. System.out.println("mom cook");
22. }
23. }
24. }

封装

封装主要是由于Java有访问权限的控制。public > protected > package = default > private。封装能够保护类中的信息，只提供想要被外界访问的信息。

类的访问范围

1. A、public 包内、包外，全部类中可见
2. B、protected 包内全部类可见，包外有继承关系的子类可见
3. (子类对象可调用)
4. C、(default)表示默认，不只本类访问，并且是同包可。
5. D、private 仅在同一类中可见

</pre>

多态

多态通常能够分为两种，一个是重写，一个是重载。

1. 重写是因为继承关系中的子类有一个和父类同名同参数的方法，会覆盖掉父类的方法。重载是由于一个同名方法能够传入多个参数组合。
2. 注意，同名方法若是参数相同，即便返回值不一样也是不能同时存在的，编译会出错。
3. 从jvm实现的角度来看，重写又叫运行时多态，编译时看不出子类调用的是哪一个方法，可是运行时操做数栈会先根据子类的引用去子类的类信息中查找方法，找不到的话再到父类的类信息中查找方法。
4. 而重载则是编译时多态，由于编译期就能够肯定传入的参数组合，决定调用的具体方法是哪个了。

向上转型和向下转型：

1. public static void main(String[] args) {
2. Son son = new Son();
3. //首先先明确一点，转型指的是左侧引用的改变。
4. //father引用类型是Father，指向Son实例，就是向上转型，既能够使用子类的方法，也能够使用父类的方法。
5. //向上转型,此时运行father的方法
6. Father father = son;
7. father.smoke();
8. //不能使用子类独有的方法。
9. // father.play();编译会报错
10. father.drive();
11. //Son类型的引用指向Father的实例，因此是向下转型，不能使用子类非重写的方法，能够使用父类的方法。
12. //向下转型，此时运行了son的方法
13. Son son1 = (Son) father;
14. //转型后就是一个正常的Son实例
15. son1.play();
16. son1.drive();
17. son1.smoke();
18. //由于向下转型以前必须先经历向上转型。
19. //在向下转型过程当中，分为两种状况：
20. //状况一：若是父类引用的对象若是引用的是指向的子类对象，
21. //那么在向下转型的过程当中是安全的。也就是编译是不会出错误的。
22. //由于运行期Son实例确实有这些方法
23. Father f1 = new Son();
24. Son s1 = (Son) f1;
25. s1.smoke();
26. s1.drive();
27. s1.play();
28. //状况二：若是父类引用的对象是父类自己，那么在向下转型的过程当中是不安全的，编译不会出错，
29. //可是运行时会出现java.lang.ClassCastException错误。它能够使用instanceof来避免出错此类错误。
30. //由于运行期Father实例并无这些方法。
31. Father f2 = new Father();
32. Son s2 = (Son) f2;
33. s2.drive();
34. s2.smoke();
35. s2.play();
36. //向下转型和向上转型的应用，有些人以为这个操做没意义，何须先向上转型再向下转型呢，不是画蛇添足么。其实能够用于方法参数中的类型聚合，而后具体操做再进行分解。
37. //好比add方法用List引用类型做为参数传入，传入具体类时经历了向下转型
38. add(new LinkedList());
39. add(new ArrayList());
40. //总结
41. //向上转型和向下转型都是针对引用的转型，是编译期进行的转型，根据引用类型来判断使用哪一个方法
42. //而且在传入方法时会自动进行转型（有须要的话）。运行期将引用指向实例，若是是不安全的转型则会报错。
43. //若安全则继续执行方法。
44. }
45. public static void add(List list) {
46. System.out.println(list);
47. //在操做具体集合时又经历了向上转型
48. //        ArrayList arr = (ArrayList) list;
49. //        LinkedList link = (LinkedList) list;
50. }

总结： 向上转型和向下转型都是针对引用的转型，是编译期进行的转型，根据引用类型来判断使用哪一个方法。而且在传入方法时会自动进行转型（有须要的话）。运行期将引用指向实例，若是是不安全的转型则会报错，若安全则继续执行方法。

编译期的静态分派

其实就是根据引用类型来调用对应方法。

<pre>

1. public static void main(String[] args) {
2. Father father= new Son();
3. 静态分派 a= new 静态分派();
4. //编译期肯定引用类型为Father。
5. //因此调用的是第一个方法。
6. a.play(father);
7. //向下转型后，引用类型为Son，此时调用第二个方法。
8. //因此，编译期只肯定了引用，运行期再进行实例化。
9. a.play((Son)father);
10. //当没有Son引用类型的方法时，会自动向上转型调用第一个方法。
11. a.smoke(father);
12. //
13. }
14. public void smoke(Father father) {
15. System.out.println("father smoke");
16. }
17. public void play (Father father) {
18. System.out.println("father");
19. //father.drive();
20. }
21. public void play (Son son) {
22. System.out.println("son");
23. //son.drive();
24. }

</pre>

方法重载优先级匹配

<pre>

1. public static void main(String[] args) {
2. 方法重载优先级匹配 a = new 方法重载优先级匹配();
3. //普通的重载通常就是同名方法不一样参数。
4. //这里咱们来讨论当同名方法只有一个参数时的状况。
5. //此时会调用char参数的方法。
6. //当没有char参数的方法。会调用int类型的方法，若是没有int就调用long
7. //即存在一个调用顺序char -> int -> long ->double -> ..。
8. //当没有基本类型对应的方法时，先自动装箱，调用包装类方法。
9. //若是没有包装类方法，则调用包装类实现的接口的方法。
10. //最后再调用持有多个参数的char...方法。
11. a.eat('a');
12. a.eat('a','c','b');
13. }
14. public void eat(short i) {
15. System.out.println("short");
16. }
17. public void eat(int i) {
18. System.out.println("int");
19. }
20. public void eat(double i) {
21. System.out.println("double");
22. }
23. public void eat(long i) {
24. System.out.println("long");
25. }
26. public void eat(Character c) {
27. System.out.println("Character");
28. }
29. public void eat(Comparable c) {
30. System.out.println("Comparable");
31. }
32. public void eat(char ... c) {
33. System.out.println(Arrays.toString(c));
34. System.out.println("...");
35. }
36. //    public void eat(char i) {
37. //        System.out.println("char");
38. //    }