方法覆写中，被子类覆写的方法不能拥有比父类更加严格的访问权限。
但是如下代码为什么不算覆写？
class A{                // 定义父类
        private void print(){        // 默认的访问权限
                System.out.println("A") ;
        }
        public void fun(){        // 定义一个fun方法
                this.print() ;        // 调用print()方法
        }
};
class B extends A{        // 定义继承关系
        void print(){        // 覆写父类中的方法
                System.out.println("B") ;
        }
};
public class Demo{
        public static void main(String args[]){
                B b = new B() ;
                b.fun() ;
        }
};

private 是类私有的，改为protected才能被子类访问

方法覆写中，被子类覆写的方法不能拥有比父类更加严格的访问权限。
但是如下代码为什么不算覆写？
class A{                // 定义父类
        private void print(){        // 默认的访问权限
                System.out.println("A") ;
        }
        public void fun(){        // 定义一个fun方法
                this.print() ;        // 调用print()方法
        }
};
class B extends A{        // 定义继承关系
        void print(){        // 覆写父类中的方法
                System.out.println("B") ;
        }
};
public class Demo{
        public static void main(String args[]){
                B b = new B() ;
                b.fun() ;
        }
};


你这个代码写有很多语法错误啊  还有你创建了B对象 调用的是B内的方法，跟其父类是没有任何关系的啊  

你是想问:我在子类复写了父类的方法,可是为什么最后结果打印的是A而不是B 对吧!  不知道为什么类结束都多了一个分号  难道是另一种格式么?

1. class A{                // 定义父类
   
2.         private void print(){        // 默认的访问权限
   
3.                 System.out.println("A") ;
   
4.         }
   
5.         public void fun(){        // 定义一个fun方法
   
6.                 this.print() ;        // -----2-----调用本类的print()方法  打印的结果就是A了  如果你在子类复写这个方法的话   那打印的结果就是B了
   
7.         }
   
8. }
   
9. class B extends A{        // 定义继承关系
   
10.         void print(){        // 覆写父类中的方法
    
11.                 System.out.println("B") ;
    
12.         }
    
13. }
    
14. public class Demo{
    
15.         public static void main(String args[]){
    
16.                 B b = new B() ;
    
17.                 b.fun() ;     //----1----调用fun()方法的时候因为子类没有复盖父类的方法,所以就会去调用父类的fun()方法!
    
18.         }
    
19. }

复制代码

在JAVA中，子类是无法继承父类的private修饰的属性和方法的，也就是说子类继承了父类，却没有继承其用private修饰的属性和方法，就无法调用了。这有利于在开发过程中保护父类的某种属性和方法不被覆盖  ，如果你想调用的话，就只能通过父类的方法，比如get和set方法               
需要注意的是：使用了private修饰的属性和方法，默认使用final修饰，也就是说使用了private修饰的属性，是一个常量，第一次加载初始化后就不能够更改！
希望对你有帮助，黑马程序员加油！

类的成员方法的访问权限：
其从语法角度来讲，这写访问权限控制符作用于类的方法和作用于类的属性上的效果是一样的。
public：所有类可见。
private：只有同一类内部的方法可见，在有就是内部类也可以访问到。
默认（friendly）：包内可见。
protected:继承可见

楼主？？看到没？private不是默认的访问权限！！！！！！！！！！！private修饰的方法是在子孙类中访问不到的

作用域         当前类          同一package           子孙类                其他package
public              √                    √                       √                          √
protected         √                    √                      √                          ×
默认                √                    √                      ×                            ×
private             √                     ×                    ×                             ×

看到这里，我认为你应该好好想想还有什么 问题了，想到以后再看我下面的代码
class A
{                // 定义父类
        void print()
        {        // 默认的访问权限
                System.out.println("A") ;
    }
    public void fun()
        {        // 定义一个fun方法
                this.print() ;        // 调用print()方法
    }
}

class B extends A
{        // 定义继承关系
        void print()
        {        // 覆写父类中的方法
                System.out.println("B") ;
    }
}



class  Lun
{
        public static void main(String[] args)
        {
                B b = new B();
                b.fun();
        }
}
这里你一定会问，不是默认的权限不是不能被子孙类访问么？好吧，我现在也没有学习到package这一块，但是从编译运行的结果来看，父类的默认方法的确是被访问到了，这就说明：这~~个~~子~~类~~和~~父~~类~~是~~在~~同~~一~~个~~包~~中

这个很简单，因为，你 new一个对象时建立的 子类的对象，父类加载到内存中。
所以你调用 fun方法时，其实是直接调用的 父类的方法。
虽然 你子类中写了 覆盖 父类的方法，但是你没有调用，所以等于没有作用。
如果你在main 函数里面 写上  b.print();  就能打印 出 B。

什么时候使用覆盖呢？
当一个子类的功能内容需要修改时，可以通过覆盖来实现。 ps：前提是，修改子类内容-->也就是说必须 调用子类的方法。

覆盖是：main 函数调用 子类，然后 子类再 覆盖父类。
换句话说：你建立子类对象 却没有运行 子类中的方法。

一句话: 你写了一个 关于 覆盖的函数，但是你没有用。

恍然大悟........