Java面向物件程式設計第6章1-12

1.this和super各有幾種用法？

this

this 用法有三種，主要應用場合：

表示當前物件引用，常用於形參或區域性變數與類的成員變

量同名的情形，使用this.成員名錶示當前物件的成員

1570613133325

表示當前物件

class FighterPlane {
   private String name;
   private int missileNum;   
   private A  a;

   public void setA(A _a){
      if (_a !=null)  { a = _a ;}
   }

   public A getA(){
      if (a !=null)
          { return a;}
      else  return null;
   }

   public void fire(){ ……}
   public FighterPlane(String _name,int _missileNum){ ……}
}
class A 
{
    FighterPlane fp;
    public A(FighterPlane fpp){
       this.fp = fpp; 
       fpp.setA(this);//將當前物件傳給FighterPlane
    }
    public void invoke(){
       //A中物件傳送訊息給FighterPlane的物件
       fp.fire(); 
    }
}
public class  Run{
   public static void main(String[] args)
   {  
     FighterPlane ftp = new FighterPlane("su35",10);
     A  a   = new A(ftp); 
     a.invoke(); }
}

呼叫當前類的構造方法

class AddClass {
  public int x=0,y=0,z=0;

  AddClass (int x) 
    {   this.x=x;   }
  
  AddClass (int x,int y) 
  { this(x);  this.y=y; } 

  AddClass (int x,int y,int z) 
    { this(x,y); this.z=z; } 

  public int add()
    {return x+y+z; }
}
public class RunAddClass
{
   public static void main(String[] args)
    {
       AddClass p1=new AddClass(2,3,5);
       AddClass p2=new AddClass(10,20);  
       AddClass p3=new AddClass(1);
       System.out.println("x+y+z="+p1.add());
       System.out.println("x+y="+p2.add());
       System.out.println("x="+p3.add());
    }
}

super

super訪問當前類的直接父類，主要應用場合：

子類的資料成員或成員方法與父類的資料成員或成員方法名

字相同時，當要呼叫父類的同名方法或同名數據成員時則可

用super來指明。即super.資料成員；super.成員方法
super(引數) , 表示呼叫父類構造方法

