java继承题

1．写一个Java应用程序，主要是体现父类子类间的继承关系。父类：鸟，子类：麻雀、鸵鸟、鹰。子类继承父类的一些特点，如都是鸟的话就都会有翅膀、两条腿等，但它们各自又有各自的特点，如麻雀的年龄、体重；鸵鸟的身高、奔跑速度；鹰的捕食、飞翔高度等。
鸟
package sudy;

public class Bird {
public void niaoxinxi() {
System.out.println("我能飞！");
System.out.println("我有两条腿！");
}

}
麻雀
package sudy;

public class MaQue extends Bird {
private int nianling;
private int tizhong;

public MaQue(int nianling, int tizhong) {
this.nianling = nianling;
this.tizhong = tizhong;
}

public void name() {
System.out.println("我是麻雀！");

}

public void shuchu() {
System.out.println("我的年龄是：" + nianling + "岁");
System.out.println("我的体重是： " + tizhong + "斤");
}

}
鸵鸟
package sudy;

public class TuoNiao extends Bird {
private int shengao;
private int sudu;

public TuoNiao(int shengao, int sudu) {
this.shengao = shengao;
this.sudu = sudu;
}

public void name() {
System.out.println("我是鸵鸟！");
}

public void shuchu() {
System.out.println("我的身高是：" + shengao + "m");
System.out.println("我的速度是：" + sudu + "m/s");
}

}
鹰
package sudy;

public class Ying extends Bird {
private String pushi;
private int flygaodu;

public Ying(String pushi, int flygaodu) {
this.pushi = pushi;
this.flygaodu = flygaodu;
}

public void name() {
System.out.println("我是鹰！");
}

public void shuchu() {
System.out.println("我的扑食方式是：" + pushi);
System.out.println("我的飞行高度是：" + flygaodu + "m");
}

}
测试
package sudy;

public class BirdTxet {

public static void main(String[] args) {
// TODO Auto-generated method stub
MaQue mq = new MaQue(2, 12);
Ying y = new Ying("爪子抓", 300);
TuoNiao tn = new TuoNiao(11, 23);
();
mq.niaoxinxi();
mq.shuchu();
();
mq.niaoxinxi();
y.shuchu();
();
mq.niaoxinxi();
tn.shuchu();
}

}

2．实现一个名为Person的类和它的子类Employee，Employee有两个子类Faculty和Staff。具体要求如下：
（1）Person类中的属性有：姓名name（String类型）、地址address（String类型）、电话号码telephone（String类型）和电子邮件地址email（String类型）。
package sudy;

public class Person {
private String name;
private String address;
private String telephone;
private String email;

public Person() {

}

public Person(String name, String address, String telephone, String email) {
= name;
this.address = address;
this.telephone = telephone;
this.email = email;
}

}

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

类型）和受雇日期hiredate（String类型）。
package sudy;

public class Employee extends Person {
private String office;
private double wage;
private String hiredate;
}

（3）Faculty类中的属性有：学位degree（String类型）、级别level（String类型）。
package sudy;

public class Faculty extends Employee {
private String degree;
private String level;
}

（4）Staff类中的属性有：职务称号duty（String类型）。
package sudy;

public class Staff extends Employee {
private String duty;
}

3．在包a中编写一个类Father，具有属性：年龄（私有）、姓名（公有）；具有功能：工作（公有）、开车（公有）。在包a中编写一个子类Son，具有属性：年龄（受保护的）、姓名；具有功能：玩（私有）、学习（公有）。最后在包b中编写主类Test，在主类的main方法中测试类Father与类Son。
类Father
package a;

public class Father {
private int nianling;
public String name;

public Father(String name, int nianling) {
= name;
this.setNianling(nianling);
}

public void gongneng() {
System.out.println(name + "能开车和工作");
}

public int getNianling() {
return nianling;
}

public void setNianling(int nianling) {
this.nianling = nianling;
}

}
类Son
package a;

public class Son extends Father {
protected int nianling;
private String name;

public Son(String name, int nianling) {
super(name, nianling);
}

@SuppressWarnings("unused")
private void wan() {
System.out.println(name + "能玩！");
}

public void xuexi() {
System.out.println(name + "能学习！");
}

}

