JAVA学习第六课（面向对象）

转载自：http://blog.csdn.net/wjw0130/article/details/39127777

面向对象首先要先了解什么是面向对象？

面向对象：就是不断的和对象打交道。

早期解决问题，都是面向过程（简单来说就是一步一步怎么做，面对的是过程，即强调动作），如C语言，利用函数，进行函数的调用。

思想：

面向对象：强调的是对象，对象即指实体。c++，java，c#

例子：把大象装进冰箱

面向过程实现：1.打开冰箱  2.存储大象  3.关上冰箱

面向对象实现：（找到实体，实体封装着这些功能，也就是找到冰箱，冰箱具备打开、存储、关闭功能）
1.冰箱打开  2.冰箱存储   3.冰箱关闭

面向对象的特点：

1.符合人们的思考习惯。  2.将复杂的问题简单化

3.角色转变，针对的是对象，即面向过程中的执行者，变为面向对象的指挥者。

（土一点的说，就是对象有你需求的功能，具体它怎么做，不关我们的事）

所以解决一个问题，先找有没有解决这个问题对象，如果没有，自己编写一个对象。

面向对象思考问题举例：

   面试官招聘人员，就是面向对象的很好例子，企业接受一个项目，设计、编写、测试，面试官一个人可以完成，但是浪费大量的时间和精力，
所以他就需要招聘一些人员来帮助完成，而对象就指的是被招聘的人员，他们具备了设计、编写、测试等功能，但具体怎么实现的，面试官不
需要知道。面试官要做的，只需要找到这个对象，并指挥他来解决这个问题即可。

JAVA里面，什么都可以成为对象。
有对象找对象用对象，没对象造对象用对象，并不断的维护对象之间的关系。

面向对象的特征：

1.封装  2.继承  3.多态

规则：哪个对象，对某一动作最清楚，就把动作定义在该对象中。搬家公司搬东西，他们只需要告诉，搬运工人搬到哪即可，至于怎么搬，搬运工人最清楚，自然把搬运这个动作定义在搬运工人这个对象中。

（指挥对象做事情）

代码理解：

[html]  view plain copy

1. /*定义类就是在定义类中的成员，即组成部分  
2.  * 成员函数：对应的就是事物功能  
3.  * 成员变量：对应的就是属性  
4.  *   
5.  */  
6.   
7. //具体体现  
8.   
9. /*描述搬运过程  
10.  * 搬运工人 这一名次由属性和功能组成  
11.  * 属性：1.人数 2.性别  
12.  * 功能：搬运  
13.  */  
14. class Man  
15. {  
16.     int num ; //成员  
17.     String sex;//成员  
18.     void function()//成员  
19.     {  
20.         System.out.println(num+" .... "+sex);  
21.     }  
22.     /*public static void main(String[] args)  
23.     {  
24.         //Man这个类只是描述某一事物，当要用到它时，才运行，并不需要其独立运行，当然也可以  
25.         //所以，要用到这个事物时，只需要在一个类中，进行其对象的创建并调用即可  
26.     }*/  
27. }  
28. /*描述汽车  
29.  * 属性：数量、颜色  
30.  * 功能，启动  
31.  */  
32. class Car  
33. {  
34.     int num = 3;  
35.     String color = "blue";  
36.     void run()  
37.     {  
38.         System.out.println(num+" ... "+color);  
39.     }  
40.       
41. }  
42. public class Main   
43. {  
44.     public static void main(String[] args)  
45.     {  
46.         /*完成对象的创建，并定义该对象的名称*/  
47.         //创建一个Man的实体，通过new关键字实现  
48.         Man BLF1 = new Man();//定义一个Man类型的变量BLF2，Man是类，BLF2是变量名  
49.         //用类来定义的变量，就是一个 类 类型的变量，指向了该类的对象  
50.           
51.         BLF1.function();//使用对象中的内容，形式：对象.成员，来完成调用     
52.           
53.         Car BLF2 = new Car();  
54.         BLF2.run();//对象.组成部分  
55.     }  
56. }  

趁热打铁：

[html]  view plain copy

1. class Man  
2. {  
3.     int num ; //成员  
4.     String sex;//成员  
5.     void function()//成员  
6.     {  
7.         System.out.println(num+" .... "+sex);  
8.     }  
9.   
10. }  
11.   
12. //堆中储存的是对象  
13. public class Main   
14. {  
15.     public static void main(String[] args)  
16.     {  
17.         Man BLF = new Man();  
18.         Man BLF2 = BLF;  
19.         //Man BLF2 = new Man();  
20.         // BLF2 = BLF;  
21.         BLF.num = 4;  
22.         BLF2.sex = "man";  
23.         System.out.println(Integer.toBinaryString(BLF.num));  
24.         BLF.function();  
25.         /*  
26.          * 100  
27.          *  4 .... man  
28.          */  
29.         //PS:一旦产生对象，那么这个对象一定具备着这个类中所描述的内容  
30.     }  
31.       
32. }  

