JavaSE第8天练习题（面向对象三，final,static,abstract,接口）
文章目录
- 一、 基础案例
- 1． 训练案例1
- 2． 训练案例2
- 3． 训练案例3
- 4． 训练案例4
- 5． 训练案例5
- 6． 训练案例6
- 二、 扩展案例
- 1． 训练案例1
- 2． 训练案例2
- 3． 训练案例3
- 4． 训练案例4
一、 基础案例
1． 训练案例1
1.1． 训练描述：【final关键字特点】
一、 需求说明：定义子父类，父类如果被final修饰，测试子类能否继承父类。
二、 再定义普通的子父类，父类中有方法被final所修饰，测试子类能否重写该方法。
三、 定义一个类，该类中有final修饰的变量，并对其进行初始化，在该类中定义一个普通方法，测试这个变量值能否修改。
1.2． 操作步骤描述
-
创建Father类，该类被final修饰
-
创建Son类，并继承Father类，查看编译结果 （不能继承）
-
将上述内容注释掉，接下来，定义普通的子父类关系
-
在父类中定义被final所修饰的method方法，方法中打印内容为method father
-
子类中重写父类中method方法，打印内容为method son，查看编译结果 （不能重新）
-
在该子类中定义一个成员变量age，初始化值为10，对该成员变量用final所修饰
-
在该子类中定义show方法，在方法中，将age值改为20，并打印age值
（show输出20）
public class Son extends Father{
final int age = 10;
public void show(){
int age = 20;
System.out.println(age);
}
}
2． 训练案例2
2.1． 训练描述：【static关键字特点】
一、 需求说明：定义学生类，学生类有三个属性：name、age、graduateFrom（此属性用static修饰），该类中有成员show方法，方法中打印三个成员变量的值。
二、 在测试类中创建该学生对象，为对象中的成员变量赋值，并调用show方法。
三、 在测试类中再次创建学生对象，为对象中的成员变量赋值，并调用show方法。
四、 发现问题，每次创建学生对象都需要给学生的毕业院校属性进行赋值，那么当学生的毕业院校都属于同一所学校时，这样每次创建对象都需要重新赋值很不方便，故而，将该属性graduateFrom新增static所修饰，让这个成员变量被所有对象所共享。
2.2． 操作步骤描述
- 定义学生类，学生类有三个属性：name、age、graduateFrom，该类中有成员show方法，方法中打印三个成员变量的值
- 在测试类中创建该学生对象，为对象中的成员变量赋值，并调用show方法。
- 在测试类中再次创建学生对象，为对象中的成员变量赋值，并调用show方法。
- 发现问题，每次创建学生对象都需要给学生的毕业院校属性进行赋值，那么当学生的毕业院校都属于同一所学校时，这样每次创建对象都需要重新赋值很不方便，故而，将该属性graduateFrom新增static所修饰，让这个成员变量被所有对象所共享。
- 在测试类中创建两次学生对象，第一次创建学生对象时，给对象中的属性赋值，并调用show方法，第二次创建学生对象时，只给对象中的name、age属性赋值，调用show方法。
- 发现第二个学生对象调用show方法时，打印的学生信息中发现，该学生的毕业院校和第一个学生对象一致，从而证明被static所修饰的成员被该类的所有对象所共享。
- 在第一次创建学生对象时，给该学生的静态变量graduateFrom赋值时，发现有黄色警告，说明该成员如果被静态所修饰，应该用类名直接调用，故而在创建对象之前先用类名调用成员
public class Student {
private String name;
private int age ;
private static String graduateFrom = "清华大学";
public void show(){
System.out.println("姓名："+name+"年龄："+age+"毕业学校："+graduateFrom);
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
//this.graduateFrom = graduateFrom;
}
}
public class Main02 {
public static void main(String[] args) {
Student s = new Student("小明",24);
Student s2 = new Student("小花",24);
s.show();
s2.show();
}
}
//输出结果
//姓名：小明年龄：24毕业学校：清华大学
//姓名：小花年龄：24毕业学校：清华大学
3． 训练案例3
3.1． 训练描述：【static方法的访问特点】
一、 需求说明：定义学生类，类中有静态成员变量和非静态成员变量，有两个非静态成员方法show()、show2()和两个静态成员方法show3()、show4()
二、 在学生类中演示静态方法能否访问静态成员及非静态成员，在非静态方法能否访问非静态成员及静态成员，并在静态中演示能否与this、super连用。
3.2． 操作步骤描述
- 定义学生类，学生类有静态属性age，初始值为30。非静态属性name，初始值为林青霞
- 在该类中定义非静态方法show()、show2()，再定义静态方法show3()、show4()
- 在show2()方法与show4()方法中，方法体不需要写内容。
- 在非静态方法show()中打印name和age值，调用show2()、show4()方法，并用this调用成员变量为其赋值。
- 在静态方法show3()中打印name和age值，调用show2()、show4()方法，并用this调用成员变量为其赋值
public class Student {
private String name = "林青霞";
private static int age = 30;
public void show(){
System.out.println("姓名："+name+" 年龄："+age);
show2();
show4();
}
public void show2() {
this.name = name;
this.age = age;
}
public static void show3() {
//System.out.println("姓名："+name);静态方法无法调用非静态成员变量
System.out.println("年龄："+age);
//show2();静态方法无法调用非静态方法
show4();
}
public static void show4() {
}
}
4． 训练案例4
4.1． 训练描述：【抽象类】
一、 需求说明：定义抽象类Animal，该类中有抽象方法和非抽象方法，分别演示其子类是抽象类与具体类的情况
4.2． 操作步骤描述
- 定义抽象类Animal，其内有抽象方法eat()，与非抽象方法sleep()，该方法体内容为打印语句，打印“睡觉”。
- 定义Dog类，继承Animal类，不重写Animal类中任何方法
- 定义Cat类，继承Animal类，重写Animal类中eat方法，方法中打印“猫吃鱼”。
- 定义测试类AnimalDemo，在测试类中创建Animal对象。
- 在测试类中使用多态形式创建Cat对象，并调用eat方法与sleep方法。
public abstract class Animal {
public abstract void eat();
public void sleep(){
System.out.println("睡觉~~");
}
}
public abstract class Dog extends Animal{
}
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
public class AnimalDemo {
public static void main(String[] args) {
Animal c = new Cat();
c.eat();
c.sleep();
}
}
5． 训练案例5
5.1． 训练描述：【抽象类】
一、 需求说明：抽象类的老师案例，具体事物：基础班老师，就业班老师；
5.2． 操作步骤描述
- 基础班老师：成员变量：name、age，构造方法：无参、有参，成员方法：getXxx()、setXxx()、teach(){}。
- 就业班老师：成员变量：name、age，构造方法：无参、有参，成员方法：getXxx()、setXxx()、teach(){}。
- 抽象类老师：成员变量：name、age，构造方法：无参、有参，成员方法：getXxx()、setXxx()、teach()。
public abstract class Teacher {
private String name;
private int age ;
public abstract void teach();
public Teacher() {
super();
}
public Teacher(String name, int age) {
super();
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 class BaseTeacher extends Teacher{
public BaseTeacher() {
super();
}
public BaseTeacher(String name, int age) {
super(name, age);
}
@Override
public void teach(){
System.out.println("教基础班");
}
}
public class JobTeacher extends Teacher{
public JobTeacher() {
super();
}
public JobTeacher(String name, int age) {
super(name, age);
}
@Override
public void teach(){
System.out.println("教就业班");
}
}
public class Main05 {
public static void main(String[] args) {
Teacher b = new BaseTeacher("李老师",36);
System.out.println(b.getName()+"今年岁数："+b.getAge());
b.teach();
System.out.println();
Teacher j = new JobTeacher("陈老师",55);
System.out.println(j.getName()+"今年岁数："+j.getAge());
b.teach();
}
}
6． 训练案例6
6.1． 训练描述：【接口】
一、 需求说明：让所有的猫具备跳高的额外功能
6.2． 操作步骤描述
- 定义跳高接口Jumpping，该接口中有一个抽象跳高方法jump()。
- 定义抽象类Animal，该类中有属性姓名name、年龄age，还有一个抽象吃饭eat()方法。
- 定义猫类Cat，该类继承Animal，并实现跳高接口，重写抽象类中eat()方法与接口中的跳高jump()方法。
- 定义测试类InterfaceTest，在测试类中，创建猫对象，给对象成员变量赋值，最后调用猫的吃饭和跳高方法。
public abstract class Animal {
private String name;
private int age;
public abstract void eat();
public Animal() {
super();
}
public Animal(String name, int age) {
super();
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 interface Jumpping {
public void jump();
}
public class Cat extends Animal implements Jumpping{
@Override
public void eat() {
System.out.println("猫爱吃鱼");
}
@Override
public void jump() {
System.out.println("猫会跳");
}
public Cat() {
super();
}
public Cat(String name, int age) {
super(name, age);
}
}
public class Main06 {
public static void main(String[] args) {
Cat c = new Cat("tom",8);
System.out.println(c.getName()+"今年年龄："+c.getAge());
c.eat();
c.jump();
System.out.println("------------------");
Animal b = new Cat("ddm",2);
System.out.println(b.getName()+"今年年龄："+b.getAge());
b.eat();
//b.jump(); 报错，Animal 没有jump方法
}
}
二、 扩展案例
1． 训练案例1
1.1． 训练描述：
一、 分析以下需求，并用代码实现：
1.定义项目经理类
属性：
姓名 工号 工资 奖金
行为：
工作work
2.定义程序员类
属性：
姓名 工号 工资
行为：
工作work
要求:向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
编写测试类:完成这两个类的测试
1.2． 操作步骤描述
- 定义抽象雇员类Employee，该类中有属性：姓名name，工号id，工资salary，抽象方法：工作work()。
- 定义项目经理类Manager，该类继承雇员类，重写父类中抽象方法work(){}。
- 定义程序员类Programmer,该类继承雇员类，重写父类中抽象方法work(){}。
- 定义测试类Test，创建项目经理对象与程序员对象，为对象属性进行初始化，并调用工作方法。
public abstract class Employee {
private String name;
private String id ;
private int salary;
public abstract void work();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public Employee(String name, String id, int salary) {
super();
this.name = name;
this.id = id;
this.salary = salary;
}
public Employee() {
super();
}
}
public class Manager extends Employee {
@Override
public void work() {
System.out.println("经理管理员工");
}
public Manager() {
super();
}
public Manager(String name, String id, int salary) {
super(name, id, salary);
}
}
public class Programmer extends Employee{
@Override
public void work() {
System.out.println("程序员敲代码");
}
public Programmer() {
super();
}
public Programmer(String name, String id, int salary) {
super(name, id, salary);
}
}
public class Main11 {
public static void main(String[] args) {
Employee m = new Manager("杨大人","gh1234",56);
System.out.println(m.getName()+"的工号："+m.getId()+"，工资："+m.getSalary());
m.work();
System.out.println("--------------");
Employee q = new Programmer("小陈","gh18434",40);
System.out.println(q.getName()+"的工号："+q.getId()+"，年龄："+q.getSalary());
q.work();
System.out.println("--------------");
}
}
2． 训练案例2
2.1． 训练描述：
分析以下需求，并用代码实现
1.定义手机类
行为:
打电话,发短信
2.定义接口IPlay
行为:
玩游戏
3.定义旧手机类继承手机类
行为:
继承父类的行为
4.定义新手机继承手机类实现IPlay接口
行为:继承父类的行为,重写玩游戏方法
5.定义测试类
在测试类中定义一个 用手机的方法,要求该方法既能接收老手机对象,也能接收新手机对象
在该方法内部调用打电话,发短信以及新手机特有的玩游戏方法
public class Phone {
public void call(){
System.out.println("跟范冰冰打电话");
}
public void send(){
System.out.println("跟范冰冰发短信");
}
public Phone() {
super();
}
}
public interface IPlay{
public void game();
}
public class Ophone extends Phone{
public Ophone() {
super();
}
}
public class Nphone extends Phone implements IPlay{
@Override
public void game() {
System.out.println("玩植物大战僵尸");
}
}
public class Main12 {
public static void main(String[] args) {
Nphone n = new Nphone();
n.call();
n.send();
n.game();
}
}
3． 训练案例3
3.1． 训练描述：
分析以下需求,并用代码实现：
1.定义动物类：
行为：
吼叫；没有具体的吼叫行为
吃饭:没有具体的吃饭行为
2.定义缉毒接口
行为:
缉毒
3.定义缉毒狗:犬的一种
行为：
吼叫:汪汪叫
吃饭:狗啃骨头
缉毒:用鼻子侦测毒
4.定义测试类:
使用多态的形式创建缉毒狗对象,调用缉毒方法和吼叫方法
public abstract class Animal {
public abstract void cry();
public abstract void eat();
}
public interface Drug {
public void drug();
}
public class Dog extends Animal implements Drug{
@Override
public void drug() {
System.out.println("用鼻子侦测毒");
}
@Override
public void cry() {
System.out.println("汪汪叫");
}
@Override
public void eat() {
System.out.println("狗啃骨");
}
}
public class Main13 {
public static void main(String[] args) {
Animal d = new Dog();
d.cry();
d.eat();
Dog k = (Dog)d;
k.drug();
}
}
4． 训练案例4
1.1． 训练描述：
分析以下需求,并用代码实现：
1.定义动物类
属性：
年龄，颜色
行为:
eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,something表示吃的东西)
生成空参有参构造，set和get方法
2.定义狗类继承动物类
行为:
eat(String something)方法,看家lookHome方法(无参数)
3.定义猫类继承动物类
行为:eat(String something)方法,逮老鼠catchMouse方法(无参数)
4.定义Person类
属性：
姓名，年龄
行为：
keepPet(Dog dog,String something)方法
功能：喂养宠物狗，something表示喂养的东西
行为：
keepPet(Cat cat,String something)方法
功能：喂养宠物猫，something表示喂养的东西
生成空参有参构造，set和get方法
5.定义测试类(完成以下打印效果):
keepPet(Dog dog,String somethind)方法打印内容如下：
年龄为30岁的老王养了一只黑颜色的2岁的宠物
2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
keepPet(Cat cat,String somethind)方法打印内容如下：
年龄为25岁的老李养了一只灰颜色的3岁的宠物
3岁的灰颜色的猫眯着眼睛侧着头吃鱼
public abstract class Animal {
private int age;
private String color;
public abstract void eat(String something);
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 Animal() {
super();
}
public Animal(int age, String color) {
super();
this.age = age;
this.color = color;
}
}
public class Dog extends Animal{
@Override
public void eat(String something) {
// TODO Auto-generated method stub
}
public void lookHome(){
System.out.println("狗狗会看家");
}
public Dog() {
super();
// TODO Auto-generated constructor stub
}
public Dog(int age, String color) {
super(age, color);
// TODO Auto-generated constructor stub
}
}
public class Cat extends Animal{
@Override
public void eat(String something) {
}
public void catchMouse(){
System.out.println("猫会抓老鼠");
}
public Cat() {
super();
}
public Cat(int age, String color) {
super(age, color);
}
}
public class Person {
private String name;
private int page;
public void keepPet(Dog dog,String something) {
System.out.println("年龄为"+page+"岁的"+name+"养了一只"+dog.getColor()+dog.getAge()+"岁的宠物");
System.out.println(dog.getAge()+"岁的"+dog.getColor()+"狗两只前腿死死的抱住"+something+"猛吃");
}
public void keepPet(Cat cat,String something) {
System.out.println("年龄为"+page+name+"养了一只"+cat.getColor()+cat.getAge()+"岁的宠物");
System.out.println(cat.getAge()+"岁的"+cat.getColor()+"猫眯着眼睛侧着头吃"+something);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPage() {
return page;
}
public void setPage(int page) {
this.page = page;
}
public Person() {
super();
}
public Person(String name, int page) {
super();
this.name = name;
this.page = page;
}
}
public class Main14 {
public static void main(String[] args) {
Person w = new Person("老王",30);
Dog dog = new Dog();
dog.setAge(2);
dog.setColor("黑颜色的");
w.keepPet(dog, "骨头");
System.out.println("");
Person li = new Person("老李",25);
Cat cat = new Cat(3,"灰颜色的");
li.keepPet(cat, "鱼");
}
}