Text
package a;

public class Text {

public static void main(String[] args) {
// TODO Auto-generated method stub
Son s = new Son("小张三", 19);
s.gongneng();
s.xuexi();
Father f = new Father("张三", 44);
f.gongneng();
}

}

4．编写一个Car类，具有final类型的属性品牌，具有功能drive；定义其子类Aodi和Benchi，具有属性：价格、型号；具有功能：变速；定义主类E，在其main方法中分别创建Aodi和Benchi的对象，并测试对象的特性。
Car类
package four;

public class Car {
private final String pinpai="";

public void drive(){
System.out.println("正在开车");
}

public String getPinpai() {
return pinpai;
}

}

Aodi类
package four;

public class Aodi extends Car {
private int jiage;
private String xinghao;

public void gongneng() {
System.out.println("变速");
}

public int getJiage() {
return jiage;
}

public void setJiage(int jiage) {
this.jiage = jiage;
}

public String getXinghao() {
return xinghao;
}

public void setXinghao(String xinghao) {
this.xinghao = xinghao;
}

}

Benchi类
package four;

public class Benchi extends Car {
private int jiage;
private String xinghao;

public void gongneng() {
System.out.println("变速");
}

public int getJiage() {
return jiage;
}

public void setJiage(int jiage) {
this.jiage = jiage;
}

public String getXinghao() {
return xinghao;
}

public void setXinghao(String xinghao) {
this.xinghao = xinghao;
}
}

E类
package four;

public class E {

public static void main(String[] args) {
// TODO Auto-generated method stub
Car c=new Car();
c.drive();
Aodi a=new Aodi();
a.setJiage(999990);
a.setXinghao("X5");
System.out.println("Aodi的价格为："+a.getJiage()+" 型号为： "+a.getXinghao());
a.gongneng();
Benchi b=new Benchi();
b.setJiage(845000);
b.setXinghao("B200");
System.out.println("Benchi的价格为："+b.getJiage()+" 型号为： "+b.getXinghao());
b.gongneng();
}

}

5．按要求编写一个Java应用程序：
（1）定义一个矩形类Rect，包含两个protected属性：矩形的宽width和高height。一个带有两个参数的构造方法，用于将width和height属性初始化。一个不带参数的构造方法，将矩形的宽和高都初始化为10。还有两个一般方法：求矩形面积的方法getArea()和求矩形周长的方法getPerimeter()。
public class Rect {
//属性
protected double width;
protected double height;
//方法
//不带参数构造函数
public Rect(){
this.width=10;
this.height=10;
}
//带2个参数构造函数
public Rect(double x, double y){
this.width=x;
this.height=y;
}
//球面积方法
public double getArea(){
return width*height;
}
//求周长方法
public double getPerimeter(){
return 2*(width+height);
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}

}

（2）通过继承Rect类编写一个具有确定位置的矩形类PlainRect，其确定位置用矩形的左上角坐标来标识，有两个属性：矩形左上角坐标startX和startY。两个构造方法：一个是带4个参数的构造方法，用于对startX、startY、width和height属性初始化。一个是不带参数的构造方法，将矩形初始化为左上角坐标、长和宽都为0的矩形。
添加一个方法：判断某个点是否在矩形内部的方法isInside(doublex,double y)。如在矩形内，返回true, 否则，返回false。提示：点在矩形内是指满足条件x >= startX && x <= (startX + width) && y >=(startY - height) && y <= startY

