继承（作业篇）

简简单单继续作业~

第一题：
关于包的说法，下列错误的是：

A. 在Java中，包（package）是一种用来组织类和接口的机制。包可以将相关的类和接口组织在一起，形成一个集合。这样做不仅有助于代码的组织和管理，还能避免类名冲突。
B. 包提供了一个命名空间，这意味着不同包中的类可以使用相同的名字而不会发生冲突。例如，com.example.MyClass 和 org.example.MyClass 是两个不同的类，因为它们位于不同的包中。
C. import 语句用于导入包中的特定类或接口，而不是整个包。例如，import java.util.ArrayList; 导入的是 java.util 包中的 ArrayList 类，而不是整个 java.util 包。
D. import static 语句用于导入类的静态成员（静态方法和静态字段），使得在代码中可以直接使用这些静态成员，而不需要通过类名来引用。例如，import static java.lang.Math.PI; 导入的是 Math 类的静态字段 PI，这样在代码中可以直接使用 PI 而不需要写 Math.PI。
所以选C

第二题：
以下关于关键字super的描述中，正确的是：

A. super 关键字代表的是父类的引用，可以用来访问父类的属性和方法。子类对象包含了父类的所有特征，包括属性和方法，因此 super 关键字可以在子类对象中使用。
B. super 关键字只能指代子类的直接父类，不能直接指代父类的父类。如果需要访问父类的父类的方法或属性，需要通过直接父类来间接访问。
C. 子类通过 super 关键字既可以调用父类的方法，也可以调用父类的属性。例如，super.method() 可以调用父类的方法，super.field 可以调用父类的属性。
D. 子类通过 super 关键字既可以调用父类的属性，也可以调用父类的方法。例如，super.field 可以调用父类的属性，super.method() 可以调用父类的方法。
所以选A

class X{
	Y y=new Y();//1
	public X(){//2
		System.out.print("X");
	}
}
class Y{
	public Y(){//3
		System.out.print("Y");
	}
}
public class Z extends X{
	Y y=new Y();//4
	public Z(){//5
		System.out.print("Z");
	}
	public static void main(String[] args) {
		new Z();
	}
}

程序的执行结果是：

注：构造器与构造方法是同一个概念，不同的叫法而已

1. 父类构造器的调用：由于 Z 继承自 X，首先会调用 X 中的内容。
2. 父类成员变量的初始化：在调用 X 的构造器之前，会先初始化 X 中的成员变量 Y y。因此，会调用 Y 的构造器，输出 Y。
3. 父类构造器的执行：然后执行 X 的构造器，输出 X。
4. 子类成员变量的初始化：接着，会初始化 Z 中的成员变量 Y y。因此，会再次调用 Y 的构造器，输出 Y。
5. 子类构造器的执行：最后，执行 Z 的构造器，输出 Z。

综上所述，输出结果将是 YXYZ。

class Base{
  public Base(String s){
    System.out.print("B");
  }
}

public class Derived extends Base{
  public Derived (String s) {
    System.out.print("D");
  }
  public static void main(String[] args){
    new Derived("C");
  }
}

以上程序的输出结果为：

如果熟练了解我们之前所讲的子类构造方法的话，可以很容易发现，题目中的父类Base有一个自定义的含参（重点就是含参，无参的话子类就不需要显式调用了）构造方法（也就是显式构造方法），那么我们子类是不是就一定要先用super关键字调用我们父类的构造方法呀，因为这个时候程序不会给子类进行隐式的无参调用。所以编译会错误。
那么我们更改代码如下：

class Base {
  public Base(String s) {
    System.out.print("B");
  }
}

public class Derived extends Base {
  public Derived(String s) {
    super(s); // 显式调用父类的带参数构造器
    System.out.print("D");
  }
  public static void main(String[] args) {
    new Derived("C");
  }
}

此事的调用结果就是“BD”。

class Base {
  Base() {
  	System.out.print("Base"); 
  }
}

public class Alpha extends Base {
 
  public static void main( String[] args ) {
    new Alpha();//1
   
    new Base();//2
  } 
}

以上程序的输出结果为：

本题与上题考查内容基本一致，在父类Base中创建了一个无参的构造方法，那么系统就会给子类一个隐式的super调用，所以程序不会编译失败。
1.new Alpha()当我们调用 new Alpha() 时，会发生以下步骤：
父类构造器的调用：由于 Alpha 继承自 Base，首先会调用 Base 的构造器。
父类构造器的执行：执行 Base 的构造器，输出 Base。
子类构造器的调用：由于 Alpha 类没有显式定义构造器，编译器会提供一个默认的无参构造器。这个默认构造器会隐式调用父类的无参构造器。
子类构造器的执行：由于 Alpha 类没有显式定义构造器，也没有其他代码需要执行，因此不会输出任何内容。

2.new Base()当我们调用 new Base() 时，会发生以下步骤：
构造器的调用：调用 Base 的构造器。
构造器的执行：执行 Base 的构造器，输出 Base。
综合选B。