java的三大特性，封装，继承，多态

封装

1. /**
2. * 所谓封装，就是将对象具有的成员变量和成员函数包装和隐藏起来，让外界无法直接使用，
3. * 被封装的成员只能通过某些特定的方式才能访问。
4. * 实现封装有两个步骤：
5. *   1、将不能暴露的成员隐藏起来，我们就不能让其在类的外部被直接访问或赋值。
6. *      实现方法是将该成员定义为私有的，在成员定义前加上private访问权限修饰符。
7. *   2、用公共方法来暴露对该隐藏成员的访问，可以给成员加上public修饰符，将该成员定义为公共的
8. */
9. package com.study.feature;
10. /**
11. *
12. * @className ：Package
13. * @package : com.study.feature
14. * @Description ：封装性的测试
15. * @author：lgf
16. * @date ：2012 三月 12  10:20:35
17. * @version : 1.0
18. */
19. public class Package {
20. // 使用private隐藏
21. private String strValue;
22. // 通过get和set进行访问
23. public String getStrValue() {
24. return this.strValue;
25. }
26. public void setStrValue(String strValue) {
27. this.strValue = strValue;
28. }
29. }

继承 
父类 ExtendsFather.java

1. /**
2. * 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
3. * 对象的一个新类可以从现有的类中派生。
4. * 1. 为什么要使用继承？
5. *  a.提高程序的扩展性。
6. b.提高了代码的重用性。
7. 2. 子类能继承到父类的那些方法和属性
8. 第一种：所有的属性和方法都被子类继承到了。
9. 第二种：
10. a、子类和父类在同一个包下：
11. 公有的受保护的属性和方法被子类继承到了。
12. b、子类和父类不在同一个包下：
13. 公有的方法和属性被子类继承到了。
14. 3. 子类的对象能调用父类的那些方法和属性？
15. a、子类和父类在同一个包下：
16. 公有的受保护的属性和方法能被子类调用。
17. b、子类和父类不在同一个包下：
18. 公有的方法和属性能被子类调用。
19. 在类和抽象类中，默认的就是受保护的。
20. 在接口中，默认的就是公有的。
21. */
22. package com.study.feature;
23. /**
24. * 父类
25. * @className ：ExtendsFather
26. * @package : com.study.feature
27. * @Description ：继承测试
28. * @author：lgf
29. * @date ：2012 三月 12  10:33:02
30. * @version : 1.0
31. */
32. public class ExtendsFather {
33. // 定义不同四种修饰符的属性
34. private     String privateValue;
35. protected   String protectedValue;
36. String defaultValue;
37. public      String publicValue;
38. // 定义不同四种修饰符的方法
39. private void privateFunction(){
40. System.out.println("privateFunction");
41. }
42. protected void protectedFunction(){
43. System.out.println("protectedFunction");
44. }
45. void defaultFunction(){
46. System.out.println("defaultFunction");
47. }
48. public void publicFunction(){
49. System.out.println("publicFunction");
50. }
51. }

同包下的子类 ExtendsChildrenSamePackage.java

1. package com.study.feature;
2. /**
3. *
4. *
5. * @className ：ExtendsChildrenSamePackage
6. * @package : com.study.feature
7. * @Description ： 同一个包下面的继承关系
8. * @author：lgf
9. * @date ：2012 三月 12  10:51:23
10. * @version : 1.0
11. */
12. public class ExtendsChildrenSamePackage extends ExtendsFather{
13. public static void main(String[] args) {
14. ExtendsFather children = new ExtendsChildrenSamePackage();
15. //children.privateValue = "no"; 无法访问到
16. children.defaultValue = "ok";
17. children.protectedValue = "ok";
18. children.publicValue = "ok";
19. //除了private修饰的方法,其他都继承到了
20. //children.privateFunction();
21. children.defaultFunction();
22. children.protectedFunction();
23. children.publicFunction();
24. }
25. }

不同包下的子类 ExtendsChildrenOtherPackage.java

1. /**
2. *
3. */
4. package com.study.featureSecond;
5. import com.study.feature.ExtendsFather;
6. /**
7. *
8. * @className ：ExtendsChildrenOtherPackage
9. * @package : com.study.featureSecond
10. * @Description ：不同包下面的继承关系
11. * @author：lgf
12. * @date ：2012 三月 12  10:50:47
13. * @version : 1.0
14. */
15. public class ExtendsChildrenOtherPackage extends ExtendsFather{
16. public static void main(String[] args) {
17. ExtendsFather children = new ExtendsChildrenOtherPackage();
18. //children.privateValue = "no"; 无法访问到
19. //children.defaultValue = "no"; 无法访问到
20. //children.protectedValue = "no"; 无法访问到
21. children.publicValue= "ok";
22. //除了public修饰的方法,其他都未继承到了
23. //children.privateFunction();
24. //children.defaultFunction();
25. //children.protectedFunction();
26. children.publicFunction();
27. }
28. }

重载和重写 ExtendsOverRideLoad.java

