java_day8练习题

最新推荐文章于 2026-01-07 14:25:07 发布

原创最新推荐文章于 2026-01-07 14:25:07 发布 · 579 阅读

4 ·

本内容遵循CC 4.0 BY-SA版权协议

本文是关于Java基础的第8天学习内容，包含十道练习题，覆盖了不同难度和知识点，旨在巩固和提升Java编程技能。

文章目录

Java基础第8天练习题

Java基础第8天练习题

练习1

一、需求说明：定义子父类，父类如果被final修饰，测试子类能否继承父类。
二、再定义普通的子父类，父类中有方法被final所修饰，测试子类能否重写该方法。
三、定义一个类，该类中有final修饰的变量，并对其进行初始化，在该类中定义一个普通方法，测试这个变量值能否修改。

1.2．操作步骤描述
1.创建Father类，该类被final修饰。
2.创建Son类，并继承Father类，查看编译结果。
3.将上述内容注释掉，接下来，定义普通的子父类关系。
4.在父类中定义被final所修饰的method方法，方法中打印内容为method father
5.子类中重写父类中method方法，打印内容为method son，查看编译结果。
6.在该子类中定义一个成员变量age，初始化值为10，对该成员变量用final所修饰。
7.在该子类中定义show方法，在方法中，将age值改为20，并打印age值。

package com.scy.day8;

public final class Father {
}

package com.scy.day8;

public class son extends Father {
}

结果：Error:(3, 26) java: 无法从最终com.scy.day8.Father进行继承

package com.scy08;

public  class Father {
    public Father(){}

    public final void method(){
        System.out.println("method father");
    }
}

package com.scy08;

public class Son extends Father {
    public Son (){}

    @Override
    public final void method(){
        System.out.println("method son");
    }
}

java: com.scy08.Son中的method()无法覆盖
com.scy08.Father中的method()
 被覆盖的方法为final

package com.scy08;

public class Son extends Father {
    public final int age =10;
    public Son (){}
    @Override
    public  void method(){
        System.out.println("method son");
    }
    public void show(){
        this.age = 20;
        System.out.println(age);
    }
}

package com.scy08;
public class Test {
    public static void main(String[] args) {
        Son s = new Son();
        s.show();
    }
}

Error:(14, 13) java: 无法为最终变量age分配值

练习2

一、需求说明：定义学生类，学生类有三个属性：name、age、graduateFrom（此属性用static修饰），该类中有成员show方法，方法中打印三个成员变量的值。
二、在测试类中创建该学生对象，为对象中的成员变量赋值，并调用show方法。
三、在测试类中再次创建学生对象，为对象中的成员变量赋值，并调用show方法。
四、发现问题，每次创建学生对象都需要给学生的毕业院校属性进行赋值，那么当学生的毕业院校都属于同一所学校时，这样每次创建对象都需要重新赋值很不方便，故而，将该属性graduateFrom新增static所修饰，让这个成员变量被所有对象所共享。
2.2．操作步骤描述
1.定义学生类，学生类有三个属性：name、age、graduateFrom，该类中有成员show方法，方法中打印三个成员变量的值
2.在测试类中创建该学生对象，为对象中的成员变量赋值，并调用show方法。
3.在测试类中再次创建学生对象，为对象中的成员变量赋值，并调用show方法。
4.发现问题，每次创建学生对象都需要给学生的毕业院校属性进行赋值，那么当学生的毕业院校都属于同一所学校时，这样每次创建对象都需要重新赋值很不方便，故而，将该属性graduateFrom新增static所修饰，让这个成员变量被所有对象所共享。
5.在测试类中创建两次学生对象，第一次创建学生对象时，给对象中的属性赋值，并调用show方法，第二次创建学生对象时，只给对象中的name、age属性赋值，调用show方法。
6.发现第二个学生对象调用show方法时，打印的学生信息中发现，该学生的毕业院校和第一个学生对象一致，从而证明被static所修饰的成员被该类的所有对象所共享。
7.在第一次创建学生对象时，给该学生的静态变量graduateFrom赋值时，发现有黄色警告，说明该成员如果被静态所修饰，应该用类名直接调用，故而在创建对象之前先用类名调用成员

package com.scy08;	//Student类

public class Student {
    public String name;
    public int age;
    public static String graduateFrom;