package lession12;
/*（2）通过继承Rect类编写一个具有确定位置的矩形类PlainRect，其确定位置用矩形的左上角坐标来标识，有两个属性
：矩形左上角坐标startX和startY。两个构造方法：一个是带4个参数的构造方法，用于对startX、startY、
width和height属性初始化。一个是不带参数

的构造方法，将矩形初始化为左上角坐标、长和宽都为0的矩形。
添加一个方法：判断某个点是否在矩形内部的方法isInside(doublex,double y)。如在矩形内，返回true,
否则，返回false。提示：
点在矩形内是指满足条件x >= startX && x <= (startX + width) && y >=(startY - height) && y <= startY
*/
public class PlainRect extends Rect {

private double startX;
private double startY;


public PlainRect(){
super(0,0);
this.startX=0;
this.startY=0;
}
public PlainRect(double startX,double startY,double x, double y){
super(x,y);
this.startX=startX;
this.startY=startY;
}

public boolean isInside(double x,double y){
if(x >= startX && x <= (startX + width) && y >=(startY - height) && y <= startY){
return true;
}else{
return false;
}
}
}

（3）编写PlainRect类的测试程序，创建一个左上角坐标为（10，10），长为20，宽为10的矩形对象；计算并打印输出矩形的面积和周长；判断点(25.5，13)是否在);


package lession12;

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
PlainRect pr = new PlainRect(10,10,20,10);
System.out.println("面积"+pr.getArea());
System.out.println("周长"+pr.getPerimeter());
if(pr.isInside(25.5, 13)){
System.out.println("输出点在矩形内！");
}else{
System.out.println("输出点不在矩形内！");
}
}

}



6．按要求编写一个Java应用程序：
（1）定义一个类，描述一个矩形，包含有长、宽两种属性和计算面积方法。
package six;

public class JuXing {
public int width;
public int wide;

public JuXing(int width, int wide) {
this.width = width;
this.wide = wide;
}

public void s() {
int s = width * wide;
System.out.println("该矩形的面积为：" + s);
}

}

（2）编写一个类，继承自矩形类，同时该类描述长方体，具有长、宽、高属性和计算体积的方法。
package six;

public class ChangFangTi extends JuXing {
public int height;

public ChangFangTi(int width, int wide, int height) {
super(width, wide);
this.height = height;
}

public void v() {
int v = wide * width * height;
System.out.println("该长方体的体积为：" + v);
}
}

（3）编写一个测试类，对以上两个类进行测试，创建一个长方体，定义其长、宽、高，输出其底面积和体积。
package six;

public class Text {

public static void main(String[] args) {
// TODO Auto-generated method stub
ChangFangTi cft = new ChangFangTi(5, 5, 5);
cft.s();
cft.v();
}

}

7．编写一个类A，该类创建的对象可以调用方法f输出小写的英文字母表。然后再编写一个A类的子类B，要求子类B必须继承A类的方法f（不允许重写），子类B创建的对象不仅可以调用方法f输出小写的英文字母

表，而且可以调用子类新增的方法g输出大写的英文字母表。最后编写主类C，在主类的main方法中测试类A与类B。

A类
package seven;

public class A {

public void f() {
System.out.print("小写英文字母表： ");
for (char i = 'a'; i <= 'z'; i++) {
System.out.print(i + " ");
}
}
}
B类
package seven;

public class B extends A {
public void g(){
System.out.print("大写英文字母表： ");
for (char i = 'A'; i <= 'Z'; i++) {
System.out.print(i + " ");
}
}
}

C类
package seven;

public class C {

public static void main(String[] args) {
// TODO Auto-generated method stub
A a = new A();
a.f();
System.out.println();
B b = new B();
b.g();
System.out.println();
b.f();

}

}

8．编写一个Java应用程序，该程序包括3个类：Monkey、People类和主类E。要求：
（1）Monkey中有个构造方法：Monkey (String s)，并且有个public void speak()方法，在speak方法中输出“咿咿呀呀……”的信息。
package eight;

public class Monkey {
public Monkey(String s) {

}

public void speak() {
System.out.println("咿咿呀呀……");
}

}

（2）People是Monkey的子类，在People类中重写父类的方法speak(),在speak方法中输出“别说话！”的信息。
（3）在People类中新增方法void think()，在think方法中输出“认真思考！”。
package eight;

public class People extends Monkey {

public void speak() {
System.out.println("别说话！");
}

public void think() {
System.out.println("认真思考！");
}

public People(String s) {
super(s);

}

}



（4）在主类E的main方法中创建Monkey与People的对象来测试这两个类的功能。
package eight;

