文章目录

一、基础案例

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, "鱼");
	}

}

Bitmao888

发布了30 篇原创文章 · 获赞 10 · 访问量 890

私信关注

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

猜你喜欢

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

2．训练案例2

3．训练案例3

4．训练案例4

5．训练案例5

6．训练案例6

二、扩展案例

1．训练案例1

2．训练案例2

3．训练案例3

4．训练案例4