    public void show(){
        System.out.println(name+age+graduateFrom);
    }
}

package com.scy08;

public class Test {
    public static void main(String[] args) {
        Student.graduateFrom = "南京大学";

        Student s = new Student();
        s.name  = "wang";
        s.age = 52;
        s.show();
        System.out.println("----------------");
        Student.graduateFrom = "北京大学";

        Student s1 = new Student();
        s1.name = "li";
        s1.age = 30;
        s1.show();
    }
}

结果：
wang52南京大学
----------------
li30北京大学

练习3

3.1．训练描述：【static方法的访问特点】
一、需求说明：定义学生类，类中有静态成员变量和非静态成员变量，有两个非静态成员方法show()、show2()和两个静态成员方法show3()、show4()
二、在学生类中演示静态方法能否访问静态成员及非静态成员，在非静态方法能否访问非静态成员及静态成员，并在静态中演示能否与this、super连用。

3.2．操作步骤描述
1.定义学生类，学生类有静态属性age，初始值为30。非静态属性name，初始值为林青霞
2.在该类中定义非静态方法show()、show2()，再定义静态方法show3()、show4()
3.在show2()方法与show4()方法中，方法体不需要写内容。
4.在非静态方法show()中打印name和age值，调用show2()、show4()方法，并用this调用成员变量为其赋值。
5.在静态方法show3()中打印name和age值，调用show2()、show4()方法，并用this调用成员变量为其赋值

package com.scy08;

    public class Student {
        public String name="林青霞";
        public static int age=30;
        public void show1(){
            System.out.println(name+age);
            show2();
            show4();
            this.name = "王力宏";
            this.age = 10;
            System.out.println(name+age);
        }
        public void show2(){
        }
        public static void show3(){
            System.out.println(name+age);
            show2();
            show4();
            this.name = "王力宏";
            this.age = 10;
        }
        public static void show4(){
        }
    }

package com.scy08;
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.show1();
    }
}
结果：林青霞30
	 王力宏10

package com.scy08;
public class Test {
    public static void main(String[] args) {
        Student s2 = new Student();
        s2.show2();
    }
}
结果：
	java: 无法从静态上下文中引用非静态 方法 show2()
	java: 无法从静态上下文中引用非静态 变量 name
	java: 无法从静态上下文中引用非静态 变量 this
	java: 无法从静态上下文中引用非静态 变量 this

总结：静态方法只能只能使用静态方法；
	 并且无法使用this.super.关键字，
	 因为静态方法在生成对象前就被执行
	 非静态方法可以使用静态方法也可以使用非静态方法

练习4

一、需求说明：定义抽象类Animal，该类中有抽象方法和非抽象方法，
			分别演示其子类是抽象类与具体类的情况

4.2．操作步骤描述
1.定义抽象类Animal，其内有抽象方法eat()，与非抽象方法sleep()，该方法体内容为打印语句，打印“睡觉”。
2.定义Dog类，继承Animal类，不重写Animal类中任何方法
3.定义Cat类，继承Animal类，重写Animal类中eat方法，方法中打印“猫吃鱼”。
4.定义测试类AnimalDemo，在测试类中创建Animal对象。
5.在测试类中使用多态形式创建Cat对象，并调用eat方法与sleep方法。

package com.scy08;

public abstract class Animal {
    public abstract void eat();

    public void sleep(){
        System.out.println("睡觉");
    }
}

package com.scy08;

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package com.scy08;

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Animal();
    }
}
结果：java: com.scy08.Animal是抽象的; 无法实例化

package com.scy08;

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
}
结果：猫吃鱼
	 睡觉

练习5

5.1．训练描述：【抽象类】
一、需求说明：抽象类的老师案例，具体事物：基础班老师，就业班老师；具体事物：基础班老师，就业班老师
5.2．操作步骤描述
1.基础班老师：成员变量：name、age，构造方法：无参、有参，成员方法：getXxx()、setXxx()、teach(){}。
2.就业班老师：成员变量：name、age，构造方法：无参、有参，成员方法：getXxx()、setXxx()、teach(){}。
3.抽象类老师：成员变量：name、age，构造方法：无参、有参，成员方法：getXxx()、setXxx()、teach()。

package com.scy08;	//父类老师类

