疯狂JAVA讲义---第五章（中）面向对象

接着上次讲面向对象，这次先讲隐藏和封装，看了李刚的这本书我才知道，原来访问控制符共分四个级别，我一直以为先c+样只有private,protected,public原来还有default这种基于private和protected之间，和private的区别就是default支持同一个包间的访问。看到default大家不要以为是什么关键字，其实就是private,protected,public一个都不写，我一直以为不写就是private这下长见识了。然后给了个良好封装的例子eg

1. public class Person
2. {
3.     private String name;
4.     private int age;
6.     public Person()
7.     {
8.     }
10.     public Person(String name , int age)
11.     {
12.         this.name = name;
13.         this.age = age;
14.     }
16.     public void setName(String name)
17.     {
18.         //执行合理性校验，要求用户名必须在2～6位之间
19.         if (name.length() > 6 || name.length() < 2)
20.         {
21.             System.out.println("您设置的人名不符合要求");
22.             return;
23.         }
24.         else
25.         {
26.             this.name = name;
27.         }
28.     }
29.     public String getName()
30.     {
31.          return this.name;
32.     }
34.     public void setAge(int age)
35.     {
36.         //执行合理性校验，要求用户年龄必须在0～100之间
37.         if (age > 100 || age < 0)
38.         {
39.             System.out.println("您设置的年龄不合法");
40.             return;
41.         }
42.         else
43.         {
44.             this.age = age;
45.         }
46.     }
47.     public int getAge()
48.     {
49.          return this.age;
50.     }
51. }

 

也就是符合javabean的类。

然后讲了包的概念，这个用IDE的花就不需要花太多时间关心，然后讲了个jdk1.5后的一个新用法 import static用于引入类的静态属性eg

1. public class TestStaticImport
2. {
3.     public static void main(String[] args) 
4.     {
5.         //out是java.lang.System类的静态属性，代表标准输出
6.         //PI是java.lang.Math类的静态属性，表示常量
7.         out.println(PI);
8.     }
9. }

接下来到了面向对象的重点：继承，多态。这里所讲的东西和我以前总结的差不多，明天我将整理好贴出来。

但书中也讲了个不错的多态的例子，eg

1. class BaseClass
2. {
3.     public int book = 6;
4.     public void base()
5.     {
6.         System.out.println("父类的普通方法");
7.     }
8.     public void test()
9.     {
10.         System.out.println("父类的被覆盖的方法");
11.     }
12. }
13. public class SubClass extends BaseClass
14. {
15.     //重新定义一个book实例属性覆盖父类的book实例属性
16.     public String book = "轻量级J2EE企业应用实战";
17.     public void test()
18.     {
19.         System.out.println("子类的覆盖父类的方法");
20.     }
21.     public void sub()
22.     {
23.         System.out.println("子类的普通方法");
24.     }
25.     public static void main(String[] args)
26.     {
27.         //下面编译时类型和运行时类型完全一样，因此不存在多态
28.         BaseClass bc = new BaseClass();
29.         //输出 6
30.         System.out.println(bc.book);
31.         //下面两次调用将执行BaseClass的方法
32.         bc.base();
33.         bc.test();
35.         //下面编译时类型和运行时类型完全一样，因此不存在多态
36.         SubClass sc = new SubClass();
37.         //输出"轻量级J2EE企业应用实战"
38.         System.out.println(sc.book);
39.         //下面调用将执行从父类继承到的base方法
40.         sc.base();
41.         //下面调用将执行从当前类的test方法
42.         sc.test();
43.         //下面调用将执行从当前类的sub方法
44.         sc.sub();
46.         //下面编译时类型和运行时类型不一样，多态发生
47.         BaseClass ploymophicBc = new SubClass();
48.         //输出 6 —— 表明访问的是父类属性
49.         System.out.println(ploymophicBc.book);
50.         //下面调用将执行从父类继承到的base方法
51.         ploymophicBc.base();
52.         //下面调用将执行从当前类的test方法
53.         ploymophicBc.test();
54.         //因为ploymophicBc的编译类型是BaseClass，BaseClass类没有提供sub方法
55.         //所以下面代码编译时会出现错误。
56.         //ploymophicBc.sub();
57.     }
58. }

记住最重要的一点：子类对象直接赋给父类引用变量时，运行是调用的是子类的方法，父类的属性，属性不具多态性