1. /**
2. *
3. */
4. package com.study.feature;
5. /**
6. *
7. * @className ：ExtendsClass
8. * @package : com.study.feature
9. * @Description ：重载和重写
10. * @author：lgf
11. * @date ：2012 三月 12  11:00:35
12. * @version : 1.0
13. */
14. public class ExtendsOverRideLoad extends ExtendsFather {
15. @Override
16. public void publicFunction() {
17. //super.publicFunction(); 可以调用父类的方法
18. System.out.println("Override publicFunction");
19. }
20. public void publicFunction(String str) {
21. //super.publicFunction(); 可以调用父类的方法
22. System.out.println("overload publicFunction");
23. }
24. public static void main(String[] args) {
25. ExtendsFather child= new ExtendsOverRideLoad();
26. //Override publicFunction
27. child.publicFunction();
28. //child.publicFunction("s");  仅仅只能使用到父类有的方法,重载的方法无法调用
29. ExtendsOverRideLoad childSecond = new ExtendsOverRideLoad();
30. //Override publicFunction
31. childSecond.publicFunction();
32. //overload publicFunction
33. childSecond.publicFunction("overLoad");
34. }
35. }

多态

父类  Animal.java

1. /**
2. * 1. Java中除了static和final方法外，其他所有的方法都是运行时绑定的
3. * 2. 构造方法是被隐式声明为static方法
4. * 3. 动态绑定
5. *  将一个方法调用和一个方法主体连接到一起称为绑定（Binding）。
6. *  根据绑定的时机不同，可将绑定分为“早期绑定”和“后期绑定”两种。
7. *  如果在程序运行之前进行绑定（由编译器和链接程序完成），称为早期绑定。
8. *  如果在程序运行期间进行绑定，称为后期绑定，后期绑定也称为“动态绑定”或“运行时绑定”。
9. *  在Java中，多态性是依靠动态绑定实现的，即Java虚拟机在运行时确定要调用哪一个同名方法。
10. *
11. *  4. 多态总结
12. *      一、使用父类类型的引用指向子类的对象
13. *      二、该引用只能调用父类中定义的方法和变量
14. *      三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，
15. *          将会调用子类中的这个方法；（动态连接、动态调用）
16. *      四、变量不能被重写（覆盖），”重写“的概念只针对方法，
17. *          如果在子类中”重写“了父类中的变量，那么在编译时会报错。
18. *  5. 多态详解 多态是通过:
19. *      5.1 接口 和 实现接口并覆盖接口中同一方法的几不同的类体现的
20. *      2 父类 和 继承父类并覆盖父类中同一方法的几个不同子类实现的.
21. *
22. *  6. 一个类型引用只能引用引用类型自身含有的方法和变量
23. */
24. package com.study.feature;
25. /**
26. * @className ：Animal
27. * @package : com.study.feature
28. * @Description ：多态的测试
29. * @author：lgf
30. * @date ：2012 三月 12  13:50:36
31. * @version : 1.0
32. */
33. public class Animal {
34. public void eat(){
35. System.out.println("eating");
36. }
37. }

多态实现

1. /**
2. *
3. */
4. package com.study.feature;
5. /**
6. *
7. * @className ：Cat
8. * @package : com.study.feature
9. * @Description ：猫
10. * @author：lgf
11. * @date ：2012 三月 12  13:54:01
12. * @version : 1.0
13. */
14. public class Cat extends Animal{
15. public void eat(){
16. System.out.println("eating fish");
17. }
18. }

1. /**
2. *
3. */
4. package com.study.feature;
5. /**
6. *
7. * @className ：Dog
8. * @package : com.study.feature
9. * @Description ：狗
10. * @author：lgf
11. * @date ：2012 三月 12  13:55:38
12. * @version : 1.0
13. */
14. public class Dog extends Animal{
15. public void eat(){
16. System.out.println("eating Bone");
17. }
18. }

结果

1. /**
2. *
3. */
4. package com.study.feature;
5. /**
6. *
7. * @className ：Main
8. * @package : com.study.feature
9. * @Description ：多态测试
10. * @author：lgf
11. * @date ：2012 三月 12  13:57:11
12. * @version : 1.0
13. */
14. public class Main {
15. public static void main(String[] args) {
16. Animal animal = null;
17. animal = new Animal();
18. animal.eat();//eating
19. Animal cat = new Cat();
20. cat.eat();//eating fish
21. Animal dog = new Dog();
22. dog.eat();//eating Bone
23. }
24. }

例子2

1. /**
2. *
3. */
4. package com.study.feature;
5. /**
6. *
7. * @className ：Father
8. * @package : com.study.feature
9. * @Description ：多态
10. * @author：lgf
11. * @date ：2012 三月 12  14:53:41
12. * @version : 1.0
13. */
14. public class Father {
15. public void functionOne(){
16. functionSecond();
17. }
18. public void functionSecond(){
19. System.out.println("Father functionSecond");
20. }
21. }

1. /**
2. *
3. */
4. package com.study.feature;
5. /**
6. *
7. * @className ：Children
8. * @package : com.study.feature
9. * @Description ：测试
10. * @author：lgf
11. * @date ：2012 三月 12  14:55:15
12. * @version : 1.0
13. */
14. public class Children extends Father{
15. public void functionSecond(){
16. System.out.println("Children functionSecond");
17. }
18. public static void main(String[] args) {
19. Father c = new Children();
20. c.functionOne();//Children functionSecond
21. }
22. }