class  A{
        public void a(){
                System.out.println("A-a()");
         }
        public void b(){
                 this.a();
                System.out.println("A--b()");
        }

class B extends A{

       
        public static void main(String[] args){
                B  bb=new B();
                bb.b();
        }

A-a()
A--b()



侄女，约吗？

我也认为是楼上的答案
A-a()
A--b()

因为B继承A那么在初始化B的时候就会运行父类（A）的默认构造，但是a和b不是默认构造，所以再运行B类的默认构造，可是也没有。然后就运行b方法，b方法B类里没有A里有。那么问题就来了，会不会运行父类里的b方法呢?一直也没关注这个问题。。= =测了下，直接就调了。。因为B里没有b，同时B继承了A。。。

A-a()   A--b()

1. package tRY;
   
2. public class Try {
   
3.          public static void main(String[] args) {
   
4.         //  创建子类对象
   
5.           Zi z=new Zi("zi的构造函数");
   
6.           Zi i=new Zi();
   
7.           z.show();
   
8.           z.fangfa();
   
9.           z.nowrite();
   
10.           System.out.println(z.num);
    
11.          }
    
12.         }
    
13.         class Fu{
    
14.          int num =4;
    
15.          Fu(){
    
16.           System.out.println("fu的构造函数");
    
17.          }
    
18.          void fangfa(){
    
19.           System.out.println("Fu");
    
20.          }
    
21.         // 当子类没有复写父类方法，将直接继承。
    
22.          void nowrite(){
    
23.           System.out.println("没有复写");
    
24.          }
    
25.         }
    
26.         class Zi extends Fu{
    
27.         // 与父类相同的变量名覆盖父类变量
    
28.          int num =5;
    
29.         // 调用super表示父类对象的引用
    
30.          Zi(String a){
    
31.         //  子类构造函数默认第一行有一条隐式语句  super();
    
32.           System.out.println("覆盖父类变量：："+a);
    
33.          }
    
34.          Zi(){
    
35.           System.out.println("zi的空参数构造函数");
    
36.          }
    
37.          void show(){
    
38.           System.out.println("引用父类..."+super.num);
    
39.          }
    
40.         // 与父类相同的函数名是覆盖父类方法
    
41.          void fangfa(){
    
42.           System.out.println("覆盖父类方法：zi");
    
43.          }
    
44.         }
    
45.         //注意：子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
    
46.         //静态只能覆盖静态。
    
47.         //在对子类对象进行初始化时父类的构造函数也会运行；
    
48.         //因为子类中所有的构造函数默认第一行都是 super();
    
49.         //super();会访问父类中空参数的构造函数,该语句必须写在子类构造函数的第一行。
    
50. 
    
51. //        final关键字:
    
52. 
    
53.         //final可以修饰类，方法，变量。
    
54.         //final修饰的类不可以被继承。
    
55.         //final修饰的方法不可以被覆盖。
    
56.         //final修饰的变量是一个常量。只能被赋值一次。
    
57.         //内部类只能访问被final修饰的局部变量。

复制代码