public abstract class Teacher  {
    private String name;
    private int age;
    public Teacher(){}
    public Teacher(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 abstract void teach();
}

package com.scy08;	//基础班老师

public class BasicTeacher extends Teacher {
    public BasicTeacher(){}
    public BasicTeacher(String name,int age){
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("基础班老师教基础");
    }
}

package com.scy08;	//就业班老师

public class WorkTeacher extends Teacher {
    public WorkTeacher(){}
    public WorkTeacher(String name,int age){
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("就业班老师教提高");
    }
}

package com.scy08;

public class Test {
    public static void main(String[] args) {
        BasicTeacher b1 = new BasicTeacher();
        b1.teach();
    }
}
结果：基础班老师教基础

练习6

6.1．训练描述：【接口】
一、需求说明：让所有的猫具备跳高的额外功能
6.2．操作步骤描述
1.定义跳高接口Jumpping，该接口中有一个抽象跳高方法jump()。
2.定义抽象类Animal，该类中有属性姓名name、年龄age，还有一个抽象吃饭eat()方法。
3.定义猫类Cat，该类继承Animal，并实现跳高接口，重写抽象类中eat()方法与接口中的跳高jump()方法。
4.定义测试类InterfaceTest，在测试类中，创建猫对象，给对象成员变量赋值，最后调用猫的吃饭和跳高方法。

package com.scy08;	// 抽象父类  Animal

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 abstract void eat();
}

package com.scy08;

public interface Jumpping {
    public abstract void jump();
}

package com.scy08;	//子类Cat

public class Cat extends Animal implements Jumpping{
    public Cat(){}
    
    public Cat(String name,int age){
        super(name, age);
    }
    
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void jump() {
        System.out.println("猫会跳高");
    }
}

package com.scy08;	//测试类

public class InterfaceTest {
    public static void main(String[] args) {
        Cat c = new Cat("狸花猫",10);
        c.eat();
        c.jump();
    }
}
结果：
	猫吃鱼
	猫会跳高

练习7

1.1．训练描述：
一、分析以下需求，并用代码实现：
1.定义项目经理类 
属性：
		姓名 工号 工资 奖金
	行为：
		工作work
2.定义程序员类
	属性：
						姓名 工号 工资
	行为：
		工作work

要求:向上抽取一个父类,让这两个类都继承这个父类,
共有的属性写在父类中，子类重写父类中的方法
编写测试类:完成这两个类的测试

package com.scy08;	//抽象父类Employee

public abstract class Employee {
    private String name;
    private int id;
    private int salary;
    public Employee(){}
    public Employee(String name,int id, int salary){
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public abstract void work();
}

package com.scy08;	//子类Manager

public class Manager extends Employee {
    private int bonus;
    public Manager(){}
    public Manager(String name,int age,int salary){
        super(name,age,salary);
    }

    public int getBonus() {
        return bonus;
    }

    public void setBonus(int bonus) {
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println("经理的工作是管理");
    }
}

package com.scy08;	// 子类Programmer 

public class Programmer extends Employee {
    
    public Programmer(){}
    
    public Programmer(String name,int age, int salary){
        super(name,age,salary);
    }
    
    @Override
    public void work() {
        System.out.println("程序员的工作是写代码");
    }
}

package com.scy08;	//测试类

public class EmployeeTest {
    public static void main(String[] args) {
        Manager m = new Manager("li",01,5000);
        m.work();
        Programmer p = new Programmer("wang",02,6000);
        p.work();
    }
}
结果：
	经理的工作是管理
	程序员的工作是写代码

练习8

1.定义手机类
		行为:
			打电话,发短信
2.定义接口IPlay
	行为:
		玩游戏

3.定义旧手机类继承手机类
	行为:
		继承父类的行为
4.定义新手机继承手机类实现IPlay接口
行为:继承父类的行为,重写玩游戏方法

5.定义测试类
	在测试类中定义一个 用手机的方法,
	要求该方法既能接收老手机对象,也能接收新手机对象
	在该方法内部调用打电话,
	发短信以及新手机特有的玩游戏方法

package com.scy08;	//抽象类父类

public abstract class Phone {
    public void call(){
        System.out.println("打电话，发短信");
    }
}

package com.scy08;	//接口类call

public interface IPlay {
    public abstract void play();
}

package com.scy08;	//子类NewPhone

public class NewPhone extends Phone implements IPlay{
    
