Java中封装、继承、多态

1. Java中封装 

Java代码  

1. 封装：就是隐藏对象的属性和实现细节，仅对外提供公共访问方式。  
2.   
3. 隐藏类的实现细节，让使用者只能通过程序员规定的方法来访问数据，可以方便的加入存取控制语句，限制不合理操作。  
4.   
5. 1. 数据封装：保护数据成员，不让类以外的程序直接访问或修改，只能通过提供的公共的接口访问。  
6.   
7. 2. 方法封装：方法的细节对用户是隐藏的，只要接口不变，内容的修改不会影响到外部的调用者。  
8.   
9. public class Test {  
10.     public int add(int a, int b){  
11.         return a + b;  
12.     }  
13.     public void output(){  
14.         System.out.println("Hello World");  
15.     }  
16.     public void method(int a){  
17.         if(a < 10){  
18.             return;  
19.         }  
20.         System.out.println("Welcome!!");  
21.     }  
22.     public static void main(String[] args){  
23.         Test test = new Test();  
24.         int x = 8;  
25.         int y = 3;  
26.         int a = test.add(x, y);  
27.         System.out.println(a);  
28.           
29.         test.output();  
30.         int m = 15;  
31.         test.method(m);  
32.     }  
33. }  
34. 11  
35. Welcome!!  

2. Java中继承 

Java代码  

1. 继承：继承是从已有的类中派生出新的类称为子类，子类继承父类的数据属性和行为，并能根据自己的需求扩展出新的行为。  
2.   
3. 通过extends关键字来实现，是实现代码重用的重要手段之一。Java是单继承，每个类只能有一个父类。所有类都是Object类的子类。  
4.   
5. 继承总结：  
6. a) 父类有的，子类也有  
7. b) 父类没有的，子类可以增加  
8. c) 父类有的，子类可以改变  
9.   
10. 1. 属性  
11.     父类有，子类没有（父类调用父类的属性，子类调用父类的属性）  
12.     父类有，子类有（父类调用父类的属性，子类调用子类的属性）  
13.     父类没有，子类有（父类无法调用属性，子类调用子类的属性）  
14.     父类没有，子类没有（父类无法调用属性，子类无法调用属性）  
15. (1) 父类有属性就用父类属性，没有就无法调用属性。  
16. (2) 子类有属性就用子类属性，子类没有属性父类有就用父类的，子类没有属性父类也没有属性就无法调用属性。  
17.   
18. 2.方法  
19. 1) 构造方法(空)  
20.     父类有，子类没有（父类调用父类的构造方法，子类调用父类的构造方法、子类默认的构造方法）  
21.     父类有，子类有（父类调用父类的构造方法，子类调用父类、子类的构造方法）  
22.     父类没有，子类有（父类调用父类默认的构造方法，子类调用父类默认的构造方法、子类的构造方法）  
23.     父类没有，子类没有（父类调用父类默认的构造方法，子类调用父类默认的构造方法、子类默认的构造方法）  
24. (1) 父类有构造方法就用父类的构造方法，没有就使用父类默认的构造方法。  
25. (2) 父类有构造方法就用父类的构造方法，没有就使用父类默认的构造方法。子类有构造方法就用子类的构造方法，没有就使用子类默认的构造方法。  
26. 注意：这种情况是在没有其他构造方法的情况下。  
27. 2) 构造方法(非空)  
28. 3) 一般方法  
29.     父类有，子类没有（父类调用父类的一般方法，子类调用父类的一般方法）  
30.     父类有，子类有（父类调用父类的一般方法，子类调用子类的一般方法）  
31.     父类没有，子类有（父类无法调用一般方法，子类调用子类的一般方法）  
32.     父类没有，子类没有（父类无法调用一般方法，子类无法调用一般方法）  
33. (1) 父类有属性就用父类一般方法，没有就无法调用一般方法。  
34. (2) 子类有属性就用子类一般方法，子类没有属性父类有就用父类的，子类没有一般方法父类也没有一般方法就无法调用一般方法。  
35.   
36. public class InheritenceTest {  
37.     public static void main(String[] args){  
38.         Dog dog = new Dog();  
39.         dog.run();  
40.     }     
41. }  
42. class Animal{  
43.     public void run(){  
44.         System.out.println("animal is running");  
45.     }  
46. }  
47. class Dog extends Animal{  
48.     public void run(){  
49.         System.out.println("dog is running");  
50.         super.run();  
51.     }  
52. }  
53. dog is running  
54. animal is running  

3. Java中多态 

Java代码  

1. 多态：指允许不同的对象对同一消息做出相应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。  
2.   
3. “一个接口，多种方法”，同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。重载(overload)和重写(override)是实现多态的两种主要方式。  
4.   
5. 多态的三个条件：  
6. a) 继承的存在(继承是多态的基础,没有继承就没有多态)  
7. b) 子类重写父类的方法(多态下调用子类重写的方法)  
8. c) 父类引用变量指向子类对象(子类到父类的类型转换)  
9.   
10. 实现多态：  
11. a) 接口多态性  
12. b) 继承多态性  
13. c) 通过抽象类实现的多态性  
14.   
15. public class PolyTest {  
16.     public void run(Car car){  
17.         car.run();  
18.     }  
19.     public static void main(String[] args){  
20.         PolyTest test = new PolyTest();  
21.         Car car = new BMW();  
22.         test.run(car);  
23.         QQ qq = new QQ();  
24.         test.run(qq);  
25.     }  
26. }  
27. class Car{  
28.     public void run(){  
29.         System.out.println("car is running");  
30.     }  
31. }  
32. class BMW extends Car{  
33.     public void run(){  
34.         System.out.println("BMW is running");  
35.     }  
36. }  
37. class QQ extends Car{  
38.     public void run(){  
39.         System.out.println("QQ is running");  
40.     }  
41. }  
42. BMW is running  
43. QQ is running  

Java面向对象的三个特性：封装、继承、多态。(如果说四种就加一种：抽象)

 

 

本文转自：http://andrew7676.iteye.com/blog/2430523