[html]  view plain copy

1. /**  
2.  * 成员变量和局部变量的区别  
3.  *1. 局部变量定义在函数、语句、代码块中，并且只在所属区域中有效  
4.  * 成员变量定义在类中，且整个类中都可以访问  
5.  * 2.成员变量存在于堆内存的对象中  
6.  * 局部变量存在栈内存的方法中  
7.  * 3.成员变量随着对象的创建而存在，随着对象的消失而消失  
8.  * 局部变量随着所属区域的执行而存在，随着所属区域的结束而释放  
9.  * 4.成员变量都有默认初始化值，局部变量没有初始化值  
10.  */  

类 类型参数：

[html]  view plain copy

1. class Man  
2. {  
3.     int num = 4; //成员  
4.     String sex;//成员  
5.     void function()//成员  
6.     {  
7.           
8.         System.out.println(num+" .... "+sex);  
9.     }  
10.   
11. }  
12. public class Main   
13. {  
14.     public static void main(String[] args)  
15.     {  
16.         /*Man a = new Man();  
17.         a.num = 4;  
18.         a.sex = "man";  
19.         Man b = new Man();  
20.         b.num = 4;  
21.         b.sex = "man";*///代码冗杂,进行调用  
22.         Man a = new Man();  
23.         Man b = new Man();  
24.         show(a);  
25.         show(b);  
26.         a.function();  
27.         b.function();  
28.         /*  
29.          * 4 .... man  
30.          * 4 .... man  
31.          */  
32.     }  
33.     public static void show(Man b) //类类型的变量一定指向对象，否则就是null  
34.     {  
35.         b.num = 4;  
36.         b.sex = "man";  
37.     }  
38.       
39. }  

了解：匿名对象


栈内存存储的是局部变量，所以匿名变量储存在堆中

[html]  view plain copy

1. class Car  
2. {  
3.     int num ;//成员  
4.     String color;//成员  
5.     void function()//成员  
6.     {  
7.           
8.         System.out.println(num+" .... "+color);  
9.     }  
10.   
11. }  
12. public class Main   
13. {  
14.     public static void main(String[] args)  
15.     {  
16.         /*  
17.          * 匿名对象  
18.          * new Man();  
19.          * 也就是定义对象时的简写格式  
20.          * */  
21.         new Car();  
22.           
23.         //使用方法一：当对象对方法仅进行一次调用，即可简化为匿名对象  
24.         /*  
25.          * new Car().num = 4;  
26.          * new Car().color = "man";  
27.          * new Car().function;  
28.          * 打印结果：0....null  
29.          * 理由如下图：  
30.          * new Car().num = 4;执行完后，自动变成堆中的垃圾  
31.          * */  
32.         //使用方法二：匿名对象可以做实际参数进行传递  
33.         show(new Car());  
34.     }  
35.     public static void show(Car a)  
36.     {  
37.         a.num = 4;  
38.         a.color = "MAN";  
39.         a.function();  
40.     }  
41.   
42. }  

数据类型参数传递问题：

[html]  view plain copy

1. //基本数据类型参数传递  
2. public class Main  
3. {  
4.     public static void main(String[] args)  
5.     {  
6.         int x = 3;  
7.         show(x);  
8.         System.out.println(x);  
9.     }  
10.     public  static void show(int x)   
11.     {  
12.         x = 9;  
13.         //return ;  
14.     }  
15. }  
16. //打印 3  
17. 改变的只是show中x的值，执行完后弹栈，释放，但是本来的x的值并为改变。  

[html]  view plain copy

1. /引用数据类型参数传递  
2. public class Main   
3. {  
4.     int  x = 3;  
5.     public static void main(String[] args)  
6.     {  
7.         Main d = new Main();  
8.         d.x = 9;  
9.         show(d);  
10.         System.out.println(d.x);  
11.     }  
12.     public  static void  show(Main b)   
13.     {  
14.         b.x = 1;  
15.     }  
16. }  
17. //打印 1 ，栈 和 堆  
18. //执行如图  

图示：很清晰，引用数据类型变量，在栈和堆中执行，栈中show也引用了类d的地址，所以可以改变其中x的值

转载自：http://blog.csdn.net/wjw0130/article/details/39127777