Java面向對象程序設計第6章1-12

時間  2019-11-08
標籤 java 面向對象 程序設計 欄目 Java 简体版
原文   原文鏈接

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

this

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

  1. 表示當前對象引用，經常使用於形參或局部變量與類的成員變app

    量同名的情形，使用this.成員名錶示當前對象的成員ide

1570613133325

  1. 表示當前對象
  • 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(); }
}
  1. 調用當前類的構造方法
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訪問當前類的直接父類，主要應用場合：函數

  1. 子類的數據成員或成員方法與父類的數據成員或成員方法名this

    字相同時，當要調用父類的同名方法或同名數據成員時則可設計

    用super來指明。即super.數據成員；super.成員方法code

  2. super(參數) , 表示調用父類構造方法orm

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();
    }
 }

注意：

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

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

    中用的x都是子類本身的，若要使用父類x，則必須用super.x。

  2. 子類在覆蓋父類方法的同時，調用父類的super.Printme()，這

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

    的代碼雖然調用父類代碼，但其中的this指的是子類對象。

2.子類對象實例化的具體過程是什麼？

  1. 子類在構造對象時候，必須訪問父類的構造函數，爲了完成這個必須的動做，就在子類的構造函數中加入了super()語句。
  2. 若是父類中沒有定義空參數構造函數，那麼子類的構造函數必須用super明確要調用父類中哪一個構造函數，不然子類沒法完成初始化。
  3. 在構造函數生效以前，程序會先執行靜態的成員活方法的初始化。

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.接口有什麼做用？本身定義一個接口，並給出實現類和使用類。

接口的兩種含義：

  1. 能夠被引用調用的方法（public方法或同包中的protected方法或默認方法）；
  2. 另外一種是同「類」概念地位至關的專有概念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 ();當經過接口調用玫瑰洗衣機類獨有的，  
                     //接口未定義的功能方法，編譯會報錯。
  }  
}

注意:

  1. 在類中，用implements關鍵字來實現接口。一個類能夠實現多個接口，在implements後用逗號隔開多個接口的名字。一個接口也可被多個類來實現。

  2. 接口中的字段（域）的值存儲在該接口的靜態存儲區域內，使用接口名.字段或實現類.字段都可訪問。

  3. 若是實現某接口的類不是abstract修飾的抽象類，則在類的定義部分必須實現接口的全部抽象方法，並且方法頭部分應該與接口中的定義徹底一致。
  4. 若是實現接口的類是abstract類，則它能夠不實現該接口的全部方法。但對於抽象類的任何一個非抽象的子類而言，接口中的全部抽象方法都必須實現。

  5. 類在實現接口的抽象方法時，必須顯式使用public修飾符，不然將被警告爲縮小了接口中定義的方法的訪問控制範圍。

6.抽象類與接口的異同點是什麼？

相同點：

  1. 不能直接實例化，若是要實例化，抽象類變量必須指向實現全部抽象方法的子類對象，接口變量必須指向實現全部接口方法的類對象。
  2. 都有本身的聲明，能夠引用子類或實現類對象

不一樣點：

  1. 抽象類能夠有域變量，接口沒有，只能是靜態常量。
  2. 抽象類能夠有具體方法；接口全是抽象方法。
  3. 抽象類實現靠子類繼承，接口靠實現類。

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

  1. equals方法比較。
  2. 使用「==」進行比較。
  3. 使用instanceof比較引用類型

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

做用：

  1. 內部類能夠很好的實現隱藏。通常的非內部類，是不容許有 private 與protected權限的，但內部類能夠。
  2. 內部類擁有外圍類的全部元素的訪問權限。
  3. 但是實現多重繼承。
  4. 能夠避免修改接口而實現同一個類中兩種同名方法的調用。

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.什麼是數據隱藏？如何證實子類對父類同名方法進行從新定義，只能是方法的覆蓋，而不是方法的隱藏？

  1. 在子類對父類的繼承中，若是子類的成員變量和父類的成員變量同名，此時稱爲子類隱藏（override）了父類的成員變量。

  2. 覆蓋：子類重寫父類的方法，要求方法名和參數類型徹底同樣(參數不能是子類)，返回值和異常比父類小或者相同(即爲父類的子類)，訪問修飾符比父類大或者相同。

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

11.A一、A2分別是具體類A的子類，A3爲A1的子類，A一、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

15706240569481570624077550

1570624100716

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程