练习代码（三）复用类

小白做课后习题，有不对的地方或者不好的地方多多包容。

1.创建两个带有缺省构造器（空参数列表）的类A和类B。从A中继承产生一个名为C的信类，并在C内创建一个B类的成员。不要给C编写构造器。创建一个C类的对象并观察其结果。

package six;
class A{
     public  A(){
System.out.println("A");
}
}
class B{
 public  B(){
System.out.println("B");
}
}
public class C extends A{

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

输出结果为：

B

A

2.修改练习1，使A和B以带参数的构造器取代缺省的构造器。为C写一个构造器，并在期中执行所有的初始化。

package six;
class A{
public A(String a){
System.out.println(a);
}
}
class B{
public B(String b){
System.out.println(b);
}
}
public class C extends A{
    public C(){
super("A");
B b = new B("B");
}
public static void main(String[] args){
new C();
}
}

输出结果为:

A

B

3.创建一个简单的类。在第二个类中，将一个引用定义为第一个类的对象。运用惰性初始化来实例化这个对象。

package six;
class A{
public A(String a){
System.out.println(a);
}
}
public class C{
   private A ab = null;
String a;
public A geta(){
if(ab == null)
ab = new A("A");
return ab;
}
    public static void main(String[] args){
   C c = new C();
   c.geta();
}
}

4. 请证明缺省构造器是编辑器所创建的。

package six;

public class C{

    public static void main(String[] args){
    new C();
}
}

5.证明基类构造器：（a）总是会被调用；（b）在导出类构造器之前被调用。

package six;
class A{
A(){
System.out.println("A");
}
}
public class C extends A{
C(){
System.out.println("C");
}
    public static void main(String[] args){
    new C();
}
}

输出结果：

A

C

6. 创建一个基类，它仅有一个非缺省构造器；再创建一个导出类，它带有缺省构造器和非缺省构造器。在导出类的构造器中调用基类的构造器。

package six;
class A{
A(String a){
System.out.println(a);
}
}
public class C extends A{
C(){
super("A");
System.out.println("C");
}
C(String c){
super("A");
System.out.println(c);
}
    public static void main(String[] args){
    new C();
    new C("Cc");
}
}

输出结果：

A
C
A
Cc

7. 创建一个Root类，令其含有名为Component1，Component2，Component3的类各一个实例。从Root中派生一个类Stem，也含有上述各“组成部分”。所有的类都应带有可打印出类的相关信息的缺省构造器。

package six;
class Connpent1{
public Connpent1(){
System.out.println("Connpent1()");
}
}
class Connpent2{
public Connpent2(){
System.out.println("Connpent2()");
}
}
class Connpent3{
public Connpent3(){
System.out.println("Connpent3()");
}
}
class Root {
Connpent1 a1 = new Connpent1();
Connpent2 a2 = new Connpent2();
Connpent3 a3 = new Connpent3();
public Root(){
System.out.println("Root()");
}
}
public class Stem extends Root {
Connpent1 a1 = new Connpent1();
Connpent2 a2 = new Connpent2();
Connpent3 a3 = new Connpent3();
public Stem(){
System.out.println("Stem()");
}
    public static void main(String[] args){
new Stem();
}
}

输出结果：

Connpent1()
Connpent2()
Connpent3()
Root()
Connpent1()
Connpent2()
Connpent3()
Stem()

8. 修改练习7，使每个类都仅具有非缺省构造器。

package six;
class Connpent1{
public Connpent1(String s){
System.out.println("Connpent1()");
}
}
class Connpent2{
public Connpent2(String s){
System.out.println("Connpent2()");
}
}
class Connpent3{
public Connpent3(String s){
System.out.println("Connpent3()");
}
}
class Root {
Connpent1 a1 = new Connpent1("a");
Connpent2 a2 = new Connpent2("b");
Connpent3 a3 = new Connpent3("c");
public Root(int i){
System.out.println("Root()");
}
}
public class Stem extends Root {
Connpent1 a1 = new Connpent1("a");
Connpent2 a2 = new Connpent2("b");
Connpent3 a3 = new Connpent3("c");
public Stem(int i){
super(345);
System.out.println("Stem()");
}
    public static void main(String[] args){
new Stem(123);
}
}

输出结果：

Connpent1()
Connpent2()
Connpent3()
Root()
Connpent1()
Connpent2()
Connpent3()
Stem()

9. 创建一个类，它应带有一个被重载了三次的方法。继承产生一个新类，并添加一个该方法的新的重载定义，展示这四个方法在导出类中都是可以使用的。

package six;
class Root{
public void say(String a){
System.out.println(a);
}
public void say(int a){
System.out.println(a);
}
public void say(char a){
System.out.println(a);
}
}
public class Stem extends Root{
public void say(double a){
System.out.println(a);
}
public static void main(String[] args){
Stem stem = new Stem();
stem.say("World");
stem.say(123);
stem.say('x');
stem.say(1.0);
}
}

输出结果：

World
123
x
1.0

10 .创建一个名为Amphibian的类。由此继承产生一个称为Frog的类。在基类中设置适当的方法。在main（）方法中，创建一个Frog并向上转型至Amphibian，然后说明所有方法都可工作。

package six;
class Amphibian{
public void printa(){
System.out.println("Hello World");
}
}
public class Frog extends Amphibian{
public void printf(){
System.out.println("Hello Java");
}
public static void main(String[] args){
Amphibian a = new Frog();
a.printa();
}
}

输出结果：

Hello World

11. 修改练习10，使Frog覆盖基类中的方法定义，请留意main（）中都发生了什么。

package six;
class Amphibian{
public void print(){
System.out.println("Hello World");
}
}
public class Frog extends Amphibian{
public void print(){
System.out.println("Hello Java");
}
public static void main(String[] args){
Amphibian a = new Frog();
a.print();
}
}

输出结果：

Hello Java   

基类中的方法无法被调用。

12. 创建一个含有指向某对象的空白final引用的类。在所有的构造器内部都执行空白final的初始化动作。说明Java确保final在使用前必须被初始化，且一旦被初始化即无法改变。

package six;
class Amphibian{
public Amphibian(String s){
System.out.println(s);
}
}
public class Frog {
private final Amphibian ahn;
public Frog(){
ahn = new Amphibian("initialize");
}
public Frog(String s){
ahn = new Amphibian(s);
}
public static void main(String[] args){
new Frog();
new Frog("initialize");
}
}

输出结果：

initialize
initialize