黑马程序员_java 面向对象的理解

-------  android培训 、 java培训 、期待与您交流！ ----------

1.1理解面向对象

面向对象是相对面向过程而言

面向对象和面向过程都是一种思想

面向过程：强调的是功能行为

面向对象：将功能封装进对象，强调具备了功能的对象面向对象是基于面向过程的

[java]  view plain copy

1. class    
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         System.out.println("Hello World!");  
6.     }  
7. }  
8.   
9. /* 
10. 人开门：名词提炼法。 
11. 人 
12. { 
13.     开门（门） 
14.     { 
15.         门.开(); 
16.     } 
17. } 
18.  
19. 门 
20. { 
21.     开(){操作门轴等。} 
22. } 
23.  
24. */  

1.2面向对象的特点

三个特点：封装，继承，多态

以后开发其实就是找对象使用，没有对象，就创建对象找对象，建立对象，使用对象，维护对象的关系

2.类与对象的关系

现实生活中的对象：张三，李四

想要描述，想要描述对象中共性的内容，对具体的抽象

描述时：这些对象的共性有：姓名，年龄,性别，学习java功能

映射到java中，描述就是class定义的类，具体对象就是对应java在堆内存中庸new建立实体

类： 就是对现实生活事物的描述

对象：就是这类事物，实实在在存在的个体 

匿名对象是对象的简化形式

匿名对象两种使用情况：当对对象方法仅进行一次调用时，匿名对象可以作为实际参数进行传递

[java]  view plain copy

1. class Car  
2. {  
3.     //描述颜色  
4.     String color = "红色";  
5.     //描述轮胎数  
6.     int num = 4;  
7.   
8.     //运行行为。  
9.     void run()  
10.     {  
11.   
12.         System.out.println(color+".."+num);  
13.     }  
14.       
15. }  
16.   
17.   
18. class  CarDemo  
19. {  
20.     public static void main(String[] args)   
21.     {  
22.         //生产汽车。在java中通过new操作符来完成。  
23.         //其实就是在堆内存产生一个实体。  
24.         //Car c = new Car();//c就是一个类类型变量。记住：类类型变量指向对象。  
25.   
26.         //需求：将已有车的颜色改成蓝色。指挥该对象做使用。在java指挥方式是：对象.对象成员  
27.         //c.color = "blue";  
28.           
29.         //c.run();  
30.   
31.         //Car c1 = new Car();  
32.         //c1.run();//red 4;  
33.   
34.   
35. //      Car c = new Car();  
36. //      c.num = 5;  
37.         /* 
38.         new Car().num = 5; 
39.         new Car().color = "blue"; 
40.         new Car().run(); 
41.  
42.         Car c = new Car(); 
43.         c.run(); 
44.         c.num = 4; 
45.         new Car().run(); 
46.         */  
47.         //匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。  
48.         //如果对一个对象进行多个成员调用，必须给这个对象起个名字。  
49.         //匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。  
50.   
51.   
52.         Car q = new Car();  
53.         show(q);  
54.   
55.         //show(new Car());  
56.     }  
57.   
58.     //需求：汽车修配厂。对汽车进行改装，将来的车够改成黑车，三个轮胎。  
59.     public static void show(Car c)  
60.     {  
61.         c.num = 3;  
62.         c.color = "black";  
63.         c.run();  
64.     }  
65. }  

3.封装

封装：是指隐藏对象的属性和实现细节，仅对象提供公共访问方式

好处：将变化隔离，便于使用，提高重用性，提高安全性

封装规则：将不需要对外提供的内容都隐藏起来把属性都隐藏，提供公共方法对其访问

[java]  view plain copy

1. /* 
2. private :私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。 
3. 私有只在本类中有效。 
4.  
5. 将age私有化以后，类以外即使建立了对象也不能直接访问。 
6. 但是人应该有年龄，就需要在Person类中提供对应访问age的方式。 
7.  
8. 注意：私有仅仅是封装的一种表现形式。 
9.  
10.  
11. 之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。 
12. 对访问的数据进行操作。提高代码健壮性。 
13.  
14. */  
15.   
16. class Person  
17. {  
18.     private int age;  
19.     public void setAge(int a)  
20.     {  
21.         if(a>0 && a<130)  
22.         {  
23.             age = a;  
24.             speak();  
25.         }  
26.         else  
27.             System.out.println("feifa age");  
28.     }  
29.   
30.     public int getAge()  
31.     {  
32.         return age;  
33.     }  
34.     private void speak()  
35.     {  
36.         System.out.println("age="+age);  
37.     }  
38. }  
39.   
40. class PersonDemo  
41. {  
42.     public static void  main(String[] args)  
43.     {  
44.         Person p = new Person();  
45.   
46.         //p.age = -20;  
47.         p.setAge(-40);  
48.         //p.speak();  
49.     }  
50. }