    @Override
    public void play() {
        System.out.println("用手机玩王者荣耀");
    }
}

package com.scy08;	//子类OldPhone

public class OldPhone extends Phone {
    
}

package com.scy08;

public class PhoneTest {
    public void phoneCall(Phone p){
        if (p instanceof OldPhone){
            p.call();
        }
        else {
            NewPhone np = (NewPhone) p;
            np.play();
            np.call();
        }
        }

    public static void main(String[] args) {

        PhoneTest pt = new PhoneTest();
        NewPhone np = new NewPhone();
        OldPhone op = new OldPhone();
        pt.phoneCall(np);
        pt.phoneCall(op);
    }
}

练习9

	分析以下需求,并用代码实现：
1.定义动物类：
		行为：
			吼叫；没有具体的吼叫行为
			吃饭:没有具体的吃饭行为
	2.定义缉毒接口
		行为: 
			缉毒
	3.定义缉毒狗:犬的一种
		行为：
			吼叫:汪汪叫
			吃饭:狗啃骨头
			缉毒:用鼻子侦测毒
	4.定义测试类:
		使用多态的形式创建缉毒狗对象,调用缉毒方法和吼叫方法

package com.scy08;	//抽象父类Animal

public abstract class Animal {

    public abstract void bellow();

    public abstract void eat();
}

package com.scy08;	//接口缉毒NarcoticsControl

public interface NarcoticsControl {
    public abstract void narcoticsControl();
}

package com.scy08;	//子类Dog

public class Dog extends Animal implements NarcoticsControl {

    @Override
    public void bellow() {
        System.out.println("旺旺叫");
    }

    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }

    @Override
    public void narcoticsControl() {
        System.out.println("用鼻子侦测毒");
    }
}

package com.scy08;

public class AnimalTest {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.bellow();
        Dog d = (Dog) a;
        d.narcoticsControl();
    }
}
结果：旺旺叫
	 用鼻子侦测毒

练习10

分析以下需求,并用代码实现：
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岁的灰颜色的猫眯着眼睛侧着头吃鱼

package com.scy088; //抽象父类Animal

public abstract class Animal {
    private int age;
    private String color;
    public  Animal(){}
    public Animal(int age, String color){
        this.age = age;
        this.color = color;
    }
    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();
}

package com.scy088;	//子类Cat

public class Cat extends Animal {
    public Cat(){}
    public Cat(int age,String color){
        super(age, color);
    }

    @Override
    public String eat(String something) {
        return  "吃"+something;
    }

    public String catchMouse(){
        return "逮老鼠";
    }
}

package com.scy088;	//子类dog

public class Dog extends Animal {
    public Dog(){}
    public Dog(int age,String color){
        super(age, color);
    }

    @Override
    public String eat(String something) {
        return something+"猛吃";
    }
    public String lookHome(){
        return "看家";
    }
}

package com.scy088;

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 String keepPet(Dog dog,String something){

        return "年龄为"+this.age+"岁的"+this.name +"养了一只" + dog.getColor() + dog.getAge()+"岁的宠物\r\n"+dog.getAge()+"岁的"+dog.getColor()+"的狗两只前腿死死的抱住"+dog.eat(something);
    }

    public String keepPet(Cat cat,String something){
        return "年龄为"+this.age+"岁的"+this.name+"养了一只" + cat.getColor() + cat.getAge()+"岁的宠物\r\n"+cat.getAge()+"岁的"+cat.getColor()+"的猫眯着眼睛侧着头"+cat.eat(something);

    }

}

package com.scy088;	// 测试类

public class Test {
    public static void main(String[] args) {
        Cat c = new Cat(3,"灰颜色");
        Dog d = new Dog(2,"黑颜色");
        Person p1 = new Person("老李",25);
        String result1 = p1.keepPet(c,"鱼");

        Person p2 = new Person("老王",30);
        String result2 = p2.keepPet(d,"骨头");
        System.out.println(result2);
        System.out.println("------------------");
        System.out.println(result1);
    }
}
结果：
	年龄为30岁的老王养了一只黑颜色2岁的宠物
	2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
	------------------
	年龄为25岁的老李养了一只灰颜色3岁的宠物
	3岁的灰颜色的猫眯着眼睛侧着头吃鱼