封装就是把不想让人看到或用到的东西隐藏起来；具体做法是把属性私有化，并提供公有的方法访问这些属性。那么封装的破坏该怎么理解，有没有具体的例子

1. public class Demo {
   
2.         public class TestBean {
   
3.                 private String name; // 姓名
   
4.                 private String sex; // 性别
   
5.                 private int age; // 年龄
   
6.                 private String job; // 工作
   
7. 
   
8.                 // 以后只要是设置值的时候 实例化这个类
   
9.                 // 比如设置年龄 那么调用setAge(String age)；方法
   
10.                 // 传入年龄值 注意前面是什麽类型 这里为int
    
11.                 // TestBean test=new TestBean();
    
12.                 // String name="张三";
    
13.                 // test.setName(name);
    
14.                 // 设置值后 很复杂的多个属性 便变成了一个简单的JavaBean对象
    
15.                 // 取值也很简单 前提是你已经设置了多项属性的值
    
16.                 // 比如调用年龄 getAge()就可以拿到年龄的值
    
17.                 // 对应其类型 可以这样调用
    
18.                 // TestBean test=new TestBean();
    
19.                 // String name=test.getName();
    
20.                 // 使用JavaBean的好处有 实现MVC结构
    
21.                 // 封装多个属性或对象为一个对象 私有的属性 而共有的方法 大大提高程序安全性
    
22.                 // 。。。等等
    
23.                 public int getAge() {
    
24.                         return age;
    
25.                 }
    
26. 
    
27.                 public String getJob() {
    
28.                         return job;
    
29.                 }
    
30. 
    
31.                 public String getName() {
    
32.                         return name;
    
33.                 }
    
34. 
    
35.                 public String getSex() {
    
36.                         return sex;
    
37.                 }
    
38. 
    
39.                 public void setAge(int age) {
    
40.                         this.age = age;
    
41.                 }
    
42. 
    
43.                 public void setJob(String job) {
    
44.                         this.job = job;
    
45.                 }
    
46. 
    
47.                 public void setSex(String sex) {
    
48.                         this.sex = sex;
    
49.                 }
    
50. 
    
51.                 public void setName(String name) {
    
52.                         this.name = name;
    
53.                 }
    
54.         }
    
55. }
    

复制代码

按毕老师视频里说的，面向对象的另外一个特性 ：继承，
继承打破了 封装，因为子类继承父类，子类可以覆盖父类的相同方法，
所以从某种意义上讲 继承打破了封装，
此时就引出关键字 final ，如果一个类 或者一个方法不想被继承或者 覆盖，可以用 final修饰

继承破坏了封装：
子类继承父类，复习父类，并且可以覆盖父类相同的方法
比如：
        class Fu
        {
             void eat()
              {
                 System.out.println("吃饭");
              }
        }
        class Zi extends Fu//子类继承了父类
        {
              void eat()
              {
                 System.out.println("吃面");//此时子类复习了父类的功能，并将自己新的方法覆盖了父类原有的方法
              }
        }
当然，楼主不必担心说父类被覆盖了，父类还有什么用，后面会有讲到   final：最终     它的出现就是用来防止子类覆盖父类的，如果你需要说子类方法和父类一样，那么你就可以用final将父类最终化，子类便只能使用，而不能覆盖父类的功能。

何建明 发表于 2014-3-11 11:22
按毕老师视频里说的，面向对象的另外一个特性 ：继承，
继承打破了 封装，因为子类继承父类，子类可以覆盖 ...

原来是这样，正好看到继承那，还没看到final