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. 操作步骤描述

  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值
    (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. 操作步骤描述

  1. 定义学生类,学生类有三个属性:name、age、graduateFrom,该类中有成员show方法,方法中打印三个成员变量的值
  2. 在测试类中创建该学生对象,为对象中的成员变量赋值,并调用show方法。
  3. 在测试类中再次创建学生对象,为对象中的成员变量赋值,并调用show方法。
  4. 发现问题,每次创建学生对象都需要给学生的毕业院校属性进行赋值,那么当学生的毕业院校都属于同一所学校时,这样每次创建对象都需要重新赋值很不方便,故而,将该属性graduateFrom新增static所修饰,让这个成员变量被所有对象所共享。
  5. 在测试类中创建两次学生对象,第一次创建学生对象时,给对象中的属性赋值,并调用show方法,第二次创建学生对象时,只给对象中的name、age属性赋值,调用show方法。
  6. 发现第二个学生对象调用show方法时,打印的学生信息中发现,该学生的毕业院校和第一个学生对象一致,从而证明被static所修饰的成员被该类的所有对象所共享。
  7. 在第一次创建学生对象时,给该学生的静态变量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. 操作步骤描述

  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调用成员变量为其赋值
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. 操作步骤描述

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

  1. 基础班老师:成员变量:name、age,构造方法:无参、有参,成员方法:getXxx()、setXxx()、teach(){}。
  2. 就业班老师:成员变量:name、age,构造方法:无参、有参,成员方法:getXxx()、setXxx()、teach(){}。
  3. 抽象类老师:成员变量: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. 操作步骤描述

  1. 定义跳高接口Jumpping,该接口中有一个抽象跳高方法jump()。
  2. 定义抽象类Animal,该类中有属性姓名name、年龄age,还有一个抽象吃饭eat()方法。
  3. 定义猫类Cat,该类继承Animal,并实现跳高接口,重写抽象类中eat()方法与接口中的跳高jump()方法。
  4. 定义测试类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. 操作步骤描述

  1. 定义抽象雇员类Employee,该类中有属性:姓名name,工号id,工资salary,抽象方法:工作work()。
  2. 定义项目经理类Manager,该类继承雇员类,重写父类中抽象方法work(){}。
  3. 定义程序员类Programmer,该类继承雇员类,重写父类中抽象方法work(){}。
  4. 定义测试类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, "鱼");
	}

}

你可能感兴趣的:(java练习)