继承+多态（未完）详细

子类访问父类成员的三种方式

1. 在子类内部访问父类成员

2. 通过子类对象名访问父类成员

3. 通过子类类名访问父类成员

经验证，子类通过三种方式的任何一种都无法访问父类的私有成员，因此我们得出结论：私有成员无法被子类继承

package testsuper;
class A{
  public int i;
  public int j;
  public A(){
    
}
  public A(int i,int j){
      this.i = i;
      this.j = j;
  }
​
}
class B extends A{
  public int k;
  public B(){
      
  }
  public B(int i,int j,int k){
     // this.i = i;//一定要明白i前面可以加this
    //  this.j = j;
     // A(i,j);error
      super(i,j);
      this.k = k;
  }
}
​
public class TestSuper {
​
    public static void main(String[] args) {
       B bb = new B(1,2,22);
       System.out.printf("%d  %d\n",bb.i,bb.j);
    }
    
}
​

1. 每一个子类构造方法的第一条语句，都会隐含的调用super（），如果父类没有这样的构造方法，那再编译的时候就会出错

2. 如果显式地写出super（）语句，则必须保证该语句时第一条语句，否则出错

3. super（）如果不写，则编译器会自动添加所以父类没有无参的构造方法就会出错

4. 既可以写super（）前提是父类必须有无参的构造方法

   也可以写成super（实参）前提是父类必须有代餐的构造函数

5. 调用弗雷德构造函数的语句必须借助super，不能直接写父类的类名

6. 一个构造函数中不能写多个super（参数列表）语句

package testsuper;
class A{
  public int i;
  public A(){
      
  }
  public A(int i){
      this.i = i;
  }
}
class B extends A{
public int j;
public B(int i,int j){
    this.j = j; 
    //super();
    //super(i);
    
}
public void f(int i){
    //super(i);//普通方法中不能调用父类的构造方法
}
}
​
public class TestSuper {
    public static void main(String[] args) {
    
    }
    
}
​

package testover;
class A{
    public void f(){
        System.out.printf("AAAAAA\n");
    }
      public void f(int i){
          System.out.printf("哈哈哈哈!\n");
      }
}
class B extends A{
      public void f(){
          super.f();//调用父类继承过来的f方法
          f(41);
        System.out.printf("BBBBB\n");
    }
    
}
​
public class TestOver {
    public static void main(String[] args) {
        B bb = new B();
        bb.f();
    }
 
    

方法重写

重写方法必修和被重写方法具有相同的方法名称、参数列表和返回值类型

重写方法时，不能使用比父类中被覆盖的方法更严格的访问权限。

多态

package testpoly;
class A{
    public void f(){
        System.out.printf("AAAA\n");
    }
}
class B extends A{
     public void f(){
        System.out.printf("BBBB\n");
    }
}
public class TestPoly {
​
    public static void main(String[] args) {
           A aa = new A();
           B bb = new B();
           aa.f();
           bb.f();
           
           aa = bb;//把bb当作aa来看 因为子类可以当作父类看待，所以本语句ok
          // bb = aa;//把aa当作bb来看 因为父类不能当作子类
    }
    
}