实验3 继承与多态
**类可以实现多个接口 但只有单继承！**
1、继承
1)、继承语法
class 子类名 extends 父类{
}
2)、构造函数(通过source即可得到)
注意： 当子类实例化，首先调用父类构造函数，其次调用子类本身构造函数
3)、函数重载:
简单来说 相同函数名 参数需求不同 在调用时自动寻找匹配的函数
4)、覆盖问题override
子类重写了一个从父类继承过来的函数与属性
---当使用时就直接使用子类函数
直接alt加 / 键就可重写
2、final（用此定义的属性 为常量）
1)、final定义的方法可继承，但不可override！
2)、fianl定义的类不可派生子类（不可继承），但能生成对象
3)、final变量对于对象实例a，不可修改指针（×b=a），但可修改实例的内部值（a.heigtht可修改）
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 抽象类有部分方法可实现
2 接口所有方法都不可实现
3 接口继承多个接口，抽象类只能继承一个抽象类
4 抽象类有构造函数 接口没有
5 抽象类中可有main函数运行 接口不行
6 抽象类成员 private，public，protected
7 接口成员只能是public
实践编程
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();
}
}
结果
