java 实验3

实验3  继承与多态

    **类可以实现多个接口 但只有单继承！**

1、继承

　　1)、继承语法

 　　  class 子类名 extends 父类{

   　　}

　　2)、构造函数(通过source即可得到)

  注意： 当子类实例化，首先调用父类构造函数，其次调用子类本身构造函数

　　3)、函数重载:

　　简单来说 相同函数名 参数需求不同 在调用时自动寻找匹配的函数

　　4)、覆盖问题override

　　子类重写了一个从父类继承过来的函数与属性

　　---当使用时就直接使用子类函数

　　直接alt加 / 键就可重写

2、final（用此定义的属性 为常量）

　　1)、final定义的方法可继承，但不可override！

　　2)、fianl定义的类不可派生子类，但能生成对象

3、abstract（抽象）　　

 　　1)abstract函数:函数只有声明没有函数体（没有实现）

   　　　　public abstract double area();

　注意：此函数主要用作给子类override！

  　　2)abstract类:不能实例化，只能作为父类被其他类继承

   　　　　abstract class Shape{

     　　　　public abstract double area();

   　　　　  /*可以其他非抽象函数*/

　　　　　}　　

　　注意：此类主要用作子类对象的相同处、都有的属性（金字塔顶）

4、接口:interface 都是抽象方法和一些静态属性.

具体的方法在子类中实现

　　

　　1)定义接口

   　   　interface Shape{

      　　double pi=3.14;

      　　double area();

　　   }

　　

 　　2)类实现接口:如果不是抽象类，就需要实现接口中所有抽象方法

　　 3）类实现多个接口 ，用，隔开

　　　　　　class Circle implements Shape,Color{}

实践编程

1、实现一个名为Person的类和它的子类Employee

具体要求如下：

（1）      Person类中的属性有：姓名name（String类型），地址address（String类型），电话号码telphone（String类型）；

public class Person {
    private String name;
    private String address;
    private String telephone;
    public Person(String name, String address, String telephone) {
        super();
        this.name = name;
        this.address = address;
        this.telephone = telephone;
    }
    @Override
    public String toString() {
        return "name=" + name + ", address=" + address + ", telephone=" + telephone ;
    }
}

（2）Employee类中的属性有：办公室office（String类型），工资wage（double类型）

public class Employee extends Person {
    private String office;
    private double wage;
    public Employee(String name, String address, String telephone, String office, double wage) {
        super(name, address, telephone);
        this.office = office;
        this.wage = wage;
    }
    @Override
    public String toString() {
        return  super.toString()+", office=" + office + ", wage=" + wage   ;
    }
}

（3）测试代码，各个属性赋值在构造函数中完成。

public class test {
    public static void main(String[] args) {
        Employee e=new Employee("cf", "China", "911", "school", 20000);
        System.out.println(e.toString());
        }
}
 

2.方法调用匹配测试

class  methodMatch{
    double x=5,y=6;
    void test( double y ){
      System.out.println(y);
      test(this);  //转换匹配哪个方法
     }
   public String toString(){
      return x+","+y;
   }
   void  test( String  a){
      System.out.println(a);
     }
   void  test( Object  a){
      System.out.println(a);
     }
  public static void main(String args[]) {
     methodMatch  a=new  methodMatch ();
     a.test(8);  
     a.test("hello");  
   }
 }

Q:分析以上程序运行结果，删除test（String）方法后结果如何？加入一个test(int)方法执行结果又如何？最后，总结方法调用的匹配原则。

A:

　　8.0

　　5.0,6.0

　　hello

　　先找是否有与其变量匹配的

　　若没有则进入obj（万物皆对象）

　　Print（obj）时会调用tostring方法

3.将以下程序补充完整

public class Java_3{
          public static void main(String[] args){
                Person p = new Student("王甜甜", "计算机科学");
                System.out.println(p.getName() + ", "+ p.getDescription());
      }
    }

    abstract class Person{
           public Person(String n){
                 name = n;
       }
      //*********Found********
         public __abstract____ String getDescription();
            public String getName(){
                return name;
      }
          private String name;
     }
     //*********Found********
     class Student ___extends__ Person{
            public Student(String n, String m){
                  super(n);
                  major = m;
        }
      //*********Found********
           public String __getDescription___(){
                  return "学生专业是:" + major;
       }
          private String major;
   }

注意：

　　1 abstract函数:函数只有声明没有函数体（没有实现）--》在子类中实现

 　　2父类的所有抽象函数都需要实现

4  编写一个抽象的图形类Shape,里面有方法area()计算面积以及方法displayArea()显示面积，编写子类矩形类和三角型类分别实现两个方法。

　　抽象shape类

public abstract class Shape {
    abstract double area();
    abstract void displayArea();
}

注意： abstract函数:函数只有声明没有函数体（没有实现）--》在子类中实现

　　子类矩形类

