面向对象

面向对象学习（只写出自己以前比较困惑的知识点）

一，重写、覆盖、隐藏、重载，java中的各种专业术语，归纳一下

　　　　　　　　从全局来看，java只有重写、隐藏、重载3种，具体归纳如下：

　　　　　　　　基本概念：方法签名：方法名+参数列表（参数类型、个数、顺序）。

二，重写（又叫做覆盖）

只有实例方法可以被重写！重写后的方法必须仍为实例方法！(实例方法------重写------>实例方法) 。
成员变量和静态方法都不能被重写，只能被隐藏。
超类Parent中有实例方法A，子类child定义了与A“相同签名和子集返回类型”的实例方法B，子类对象ChildObj只能调用自己的实例方法B。即使将子类对象ChildObj转换为超类对象ParentObj，ParentObj依然只能调用重写后的实例方法B(超类对象ParentObj中的实例方法A已经被实例方法B覆盖了。

三，重写的语法规则如下： ===========注意：当重写后的方法调用被隐藏过的属性时，无论是否发生过向上转型，调用的都是子类的属性

　　　　　　 (1)方法签名必须相同(参数类型、个数、顺序);

　　　　　　 (2)对返回类型有要求，分2种情况：

　　　　　　　　　　　　a.被重写方法的返回类型是基本类型：重写方法的返回类型必须“相同”。基本类型包括了(byte,short,int,long,float,double,char,boolean，其实还包　　　　　　　　　　　　　　　　　　　　括一个void类型)，但要注意返回类型是封装类时属于下面的情况b。

　　　　　　　　　　　　 b.被重写方法的返回类型是引用类型：重写方法的返回类型应“相同”或是其“子类型”；引用类型包括了数组、string等一切非基本类型的类型(即类类型)。

　　　　　　(3)重写方法的访问权限不能小于被重写方法的访问权限，可以更广泛。如被重写方法是包访问权限，重写方法是public访问权限。重写方法可以改变其它的方法修饰符，如final、synchronized、native、strictfp。不管被重写方法中有无final修饰的参数，重写方法都可以增加、保留、去掉这个参数的final修饰符(参数修饰符不属于方法签名)。

　　　　　　(4)重写方法抛出的异常范围不能大于被重写方法抛出的异常的范围（-------------也可以不抛出异常------------------）。

　　　　　　 (5)不能重写final方法。(final修饰符存在的意义就是防止任何子类重写该方法)

　　　　　　(6)不能重写static静态方法。(形式上可以写，但本质上不是重写，属于下面要讲的隐藏)

　　　　　　(7)如果一个方法不能被继承，则不能重写它。或者说：只有当方法可以被访问时才可以被重写。典型的就是超类的private方法。

　　　　　（8）对于(3)需要注意：

　　　　　　　　　　　　　　 1.重写override对返回类型有要求，而重载overload对返回类型没有要求。重载可以改变返回类型。因为编译器通过对方法签名的识别即可静态编译出不同的方法。这也是java中重载与重写的区别之一。

　　　　　　　　　　　　　　2.严格来说，重写属于多态，因为是动态绑定（或称为动态联编），而重载是静态绑定，编译时即可确定。

四，隐藏 ==注：隐藏与覆盖在形式上极其类似(语法规则)，但有着本质的区别。==

　　　　1，只有成员变量(不管是不是静态)和静态方法可以被隐藏。

　　　　　　　　----------------------------成员变量------------------------

　　　　　　　　隐藏成员变量：超类Parent中有成员变量A，子类Child定义了与A同名的成员变量B，子类对象ChildObj调用的是自己的成员变量B。如果把子类对象ChildObj转换为超类对象ParentObj，ParentObj调用的是超类的成员变量A！

　　　　　　　　=======注：1.隐藏成员变量时，只要同名即可，可以更改变量类型(无论基本类型还是隐藏类型) =====

2.不能隐藏超类中的private成员变量，换句话说，只能隐藏可以访问的成员变量。

　　　 3.隐藏超类成员变量A时，可以降低或提高子类成员变量B的访问权限，只要A不是private

4.隐藏成员变量与是否静态无关！静态变量可以隐藏实例变量，实例变量也可以隐藏静态变量。-------------------非常重要

5.可以隐藏超类中的final成员变量。

五，静态方法

　　　　　　1，隐藏后的方法必须仍为静态方法！(静态方法------隐藏------>静态方法)

　　　　　　2，隐藏静态方法：超类Parent有静态方法A，子类Child定义了与A“相同签名和子集返回类型”的静态方法B，子类对象ChildObj调用的是自己的静态方法B。如果把子类对象ChildObj转换为超类对象ParentObj，ParentObj调用的是超类的静态方法A！

　　　　　　3，隐藏超类静态方法的语法规则与重写实例方法的规则几乎完全相同，只需要修改第(6)条为：(6)不能隐藏实例方法。。

六，代码练习：

 1 class Animal {  
 2     
 3             //定义两个成员
 4             char hairColor='B';
 5             
 6             int legNumber=2;
 7             
 8             //属于类的静态成员
 9             static boolean isHuman=true;
10             
11             //静态方法
12             public static void testClassMethod() {  
13                 System.out.println("The class" + " method in Animal.");  
14             }  
15             
16             //成员方法
17             public void testInstanceMethod() {  
18                 System.out.println("The instance " + " method in Animal.");  
19             }  
20 }  
21   
22 
23 //定义一个类继承自Animal
24 public class Cat extends Animal {  
25     
26             //定义同名不同类型成员
27             static int hairColor=1;  
28             char legNumber='A';  
29             
30             //静态成员
31             double isHuman=3.1415926E5;   
32             
33             //类方法不能被覆盖
34             public static void testClassMethod() {  
35                 System.out.println("The class method" + " in Cat.");  
36             }  
37           
38             //覆盖实例方法
39             public void testInstanceMethod() {  
40                 System.out.println("The instance method" + " in Cat.");  
41             }  
42           
43             
44             //测试输出
45             public static void main(String[] args) {  
46                 
47                 
48                 System.out.println("========child class=========");
49                 
50                 //子类实例化
51                 Cat myCat = new Cat();  
52                 
53                 //父类同名成员被隐藏
54                 System.out.println("myCat.hairColor="+myCat.hairColor);  
55                 System.out.println("myCat.legNumber="+myCat.legNumber);  
56                 System.out.println("myCat.isHuman="+myCat.isHuman);  
57                 
58                 //父类静态方法被隐藏
59                 myCat.testClassMethod();
60                 
61                 //父类方法被覆盖
62                 myCat.testInstanceMethod();
63                 
64                 
65                 System.out.println("========child class ---> parent class=========");  
66                 
67                 //子类向上转型
68                 Animal myAnimal = myCat;  
69                 System.out.println("========parent class=========");  
70                 
71                 //输出父类被隐藏的成员
72                 System.out.println("myAnimal.hairColor="+myAnimal.hairColor);  
73                 System.out.println("myAnimal.legNumber="+myAnimal.legNumber);  
74                 System.out.println("myAnimal.isHuman="+myAnimal.isHuman);    
75                 
76                 //输出父类被隐藏的静态方法
77                 myAnimal.testClassMethod();
78                 
79                 //父类成员方法被覆盖内存中不存在，输出子类方法
80                 myAnimal.testInstanceMethod();  
81             }  
82 }