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教程