public class MyRectangle extends Shape {
    private double length;
    private double width;
    public MyRectangle(double length, double width) {
        super();
        this.length = length;
        this.width = width;
    }
    @Override
    double area() {
        return length*width;
    }
    /* 
     * 覆盖了父类Shape的displayArea函数
     */
     @Override
    void displayArea() {
        System.out.println("Rectangle's area:"+area());
    }
}

注意：父类的所有抽象函数都需要实现

　　子类三角型类

public class MyTriangle extends Shape {
    private double length;
    private double height;
    public MyTriangle(double length, double height) {
        super();
        this.length = length;
        this.height = height;
    }
    @Override
    double area() {
        return 0.5*length*height;
    }
    /* 
     * 覆盖了父类Shape的displayArea函数
     */
     @Override
    void displayArea() {
        System.out.println("Triangle's area:"+area());
    }
}

 　　测试数据

public class test {
    public static void main(String[] args) {
        Shape a=new MyRectangle(10, 20.5);
        Shape b=new MyTriangle(10, 20.5);
        a.displayArea();
        b.displayArea();
    }
}

 

5、编写一个完整的Java  Application 程序。包含接口Shape，MyRectangle类，MyTriangle类及Test类，具体要求如下：

⑴、接口ShapeArea：

       double  area()：求一个形状的面积

　　double   perimeter ()：求一个形状的周长

interface ShapeArea {
    double area();
    double perimeter();
}

⑵、类 MyRectangle：

       实现Shape接口，并有以下属性和方法：

　　①    属性

　　width：  double类型，表示矩形的长

　　height：  double类型，表示矩形的高

　　②    方法

　　MyRectangle(double  w, double  h)：构造函数

 　　toString()方法 ：输出矩形的描述信息，如“width=1.0,height=2.0, perimeter=6.0, area=2.0”

class MyRectangle implements ShapeArea {
    private double width;
    private double height;
    
    public MyRectangle(double width, double height) {
        super();
        this.width = width;
        this.height = height;
    }
    @Override
    public double area() {
        return width*height;
    }
    @Override
    public double perimeter() {
        return 2*(width+height);
    }
    @Override
    public String toString() {
        return "MyRectangle [width=" + width + ", height=" + height + ", area=" + area() + ", perimeter="
                + perimeter() + "]";
    }
}

⑶、类MyTriangle：

       实现Shape接口，并有以下属性和方法：

　　①    属性

　　x,y,z: double型，表示三角形的三条边

　　s: 周长的1/2（注：求三角形面积公式为， s=(x+y+z)/2 ，开方可用Math.sqrt(double)方法）

　　②    方法

　　MyTriangle(double  x,  double  y,  double  z)：构造函数，给三条边和s赋初值。

　　toString()：输出矩形的描述信息，如“three sides:3.0,4.0,5.0,perimeter=12.0,area=6.0”

class MyTriangle implements ShapeArea {

    private double x;
    private double y;
    private double z;
    
    public MyTriangle(double x, double y, double z) {
        super();
        this.x = x;
        this.y = y;
        this.z = z;
    }

    @Override
    public double area() {
        double s=perimeter();
        return Math.sqrt(s*(s-x)*(s-y)*(s-z));
    }

    /* 
     * 覆盖了父类application的perimeter函数
     */
    @Override
    public double perimeter() {
        return 0.5*(x+y+z);
    }

    @Override
    public String toString() {
        return "MyTriangle [x=" + x + ", y=" + y + ", z=" + z + ", area=" + area() + ", perimeter=" + perimeter()
                + "]";
    }
}

⑷、Test类作为主类要完成测试功能

　　①生成MyRectangle对象

　　② 调用对象的toString方法，输出对象的描述信息

public class test {
    public static void main(String[] args) {
        ShapeArea sa;
        sa=new MyRectangle(10, 20.5);
        System.out.println(sa.toString());
        sa=new MyTriangle(3,4,5);
        System.out.println(sa.toString());
    }
}

结果

 

6、定义一个接口CanFly，描述会飞的方法public void fly();

interface CanFly {
    public void fly();
}

分别定义类飞机和鸟，实现CanFly接口。

//飞机类
public class airplane implements CanFly {
    @Override
    public void fly() {
        System.out.println("我是飞机我会飞");
    }
}
//鸟类
public class bird implements CanFly {
    @Override
    public void fly() {
        System.out.println("我是鸟我会飞");
    }
}

定义一个测试类，测试飞机和鸟，在main方法中创建飞机对象和鸟对象，再定义一个makeFly()方法，其中让会飞的事物飞。并在main方法中调用该方法，让飞机和鸟起飞。

public class test {
    public static void main(String[] args) {
        CanFly c1=new airplane();
        CanFly c2=new bird();
        makeFly(c1);
        makeFly(c2);
    }
    private static void makeFly(CanFly c) {
        c.fly();
    }
}

结果