class A
{
    int x=4;int y=1;
    public void Printme()
      { System.out.println("x="+x+" y="+y);
        System.out.println("class name: "+getClass().getName());
      }
}
public class AA extends A{  
    int x;
    public void Printme()
      { int z=super.x+6;
        super.x = 5;
        super.Printme(); 
        System.out.println("I am an  
                "+getClass().getName()); 
        x=6;
        System.out.println(" z="+z+" x="+x+" 
                        super.x="+super.x +"  
                       y="+y+"super.y="+y);
      }
}
public static void main(String arg[])
     { int k;
       A p1=new A();
       AA p2=new AA();
       p1.Printme();
       p2.Printme();
    }
 }

注意：

子類和父類定義了同名數據成員，子類繼承了父類的x，自

己又定義了一個x，則會發生父類資料成員的隱藏。在子類

中用的x都是子類自己的，若要使用父類x，則必須用super.x。
子類在覆蓋父類方法的同時，呼叫父類的super.Printme()，這

個方法中的成員變數均為父類的成員變數。super.Printme()中

的程式碼雖然呼叫父類程式碼，但其中的this指的是子類物件。

2.子類物件例項化的具體過程是什麼？

子類在構造物件時候，必須訪問父類的建構函式，為了完成這個必須的動作，就在子類的建構函式中加入了super()語句。
如果父類中沒有定義空引數建構函式，那麼子類的建構函式必須用super明確要呼叫父類中哪個建構函式，否則子類無法完成初始化。
在建構函式生效之前，程式會先執行靜態的成員活方法的初始化。

3.類的域變數和方法中定義的區域性變數在初始化上有何區別？

類的域變數在類初始化的時候就開始建立了，而方法中的變數是在呼叫到該方法時，才會為該變數建立。

4.模仿形成抽象類的過程，自選角度，形成一個自己的抽象類，並在程式的類繼承和引用中體現抽象類的作用。

import java.awt.*;
import java.applet.*;
//抽象類Shapes
abstract class Shapes 
{ 
  protected int x,y,k; 
  protected double m;
  public Shapes(int x,int y,int k,double m){
    this.x=x;   this.y=y;
    this.k=k;   this.m=m;
  }
  abstract public double getArea();
  abstract public double getPerimeter();
}
//各子類定義
class Rect extends Shapes {
  public double getArea()
  { return(k*m); }
  public double getPerimeter()
  { return(2*k+2*m);}
  public Rect(int x,int y,int width,int height)
  { super(x,y,width,height);}
}

class Triangle extends Shapes{
    public double getArea(){
       return(Math.sqrt(m*( m-k)*( m-x)*(m-y)));}
    public double getPerimeter(){
       return(k+x+y);}
    public Triangle(int baseA,int baseB,int baseC){
       super(baseA, baseB, baseC,0);
            //m充當了周長的一半
       m= (baseA+ baseB+ baseC)/2.0;
    }
}

class Circle extends Shapes{
    public double getArea()
   //Math是java.lang包中的類，PI是靜態其屬性，其值為Π
  { return(m* m *Math.PI);}
    public double getPerimeter()
     {return(2*Math.PI* m);}
    public Circle(int x,int y,int width){
   //k充當了直徑，m充當了半徑的角色
     super(x,y, width, width/2.0);
  }
}
//使用類
public class RunShape extends Applet{
  Rect rect=new Rect(5,15,25,25);
  Triangle tri=new Triangle(5,5,8);
  Circle cir =new Circle(13,90,25);
  public void paint(Graphics g){
   //繪製矩形，輸出矩形的面積和周長
       g.drawRect(rect.x,rect.y,rect.k,(int)rect.m);
       g.drawString("Rect Area:"+rect.getArea(),50,35);
       g.drawString("Rect Perimeter:"+rect.getPerimeter(),50,55);

   //輸出三角形的面積和周長
       g.drawString("Triangle Area:"+tri.getArea(),50,75);
       g.drawString("Triangle Perimeter:"+tri.getPerimeter(),50,95);

   //繪製圓，輸出圓的面積和周長
       g.drawOval(cir.x-(int)cir.k/2,cir.y-(int)cir.k/2,cir.k,cir.k);
       g.drawString("Circle Area:"+cir.getArea(),50,115);
       g.drawString("Circle Perimeter:"+cir. getPerimeter(),50,135); 
  }
}

5.介面有什麼作用？自己定義一個介面，並給出實現類和使用類。

介面的兩種含義：

可以被引用呼叫的方法（public方法或同包中的protected方法或預設方法）；
另一種是同“類”概念地位相當的專有概念interface， interface是方法說明的集合。

作用：

介面最直接的好處就是提供了一個統一的操作方法名，然後同樣的方法名在不同的類中可以有不同的具體實現過程，這樣的結果就是在操作實現了該介面的類的物件時，不用去事先了解該方法的名字，而採用統一的名字進行呼叫。

介面的設計用途：通用可擴充套件程式碼，多型體現

import java.util.*;
public boolean addAll(int index, Collection c) {
       int numNew = c.size();
        ......
}
public boolean addAll(int index, AbstractCollection c)
public boolean addAll(int index, AbstractList c)
public boolean addAll(int index, AbstractSet c)
public boolean addAll(int index, LinkedList c)
public boolean addAll(int index, ArrayList c)
......

//定義介面
public interface  Washer {
    public static final int ON = 1 ;
    public static final int OFF = 0 ;
    abstract void startUp();     //啟動  
    abstract void letWaterIn();  //進水
    abstract void washClothes(); //洗衣
    abstract void letWaterOut(); //排水
    abstract void stop();        //停止
}
//實現介面
class RoseBrand implements Washer{
    public  void startUp(){ System.out.println("startUp");}
    public  void letWaterIn(){System.out.println("letWaterIn");}
    public  void washClothes(){System.out.println("washClothes");}
    public  void letWaterOut(){System.out.println("letWaterOut");}
    public  void stop(){System.out.println("stop");}
    public  void dehydrate(){System.out.println("dehydrate ");}//脫水
}
//使用介面
public class Consumer {
  public static void main(String args[]){
      //介面宣告引用實現介面的RoseBrand類的物件。
      Washer  w = new RoseBrand();
      w.startUp();
      w.letWaterIn();
      w.washClothes();
      w.letWaterOut();
      w.stop();
      //w.dehydrate ();當通過介面呼叫玫瑰洗衣機類獨有的，  
                     //介面未定義的功能方法，編譯會報錯。
  }  
}

注意:

在類中，用implements關鍵字來實現介面。一個類可以實現多個介面，在implements後用逗號隔開多個介面的名字。一個介面也可被多個類來實現。
介面中的欄位（域）的值儲存在該介面的靜態儲存區域內，使用介面名.欄位或實現類.欄位均可訪問。
如果實現某介面的類不是abstract修飾的抽象類，則在類的定義部分必須實現介面的所有抽象方法，而且方法頭部分應該與介面中的定義完全一致。
如果實現介面的類是abstract類，則它可以不實現該介面的所有方法。但對於抽象類的任何一個非抽象的子類而言，介面中的所有抽象方法都必須實現。
類在實現介面的抽象方法時，必須顯式使用public修飾符，否則將被警告為縮小了介面中定義的方法的訪問控制範圍。

6.抽象類與介面的異同點是什麼？

相同點：

不能直接例項化，如果要例項化，抽象類變數必須指向實現所有抽象方法的子類物件，介面變數必須指向實現所有介面方法的類物件。
都有自己的宣告，可以引用子類或實現類物件

不同點：

抽象類可以有域變數，介面沒有，只能是靜態常量。
抽象類可以有具體方法；介面全是抽象方法。
抽象類實現靠子類繼承，介面靠實現類。

7.引用比較方法有哪些？

equals方法比較。
使用“==”進行比較。
使用instanceof比較引用型別

8.內部類的作用是什麼？什麼情況下使用匿名內部類？

作用：

內部類可以很好的實現隱藏。一般的非內部類，是不允許有 private 與protected許可權的，但內部類可以。
內部類擁有外圍類的所有元素的訪問許可權。
可是實現多重繼承。
可以避免修改介面而實現同一個類中兩種同名方法的呼叫。

9.不上機，判斷下面程式的輸岀結果。

class X {
    Y b = new Y();
    X() {
        System.out.println("X");
    }
}
class Y {
    Y() {
        System.out.println("Y");
    }
}
public class Z extends X{
    Y y = new Y();
    Z() {
        System.out.println("Z");
    }
    public static void main(String[] args) {
        new Z();
    }
}

A. Z 　　　B. YZ 　　　C. XYZ　　　 D. YXYZ

答案：D
解析：執行new Z();後，進入Z類，首先實現父類X，實現X時又由於Y b = new Y();先實現Y，於是輸出Y，完畢後回到X，輸出X，再回到Z類，執行Y y = new Y();輸出Y，最後輸出Z。

10.什麼是資料隱藏？如何證明子類對父類同名方法進行重新定義，只能是方法的覆蓋，而不是方法的隱藏？

在子類對父類的繼承中，如果子類的成員變數和父類的成員變數同名，此時稱為子類隱藏（override）了父類的成員變數。
覆蓋：子類重寫父類的方法，要求方法名和引數型別完全一樣(引數不能是子類)，返回值和異常比父類小或者相同(即為父類的子類)，訪問修飾符比父類大或者相同。

隱藏：父類和子類擁有相同名字的屬性或者方法（方法隱藏只有一種形式，就是父類和子類存在相同的靜態方法）時，父類的同名的屬性或者方法形式上不見了，實際是還是存在的。

11.A1、A2分別是具體類A的子類，A3為A1的子類，A1、A2之間的關係為平行類，如圖6.15所示。下面的程式碼為連續的程式片段，請問哪些是正確的？

A a = new A();
a = new A1();
a = new A2();
a = new A3();
A1 a1 = new A3 ();
A3 a3 = a1;           //×
A2 a2 = new A1();     //×
a3 = new A2();        //×

12.藉助JDK幫助，編寫程式實現這樣的功能：Applet當中的TextField，每輸入任一字元，在一個label當中都能動態跟蹤重新整理。

import java.applet.*;
import java.awt.*;
import java.awt.event.*;

public class test extends Applet implements ActionListener{
    private TextField input;
    private double d=0.0;
    //進行初始化工作，產生物件，加入監聽者
    public void init(){
        input = new TextField(10);
        //myApplet是容器，input是元件，呼叫add使input嵌入容器
        add(input);
        input.addActionListener(this); //向TextField註冊監聽器
    }
    public void paint(Graphics g){
        g.drawString("您輸入了資料"+d,10,50);
    }
    public void actionPerformed(ActionEvent e) {
        d=Double.valueOf(input.getText()).doubleValue();
        //進行重新整理，呼叫paint()方法
        repaint();
    }
}

1570624056948

1570624056948 1570624077550

157062410071

</div>
<div class=