1.
【编号：1001】一位面向对象的程序员小李，在编程过程中需要描述和处理个人信息，于是定义了类Person，如下所示：
public class Person {
private String name;
private int age;
private String birthday;
public String getInfo() {
return "Person[name=" + name + ", age=" + age + ", birthday=" + birthday + "]";
}
}
一周以后，小李又遇到了新的需求，需要描述和处理学生信息，于是他又定义了一个新的类：
public class Student {
private String name;
private int age;
private String birthday;
private String school;
public String getInfo() {
return "Student[name=" + name + ", age=" + age + ", birthday=" + birthday + ", school=" + school + "]";
}
}
观察发现，这两个类的结构太接近了，后者比前者仅多了一个属性，却需要重复定义其他内容。请根据类的继承机制，帮助小李重新设计Student类。并测试获取Student对象的属性信息。
参考答案
public class Student extends Person {
private String school;
public Student() {
}
public Student(String name, int age, String birthday, String school) {
super(name, age, birthday);
this.school = school;
}
public String getInfo() {
return "Student[name=" + getName() + ", age=" + getAge() + ", birthday=" + getBirthday() + ", school=" + school + "]";
}
2.
【编号：1002】请补充下列代码，使测试类编译通过并运行。
已知代码材料
class Fu {
public void methodFu(){
System.out.println("我是父类的method方法");
}
}
class Zi {
}
public class Demo1 {
public static void main(String[] args) {
Zi z = new Zi();
z.methodFu();
z.methodZi();
}
}
运行结果：
我是父类的method方法
我是子类的method方法
参考答案
class Zi extends Fu{
public void methodZi(){
System.out.println("我是子类的method方法");
}
}
3.
【编号：1003】请补充下列代码，使得程序按照顺序分别输出30 20 10。
参考答案
class Fu {
int num = 10;
}
class Zi extends Fu{
int num = 20;
public void method(){
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
4.
请对下列继承代码进行优化和丰富，使得创建子类对象的时候，可以通过有参构造进行初始化，随后通过getXxx方法获取属性并输出。
class Person{
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Student extends Person {
}
public class Demo3 {
public static void main(String[] args) {
Student s = new Student();
s.setName("张三");
s.setAge(23);
}
}
运行结果
张三...23
参考答案
class Person{
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Student extends Person {
public Student() {
}
public Student(String name, int age) {
super(name,age);
}
}
public class Demo3 {
public static void main(String[] args) {
Student s = new Student("张三",23);
System.out.println(getName+getAge);
}
}
5.
某手机系统5版本的时候，引入了【语音助手】的功能，但最开始的【语音助手】只能说英文，后期版本更新到6版本的时候，【语音助手】才能够在说英文的基础上又会说中文，请结合继承的思想，对下列代码进行补充，最终在控制台上输出（speak english）（说中文）
class PhoneVersion5{
public void speak(){
System.out.println("speak english");
}
}
class PhoneVersion6 extends PhoneVersion5 {
}
public class Demo4 {
public static void main(String[] args) {
PhoneVersion6 pv6 = new PhoneVersion6();
pv6.speak();
}
}
运行结果：
speak english
说中文
参考答案
class PhoneVersion5{
public void speak(){
System.out.println("speak english");
}
}
class PhoneVersion6 extends PhoneVersion5 {
@Override
public void speak(){
super.speak();
System.out.println("说中文");
}
}
public class Demo4 {
public static void main(String[] args) {
PhoneVersion6 pv6 = new PhoneVersion6();
pv6.speak();
}
}
6.
分析事物的共性，并抽取出正确的继承体系 现有基础班老师（BaseTeacher）和就业班老师（WorkTeacher）两个类，两者都含有姓名和年龄两个属性，还有一个讲课的行为teach，但不同的是，基础班老师的teach方法输出【基础班老师讲JavaSE】，就业班老师的teach方法输出【就业班老师讲JavaEE】，请用代码实现。 运行结果：
张三老师...23
基础班老师讲JavaSE
李四老师...24
就业班老师讲JavaEE
参考答案
public class teacher {
private String name;
private int age;
public teacher() {
}
public teacher(String name, int age) {
this.name = name;
this.age = age;
}
public void teach(){
}
}
public class WorkTeacher extends teacher {
public WorkTeacher() {
}
public WorkTeacher(String name, int age) {
super(name, age);
}
@Override
public void teach() {
System.out.println("【就业班老师讲JavaEE】");
}
}
public class BaseTeacher extends teacher{
public BaseTeacher() {
}
public BaseTeacher(String name, int age) {
super(name, age);
}
@Override
public void teach() {
System.out.println("【基础班老师讲JavaSE】");
}
}
public class Demo {
public static void main(String[] args) {
BaseTeacher b = new BaseTeacher("张三老师",23);
WorkTeacher w = new WorkTeacher("李四老师",24);
b.teach();
w.teach();
}
}
7.
结合继承的思想，分析下列需求并实现
定义项目经理类Manager 【属性：姓名 工号 工资 奖金】【行为：工作work】
定义程序员类Coder【属性：姓名 工号 工资】【行为：工作work】
要求：通过有参构造创建两个类的对象，并调用各自的work方法
运行结果：
姓名为:张三,工号为:9527,工资为:10000.0,的程序员正在编写代码
姓名为:李四,工号为:9528,工资为:15000.0,奖金为:2000.0,的项目经理正在管理程序员写代码
参考答案
public class staff {
private String name;
private int number;
private int salary;
public staff() {
}
public staff(String name, int number, int salary) {
this.name = name;
this.number = number;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public void work(){
}
}
public class Manager extends staff {
private int bonus;
public Manager() {
}
public Manager(String name, int number, int salary, int bonus) {
super(name, number, salary);
this.bonus = bonus;
}
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
@Override
public void work() {
System.out.println(getName()+",工号为:"+getNumber()+",工资为:"+getSalary()+",奖金为:"+bonus+",的项目经理正在管理程序员写代码");
}
}
public class Coder extends staff {
public Coder() {
}
public Coder(String name, int number, int salary) {
super(name, number, salary);
}
@Override
public void work() {
System.out.println(getName()+",工号为:"+getNumber()+",工资为:"+getSalary()+",的程序员正在编写代码");
}
}
public class Demo {
public static void main(String[] args) {
Manager m = new Manager("张三",110,0,0);
Coder c = new Coder("李四",120,0);
c.work();
m.work();
}
}
8.
某公司骨干程序员设计了一个TestA类，该类包含了公司的核心业务逻辑method方法，现需要将TestA交给其他同事去使用，其他同事可以丰富一些新的方法，但不能改动原有功能（不能改method方法实现内容），如果TestA类交给你来写，怎样可以强制method方法不能改？请结合以上信息，将如下代码补齐。
class TestA {
public void method(){
System.out.println("我是核心业务逻辑，可以使用，但绝对不能改动！");
}
}
class TestB {
}
public class Demo7 {
public static void main(String[] args) {
TestB t = new TestB();
t.method();
t.show();
t.print();
}
}
运行结果：
我是核心业务逻辑，可以使用，但绝对不能改动！
新增加的show方法
新增加的print方法
参考答案
public class Demo {
class TestA {
public final void method(){
System.out.println("我是核心业务逻辑，可以使用，但绝对不能改动！");
}
}
class TestB extends TestA {
public void show(){
System.out.println("我是show方法");
}
public void print(){
System.out.println("我是print方法");
}
}
public class Demo7 {
public static void main(String[] args) {
TestB t = new TestB();
t.method();
t.show();
t.print();
}
}
}
9.
现有两种事物，【手机】和【智能手机】 【手机Phone】带有（属性:品牌brand,价格price）（行为:打电话call,发短信sendMessage,玩游戏playGame） 【智能手机SmartPhone】需要在手机的功能之上，将打电话的功能做进一步增强（视频通话），请结合继承思想来设计两个类，另外，假设所有的手机都有属性屏幕的尺寸(int size)，而且假设所有手机的屏幕尺寸为6，该如何补齐下列代码？
public class Demo8 {
public static void main(String[] args) {
SmartPhone o = new SmartPhone("大米",2000);
System.out.println("品牌：" + ？ + ",价格：" + ？ + ",尺寸：" + ？);
o.call();
o.sendMessage();
}
}
运行结果：
品牌：大米,价格：2000.0,尺寸：6
打电话
视频通话
发短信
参考答案
public class Phone {
private String brand;
private int price;
private final int size=6;
public Phone() {
}
public Phone(String brand, int price) {
this.brand = brand;
this.price = price;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public int getSize() {
return size;
}
public void call(){
System.out.println("打电话");
}
public void sendMessage(){
System.out.println("发短信");
}
public void playGame(){
System.out.println("玩游戏");
}
}
public class SmartPhone extends Phone {
public SmartPhone() {
}
public SmartPhone(String brand, int price) {
super(brand, price);
}
@Override
public void call() {
System.out.println("打开视频模式");
super.call();
}
}
public class Demo {
public static void main(String[] args) {
SmartPhone o = new SmartPhone("大米",2000);
System.out.println("品牌：" + o.getBrand() + ",价格：" + o.getPrice() + ",尺寸：" + o.getSize());
o.call();
o.sendMessage();
}
}
10.
请在main方法中通过多态创建对象，随后使用对象，使得程序符合最终运行结果
public class Demo1 {
public static void main(String[] args) {
}
}
class Fu {
int num = 10;
public void method(){
System.out.println("父类的method方法");
}
}
class Zi extends Fu{
int num = 20;
public void method(){
System.out.println("子类的method方法");
}
public void show(){
System.out.println("子类的show方法");
}
}
运行结果：
10
子类的method方法
子类的show方法
参考答案
Fu f=new Zi ();
System.out.println(f.num);
f.show;
f.mentod;
11.
定义人(Person)类,人类中有吃饭方法（eat）和工作方法（work）。
定义超人（SuperMan）类，超人类中有救人方法（save）并且超人也属于人类。
要求：使用多态的方式创建超人对象，调用吃饭和工作的方法。再将此对象转为超人对象，调用救人的方法。
参考答案
public class Person {
public void eat(){
System.out.println("人类吃饭");
}
public void work(){
System.out.println("人类工作");
}
}
public class SuperMan extends Person{
public void save(){
System.out.println("超人变身");
}
}
public class Demo {
public static void main(String[] args) {
Person p=new SuperMan();
p.eat();
p.work();
SuperMan s=(SuperMan) p;
s.save();
}
}
12.
定义动物类 属性：年龄，颜色 生成空参有参构造，set和get方法 行为：eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,something表示吃的东西)
定义狗类继承动物类，行为：eat(String something)方法,看家lookHome方法(无参数)
定义猫类继承动物类，行为：eat(String something)方法,逮老鼠catchMouse方法(无参数)
定义Person类 生成空参有参构造，set和get方法 属性：（姓名，年龄） 行为：keepPet( ????? ,String something)方法 功能：喂养【宠物狗】和【宠物猫】，问号处自己思考，something表示喂养的东西
定义测试类，使用Perosn对象调用keepPet方法，实现运行结果
运行结果：
年龄为30岁的老王养了一只黑颜色的2岁的宠物
2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
年龄为25岁的老李养了一只灰颜色的3岁的宠物
3岁的灰颜色的猫眯着眼睛侧着头吃鱼
参考答案
package cn.Work1130.homeWork_03;
public abstract class Animal {
private String name;
private int age;
private String color;
public Animal() {
}
public Animal(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public abstract void eat(String something);
}
package cn.Work1130.homeWork_03;
public class Cat extends Animal {
public Cat() {
}
public Cat(String name, int age, String color) {
super(name, age, color);
}
@Override
public void eat(String something) {
System.out.println(getAge()+"岁的"+getColor()+"颜色的猫眯着眼睛侧着头吃"+something);
}
public void catchMouse(){
System.out.println("逮老鼠");
}
}
package cn.Work1130.homeWork_03;
public class Dog extends Animal {
public Dog() {
}
public Dog(String name, int age, String color) {
super(name, age, color);
}
@Override
public void eat(String something) {
System.out.println(getAge()+"岁的"+getColor()+"颜色的狗两只前腿死死的抱住"+something+"猛吃");
}
public void lookHome(){
System.out.println("看门");
}
}
package cn.Work1130.homeWork_03;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void keepPet(Animal animal,String something){
System.out.println("年龄为"+getAge()+"岁的"+getName()+"养了一只"+animal.getColor()+"颜色的"+animal.getAge()+"岁的宠物");
animal.eat(something);
}
}
package cn.Work1130.homeWork_03;
public class Demo {
public static void main(String[] args) {
Person p = new Person("小王",30);
p.keepPet(new Cat("加菲猫",10,"黄"),"");
Person p1 = new Person("老李",25);
p1.keepPet(new Dog("二郎犬",10,"黑"),"");
}
}
13
请对下列代码进行补充，打印出接口中的变量num, 随后调用method方法，要求程序与最终运行结果吻合，（注意：打印num变量，不允许创建对象调用）
public class Demo4 {
public static void main(String[] args) {
}
}
interface Inter {
int num = 10;
void method();
}
参考答案
public class Demo implements Inter {
public static void main(String[] args) {
System.out.println(Inter.num);
new Demo().method();
}
@Override
public void method() {
System.out.println("1");
}
}
interface Inter {
int num = 10;
void method();
}
14.
定义USB接口:（开启功能）（关闭功能）
定义笔记本类:（开机功能）（关机功能）（定义使用USB设备的功能,要求:既能使用鼠标也能使用键盘,使用USB功能内部调用开启和关闭功能）
定义鼠标类:要符合USB接口
定义键盘类:要符合USB接口
定义测试类:创建电脑对象,依次调用开机方法,使用USB设备, 关机方法
运行结果：
笔记本开机
连接鼠标的USB
断开鼠标的USB
连接键盘的USB
断开键盘的USB
笔记本关机
参考答案
package cn.Work1130.hooong_05;
public interface USB {
void open();
void close();
}
package cn.Work1130.hooong_05;
public class Jotter {
public void starting(){
System.out.println("电脑开机");
}
public void shutDown(){
System.out.println("电脑关机");
}
public USB Usb(USB usb){
return usb;
}
}
package cn.Work1130.hooong_05;
public class Keyboard implements USB {
@Override
public void open() {
System.out.println("键盘打开");
}
@Override
public void close() {
System.out.println("键盘关闭");
}
}
package cn.Work1130.hooong_05;
public class Mouse implements USB {
@Override
public void open() {
System.out.println("鼠标打开");
}
@Override
public void close() {
System.out.println("鼠标关闭");
}
}
package cn.Work1130.hooong_05;
public class Demo {
public static void main(String[] args) {
Jotter jotter = new Jotter();
jotter.starting();
USB usb = jotter.Usb(new Mouse());
usb.open();
usb.close();
USB usb1 = jotter.Usb(new Keyboard());
usb1.open();
usb1.close();
jotter.shutDown();
}
}
15.
定义动物类 属性:年龄行为:喝水,吃东西【吃什么不确定】
定义游泳接口: 行为:游泳方法
定义狗类 行为:吃饭(啃骨头)和 游泳(狗刨)
定义羊类: 行为:吃饭(羊啃草)
定义青蛙类: 行为:吃饭(吃虫子)和 游泳(蛙泳)
定义饲养员类: 行为:饲养动物:包括吃饭和喝水
定义测试类: 创建饲养员对象,饲养员调用三次饲养方法:饲养狗,饲养羊,饲养青蛙
要求:
1. 子类重写父类中的吃东西方法
2. 要求给狗和青蛙添加游泳的方法(实现游泳接口)
3. 饲养员类中定义一个方法,传入动物类对象(父类),
4. 调用吃饭方法,如果有游泳方法也需进行测试
运行结果：
喝水
狗啃骨头
狗会狗刨游泳
喝水
青蛙吃小虫
青蛙会蛙泳
喝水
羊啃草
参考答案
package cn.Work1130.homeWork_06;
public interface Swim {
void swin();
}
package cn.Work1130.homeWork_06;
public abstract class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void He(){
System.out.println("喝水");
}
public abstract void eat();
}
package cn.Work1130.homeWork_06;
public class Dog extends Animal implements Swim{
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃米田共");
}
@Override
public void swin() {
System.out.println("狗刨");
}
}
package cn.Work1130.homeWork_06;
public class Sheep extends Animal{
public Sheep() {
}
public Sheep(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("羊吃草");
}
}
package cn.Work1130.homeWork_06;
public class Frog extends Animal implements Swim{
public Frog() {
}
public Frog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("吃虫子");
}
@Override
public void swin() {
System.out.println("仰泳");
}
}
package cn.Work1130.homeWork_06;
public class Feeder {
public Animal feeder(Animal animal){
return animal;
}
}
public class Demo {
public static void main(String[] args) {
Feeder f = new Feeder();
Dog a= (Dog) f.feeder(new Dog("小黑",10));
a.He();
a.eat();
a.swin();
Sheep s=(Sheep)f.feeder(new Sheep("小白",2));
s.He();
s.eat();
Frog F=(Frog) f.feeder(new Frog("小青",4));
F.He();
F.eat();
F.swin();
}
}
