1. public class Two extends One
   
2. {   
   
3.         protected void printA()
   
4.         {
   
5.                 System.out.println("two A");
   
6.         }   
   
7.         private void printB()
   
8.         {
   
9.                 System.out.println("two B");
   
10.         }   
    
11.         public static void main(String[] args)  
    
12.         {
    
13.                 Two t = new Two();
    
14.                 t.printAB();
    
15.         }
    
16. }  

复制代码

1. public class  One
   
2. {  
   
3.         protected void printA()
   
4.         {
   
5.                 System.out.println("OneA");
   
6.         }   
   
7.         private void printB()
   
8.         {
   
9.                 System.out.println("One B");
   
10.         }   
    
11.         protected void printAB()
    
12.         {
    
13.                 printA();
    
14.                 printB();      
    
15.         }
    
16. }

复制代码

对象是Two类型的t，
第一步，Two重写了printA()，printA()打印TwoA,这个没问题。
第二步printB(),这个没有继承父类，本类有一个新方法，为什么却去调用父类的方法？

看看哈，

我是这么理解的，被private修饰的方法都是属于自己类的，不能被继承。
printAB()是父类的方法调用printB()在子类中找不到可以访问的，
子类虽然不能继承父类的私有方法，但是在子类是存有父类的私有方法的，
只是子类永远调用不了，printAB()是父类的也调用不了子类的私有方法，因为你没有重写，
所以printAB()和父类的printB()是在同一个类中，而私有方法可以访问的，所以打印父类的printB()

应该是这样的吧，不对的可以指正。

package com.wenfengkeji.heima;

public class Two extends One
{   
                @Override
        protected void printA()
        {
                System.out.println("two A");
        }   
        @Override  //这里加注解后编译不能通过 这样就很好理解了 说明当子类的方法是私有的父类是无法对其重写的
        public void printB() // 提升子类的方法的访问权限就O了
        {
                System.out.println("two B");
        }   
        public static void main(String[] args)  
        {
                Two t = new Two();
                t.printAB();
        }
}  
class  One
{  
        protected void printA()
        {
                System.out.println("OneA");
        }   
        private void printB()  //改为 public protected 或default就好了
        {
                System.out.println("One B");
        }   
        protected void printAB()
        {
                        printA();
                printB();      
        }
}

子类使用父类的方法，子类是仅仅有权限使用父类的方法，隐式的父类引用指向的是子类对象？
最终还是父类在工作，所以父类因为子类没覆盖，所以调用了自己的private方法？
这样的话有点类似于多态，这样考虑到底对不对？

public static void main(String[] args){
                Two t = new Two();
                t.printA();
                t.printB();//该属性（方法）为只有本类内部可以访问（类内部可见）
                t.printAB();//多态的定理
        多态的前提，将子类对象当做父类对象来看，我们可以把子类对象当做父类对象来看，但是我们一旦这样做了，就只能用父类的方法。（这个就是为什么会调用此方法的原因）
        当我们把子类对象当做父类对象来看是，如果子类覆盖了父类的方法，则调用该方法时，该调用是子类覆盖后的方法。
        }