public class E {

public static void main(String[] args) {
// TODO Auto-generated method stub
Monkey m=new Monkey("hello");
People p=new People("你好");
m.speak();
p.speak();
p.think();

}

}

9．编写一个Java应用程序，设计一个汽车类Vehicle，包含的属性有车轮个数wheels和车重weight。小车类Car是Vehicle的子类，其中包含的属性有载人数loader。卡车类Truck是Car类的子类，其中包含的属性有载重量payload。每个类都有构造方法和输出相关数据的方法。最后，写一个测试类来测试这些类的功能。
汽车类Vehicle
package nine;

public class Vehicle {
public int wheels;
public int weight;

public Vehicle(int wheels, int weight) {
this.wheels = wheels;
this.weight = weight;
}

public void shuchu1() {
System.out.println("车轮个数：" + wheels + "个 车重：" + weight + "吨");
}

}

小车类Car
package nine;

public class Car extends Vehicle {
public int loader;

public Car(int wheels, int weight, int loader) {
super(wheels, weight);
this.loader = loader;
}

public void shuchu2() {
Syst

em.out.println("haha");
}

}

卡车类Truck
package nine;

public class Truck extends Car {
public int payload;

public Truck(int wheels, int weight, int loader, int payload) {
super(wheels, weight, loader);
this.payload = payload;
}

public void shuchu3() {
System.out.println("车轮个数：" + wheels + "个 车重：" + weight + "吨"
+ " 承载人数：" + loader + "人 车载重量： " + payload + "吨");
}
}
测试类
package nine;

public class Text {
public static void main(String[] args) {
// TODO Auto-generated method stub
Truck t = new Truck(4, 20, 6, 80);
t.shuchu3();
}
}

10．编写一个Shape类，具有属性：周长和面积；定义其子类三角形和矩形，分别具有求周长的方法。定义主类E，在其main方法中创建三角形和矩形类的对象，并赋给Shape类的对象a、b，使用对象a、b来测试其特性。
Shape类
package ten;

public class Shape {
private double mianji;
private double zhouchang;

public Shape(){

}
public Shape(double mianji,double zhouchang){
this.setMianji(mianji);
this.setZhouchang(zhouchang);
}



public double getZhouchang() {
return zhouchang;
}
public void setZhouchang(double zhouchang) {
this.zhouchang = zhouchang;
}
public double getMianji() {
return mianji;
}
public void setMianji(double mianji) {
this.mianji = mianji;
}
}
JuXing 类
package ten;

public class JuXing extends Shape {
private double a;
private double b;

public JuXing(double a,double b){
this.a=a;
this.b=b;
}

public void zhouchang(){
System.out.println("矩形都周长为："+(a+b)*2);
}

}
SanJiao 类
package ten;

public class SanJiao extends Shape {
private double a;
private double b;
private double c;

public SanJiao(double a, double b, double c) {

this.a = a;
this.b = b;
this.c = c;
}

public void zhouchang() {
if (a + b > c && Math.abs(a - b) < c) {

System.out.println("三角形的周长为：" + (a + b + c));

} else {
System.out.println("这不是三角形");

}
}

}
E类
package ten;

public class E {

public static void main(String[] args) {
// TODO Auto-generated method stub
JuXing jx=new JuXing(2.5, 8.1);
jx.zhouchang();

SanJiao sj=new SanJiao(3, 4, 5);
sj.zhouchang();

}

}



11．编写一个Java应用程序，该程序包括3个类： A类、B类和主类E。其中类B是类A的子类，在子类B中新增了成员变量和成员方法，并且隐藏了父类A的成员变量和重写了父类A的成员方法。在主类E的main方法中，创建类B的对象并赋给父类A的对象a，使用上转型对象a来测试上转型对象的一些特性。
A类
package sudy;

public class A {
public void shuchua(){
System.out.println("这是A类");
}
}

B类
package sudy;

public class B extends A {
public void shuchuB(){
System.o

ut.println("这是B类");
}
}

E类
package sudy;

public class E {

public static void main(String[] args) {
// TODO Auto-generated method stub
A a=new B();
a.shuchua();


}

}