黑马程序员_面向对象与类的分析

标签：

一、面向对象的概述：

java是一种面向对象的编程语言，也就是说对象是这种语言的基础，没有对象了，就没有了java。任何功能都是通过对象来实现的，就是将功能封装进对 象，让对象去调用这些功能。这种思想是将数据作为第一位，而方法（功能或者说是算法）作为其次。我个人认为，这是对数据的一种优化，安全性更高，操作起数据来一更方便。

那么将这种思想提升到一种境界就是：万物皆对象。

1、对面向对象的理解：

1）面向对象是相对面向过程而言的，且基于面向过程的。

2）面向对象是一种思想。

3）面向对象将功能封装进对象中，强调了具备功能的对象，主体是对象，将过程简化

4）在实际开发中，以对象为核心，先明确好对象，在实现具体功能，或者可是使用已有的对象。

5）面向对象的三个特征：封装性，继承性，多态性。

二、类与对象概述

1、类（class）：可以理解为是构造对象的一个蓝图或者模板，是抽象的概念；反过来说，对象是以类为模型创造的具体实例，是对类的一种具体化、形象化。

类：对生活中事物的描述

对象：对类的具体实现，是实实在在存在的实体。

类就是对象的描述。
对象就是存在的可以被操作的实体。


需求：描述一个汽车。
描述两方面：属性，行为。
属性：轮胎数。颜色。
行为：运行。

其实类中定义的都是成员：
成员变量-----属性。
成员函数-----行为。

[java] view plaincopy

 

1. class Car  
2. {  
3.     //1,描述属性。  
4.     int num;  
5.     String color;  
6.     void run()  
7.     {  
8.         System.out.println(num+"::"+color);  
9.     }  
10.   
11. }  
12.   
13. //描述实物的目的就是为了创建实体。  
14.   
15. class CarDemo   
16. {  
17.     public static void main(String[] args)   
18.     {  
19.         //创建Car的实体对象。  
20.         new Car();  
21.     }  
22. }   

2.匿名对象

[java] view plaincopy

 

1. class CarDemo   
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         //创建对象。  
6.         Car c = new Car();  
7. //        c.num= 4;  
8. //        c.color = "red";  
9. //        c.run();  
10.   
11.         Car c1 = new Car();  
12. //        c1.num = 4;  
13. //        c1.color = "red";  
14. //        c1.run();  
15.           
16.         show(c);  
17.         show(c1);  
18.   
19.   
20.   
21.         /* 
22.         匿名对象。 
23.  
24.         Car c = new Car(); 
25.         c.run(); 
26.          
27.  
28.         简化成： 
29.         new Car().run(); 
30.         创建对象只为调用一次方法，可以使用匿名对象完成。 
31.         匿名对象可以作为实参传递。 
32.  
33.  
34.         Car c = new Car(); 
35.         c.num = 4; 
36.         c.color = "red"; 
37.         c.run(); 
38.  
39.         new Car().num = 5; 
40.         new Car().color = "blue"; 
41.         new Car().run(); 
42.          
43.         */  
44.         show(new Car());  
45.     }  
46.   
47.     public static void show(Car c)  
48.     {  
49.         c.num = 3;  
50.         c.color = "black";  
51.         c.run();  
52.     }  

3.面向对象-成员变量和局部变量的区别

[java] view plaincopy

 

1. /* 
2. 1,源代码的位置： 
3. 成员变量定义在类中,该变量在整个类访问有效。 
4. 局部变量定义在方法中,该变量只在方法内有效。 
5.  
6. 2，内存中的位置： 
7. 成员变量在堆内存的对象中存储。成员变量所属于对象。 
8. 局部变量在栈内存的方法中存储。局部变量所属于方法。 
9.  
10. 3，初始化。 
11. 成员变量都有默认的初始化。根据类型不同初始化值不同。 
12. 局部变量没有默认初始化。使用时，必须初始化才可以用。 
13. */  

4.面向对象-封装和私有化及封装的好处

[java] view plaincopy

 

1. /* 
2. 封装：隐藏实现细节，对外提供公共的访问方式。 
3.  
4. 1，安全性。 
5. 2，复用性。 
6. 3，隔离的变化。后期应用于分层设计。 
7.  
8.  
9.  
10. */  
11. /* 
12. 描述人： 
13. 属性：姓名，年龄。 
14. 行为：说话。 
15. */  
16.   
17. class Person  
18. {  
19.     private String name;  
20.     private/*私有*/ int age;  
21.     /* 
22.     将成员变量私有化，对外提供set get方法，对其访问的原因就是可以属性可控。 
23.  
24.     私有关键字private 是一个权限修饰符，只能修饰成员(成员变量，成员函数)。 
25.  
26.  
27.     注意：私有仅仅是封装的表现形式之一！ 
28.  
29.     */  
30.   
31.     public void setName(String s)  
32.     {  
33.         name = s;  
34.     }  
35.     public String getName()  
36.     {  
37.         return name;  
38.     }  
39.   
40.     public void setAge(int a)  
41.     {  
42.   
43.         /*可以加入健壮性的判断。 
44.         if(a<=0 || a>120) 
45.             throw  
46.         */  
47.             age = a;  
48.           
49.     }  
50.     public int getAge()  
51.     {  
52.         return age;  
53.     }  
54.   
55.   
56.     void speak()  
57.     {  
58.         System.out.println(name+":"+age);  
59.     }  
60. }  
61.   
62.   
63. class PersonDemo  
64. {  
65.     public static void main(String[] args)   
66.     {  
67.         Person p = new Person();  
68. //      p.name = "东邪";  
69. //      p.age = -20;  
70.         p.setName("东邪");  
71.         p.setAge(20);  
72.         p.speak();  
73.     }  
74. }  

黑马程序员_面向对象与类的分析

标签：

原文地址：http://www.cnblogs.com/shujin/p/4425630.html