Java基础习题（四）

九、抽象类

一个类一个.java文件

1.设计一个抽象类Person和它的三个子类Student、Teacher和Worker，要求如下：
Person抽象类中包括name、age两个属性，可用带参数的构造方法为属性赋值；还有一个抽象方法getInfo()，该方法返回一个人的个人信息，返回String类型的结果。
Student、Teacher和Worker三个子类中通过实现Person抽象类中的getInfo()抽象方法，获取各自的个人信息。
在测试类中分别创建Student、Teacher和Worker三个子类的对象，并输出这些对象的个人信息。

//抽象父类Person
abstract class Person {
	String name;
	int age;
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public Person() {}		//构造方法
	public abstract String getInfo();		//抽象方法
}
//子类Student 继承 父类Person
public class Student extends Person{
	public Student(String name,int age) {
		super(name,age);
	}
	public String getInfo() {
		return "student\nname:"+name+"\nage:"+age;
	}
}
//子类Teacher 继承 父类Person
public class Teacher extends Person{
	public Teacher(String name,int age) {
		super(name,age);
	}
	public String getInfo() {
		return "teacher\nname:"+name+"\nage:"+age;
	}
}
//子类Worker 继承 父类Person
public class Worker extends Person {
	public Worker(String name,int age) {
		super(name,age);
	}
	public String getInfo() {
		return "worker\nname:"+name+"\nage:"+age;
	}
}
//测试类
public class PersonTest {
	public static void main(String[] args) {
		Student student1 = new Student("Ammliy",19);
		System.out.println(student1.getInfo());
		
		Teacher teacher1 = new Teacher("Lin",27);
		System.out.println(teacher1.getInfo());
		
		Worker worker1 = new Worker("Jack",51);
		System.out.println(worker1.getInfo());
	}
}

2.设计一个抽象类Shape和它的两个子类Square和Circle，要求如下：
Shape抽象类中有一个抽象方法getArea()，该方法返回一个形状的面积，返回double类型的结果。
Square和Circle中实现了Shape抽象类中的getArea()抽象方法，分别求正方形和圆形的面积并返回。
在测试类中创建Square和Circle对象，计算边长为2的正方形面积和半径为3的圆形面积。

//抽象父类Shape
abstract class Shape {
	int width;
	int r;
	abstract double getArea();
}
//子类Circle 继承 父类Shape
public class Circle extends Shape{
	public double getArea() {
		return r*r*3.14;
	}
}
//子类Square 继承 父类Shape
public class Square extends Shape{
	public double getArea() {
		return width*width;
	}
}
//测试类
public class ShapeTest {
	public static void main(String[] args) {
		Square s = new Square();
		s.width = 2;
		System.out.println("边长为2的正方形面积:"+s.getArea());
		Circle c = new Circle();
		c.r = 3;
		System.out.println("半径为3的圆形面积:"+c.getArea());
	}
}

十、接口

定义接口：interface
实现接口：implements
基础知识点：接口里只能包含abstract抽象方法、final常量、default默认方法和static静态方法，其中默认方法和静态方法允许有方法体。

1.定义接口Areaable，包括抽象方法getArea()，获取形状的面积；定义接口Colorable，包括抽象方法getColor()，获取形状颜色。
假定：圆形只需要计算面积；三角形只需要获取颜色；正方形既需要计算面积，也需要获取颜色。
测试类中分别创建Circle、Square、Triangle对象，并输出面积或颜色等信息。

//接口Areaable
public interface Areaable {
	abstract double getArea();		//抽象方法
}
//接口Colorable
public interface Colorable {
	abstract void getColor();
}
//类Circle 实现 接口Areaable
public class Circle implements Areaable{
	int r;
	public Circle(int r) {
		this.r = r;
	}
	public double getArea() {
		return r*r*3.14;
	}
}
//类Square 实现 接口Areaable和Colorable
public class Square implements Areaable,Colorable{
	int width;
	String color;
	public Square(int width,String color) {
		this.width = width;
		this.color = color;
	}
	public double getArea() {
		return width*width;
	}
	public void getColor() {
		System.out.println("此正方形的颜色为"+color);
	}
}
//类Triangle 实现 接口Colorable
public class Triangle implements Colorable{
	String color;
	public Triangle(String color) {
		this.color = color;
	}
	public void getColor() {
		System.out.println("此三角形的颜色为"+color);
	}
}
//测试类
public class ShapeTest {
	public static void main(String[] args) {
		Circle c = new Circle(2);
		System.out.println("此圆形的面积为"+c.getArea());
		Square s = new Square(4,"blue");
		System.out.println("此正方形的面积为"+s.getArea());
		s.getColor();
		Triangle t = new Triangle("red");
		t.getColor();
	}
}

2.体操比赛计算选手成绩的办法是去掉一个最高分和一个最低分再计算平均分，而学校考查一个班的某科目的考试情况时，是计算全班同学的平均成绩。定义ComputeAverage接口，及实现了该接口的Gymnastics类和School类，然后编写程序分别计算某体操选手和某班的平均成绩。

//接口ComputeAverage
public interface ComputeAverage {
	abstract int avg();
}
//类Gymnastics 实现 接口ComputeAverage
public class Gymnastics implements ComputeAverage{
	int avg;
	public  Gymnastics(int sum,int high,int low,int people) {
		avg = (sum - high - low) / (people - 2);
	}
	public int avg() {
		return avg;
	}
}
//类School 实现 接口ComputeAverage
public class School implements ComputeAverage{
	int avg;
	public School(int people,int sum) {
		avg = sum / people;
	}
	public int avg() {
		return avg;
	}
}
//测试类
public class ComputeAverageTest {
	public static void main(String[] args) {
		Gymnastics p1 = new Gymnastics(52,10,8,6);
		System.out.println(p1.avg());
		School p2 = new School(33,2592);
		System.out.println(p2.avg());
	}
}

3.定义一个打印接口Printer，在其中定义一个print()方法，输出打印信息。
创建两个均实现了接口Printer的类，分别是类BlackPrinter和类ColorPrinter。
定义一个Officer类，该类的属性有个打印接口Printer的引用。
使用面向接口编程的方法让Officer类的对象用黑白或彩色打印机打印。

//接口Printer
public interface Printer {
	abstract void print();
}
//类BlackPrinter 实现 接口Printer
public class BlackPrinter implements Printer{
	public void print() {}
	public static void p() {
		System.out.println("hello!");
	}
}
//类ColorPrinter 实现 接口Printer
public class ColorPrinter implements Printer{
	public void print() {}
	public static void p() {
		System.out.println("HELLO");
	}
}
//类Officer 实现 接口Printer
public class Officer implements Printer{
	int x;
	public void print() {}
	public Officer(int x) {
		this.x = x;
		if(x==0) 
			System.out.println("使用彩色打印机");
		else 
			System.out.println("使用黑白打印机");	
	}
}
//测试类
import java.util.Scanner;
public class OfficerTest {
	public static void main(String[] args) {
		System.out.println("请选择打印机：");
		System.out.println("彩色打印请选0，黑白打印请选1，其他数字默认黑白打印");
		Scanner in = new Scanner(System.in);
		int x = in.nextInt();
		Officer p1= new Officer(x);
		if(x==0) 
			ColorPrinter.p();
		else 
			BlackPrinter.p();
	}
}

4.TyresStandrad接口用于声明17寸轮胎的速度级别及名称，即其包括常量SIZE、方法turnWheel()和方法getTyresName()。
设计一个Car类，该类有一个useTyres (TyresStandrad tyres)方法，该方法的参数tyres是TyresStandrad接口类型，该参数可以存放任何实现TyresStandrad接口的类的对象的引用，并回调类重写的接口方法显示轮胎转速和轮胎名称。
定义Michelin和Dunlop两个实现了接口TyresStandrad的类。
在测试类中获取不同品牌使用17寸轮胎的汽车类的对象，显示其轮胎转速和轮胎名称。

//接口TyresStandrad
public interface TyresStandrad {
	final int size=17;
	abstract int turnWheel();
	abstract String getTyresName();
}
//类Car 实现 接口TyresStandrad
public class Car implements TyresStandrad{
	public int turnWheel;
	String name;

	public int turnWheel() {
		return	turnWheel;
	}
	public String getTyresName() {
		return name;
	}
	public void useTyres (TyresStandrad tyres) {
		System.out.println("SIZE:"+size+"寸");
		System.out.println(tyres.getTyresName()+":");
		System.out.println("转速为："+tyres.turnWheel());
	}
}
//子类Michelin 继承 父类Car 并实现 接口TyresStandrad
class Michelin extends Car implements TyresStandrad{
	public int turnWheel(){
		return 5;
	}
	public String getTyresName(){
		return "Michelin" ;
	}
}
//子类Dunlop 继承 父类Car 并实现 接口TyresStandrad
class Dunlop extends Car implements TyresStandrad{
	public int turnWheel(){
		return 4;
	}
	public String getTyresName(){
		return "Dunlop";
	}
}
//测试类
public class CarTest {
	public static void main(String[] args) {
		Michelin m = new Michelin();
		m.useTyres(m);

		Dunlop d = new Dunlop();
		d.useTyres(d);

		Car c = new Car();
		c.turnWheel = 6;
		c.name = "KKK";
		c.useTyres(c);
	}
}

5.面向对象方法描述动物特性
提示：
定义抽象类Animal，包括：
1）protected级别的mammal和carnivorous成员变量；
2）带mammal和carnivorous两个参数的构造方法；
3）isMammal()和isCarnivorous()分别判断是否哺乳动物和肉食性动物；
4）public级别的static类型的常量COMFORTED，表示动物情绪好；
5）public级别的static类型的常量SCARED，表示动物情绪烦躁；
6）protected级别的mood成员变量，默认初值0表示动物情绪平稳；
7）public级别的setMood和getMood方法分别设置和返回表示情绪的数值；
8）抽象方法sayHello(int mood)，动物带带情绪时打招呼方式。

考虑动物情绪问题及水生动物和陆生动物的区别。
定义陆生动物接口LandAnimal，包括抽象方法getNumberOfLegs()。
定义水生动物接口WaterAnimal，包括抽象方法hasGills()和layEggs()。

子类Cat、Dog、Frog，重写Animal父类的抽象方法sayHello(int mood)；
子类Cat、Dog实现陆生动物接口LandAnimal，重写方法getNumberOfLegs()；
子类Frog实现陆生动物接口LandAnimal，重写方法getNumberOfLegs()；
子类Frog实现水生动物接口WaterAnimal，重写方法hasGills()和layEggs()。

测试类中分别实例化Dog、Cat和Frog三个类的三个对象，并输出各类对象的相应信息。

//抽象类Animal
abstract class Animal {
	public static String COMFORTED = "情绪好";
	public static String SCARED = "情绪烦躁";   //public级别的static类型的常量
	protected boolean mammal;
	protected boolean carnivorous;		
	protected int mood = 0;
	public int getMood() {
		return mood;
	}
	public void setMood(int mood) {
		this.mood = mood;
		if(mood>5)
			System.out.println(SCARED);
		else
			System.out.println(COMFORTED);
	}
	public Animal() {}		//写了有参的构造方法后，系统自动加的无参构造就没有了，就需要自己手动增加一个无参的比较好
	public Animal(boolean mammal,boolean carnivorous,int mood) {}
	//判断是否为哺乳动物
	public void isMammal() {
		if(mammal==true)
			System.out.println("是哺乳类动物");
		else
			System.out.println("不是哺乳类动物");
	}
	//判断是否为食肉动物
	public void isCarnivorous() {
		if(carnivorous==true)
			System.out.println("是食肉类动物");
		else
			System.out.println("不是食肉类动物");
	}
	abstract void sayHello(int mood);
}
//接口LandAnimal
public interface LandAnimal {
	abstract String getNumberOfLegs();
}
//接口WaterAnimal
public interface WaterAnimal {
	abstract boolean hasGills();
	abstract boolean layEggs();
}
//类Cat 继承 抽象类Animal 并实现 接口LandAnimal
public class Cat extends Animal implements LandAnimal{
	public Cat(boolean mammal,boolean carnivorous,int mood) {
		this.mammal = mammal;
		this.carnivorous = carnivorous;
		this.mood = mood;
	}
	public String getNumberOfLegs() {
		return "猫有4条腿";
	}
	void sayHello(int mood) {
		if(mood>5) {
			System.out.println("Cat:咕噜咕噜……");
		}
		else {
			System.out.println("Cat:喵~");
		}
	}
}
//类Dog 继承 抽象类Animal 并实现 接口LandAnimal
public class Dog extends Animal implements LandAnimal{
	public Dog(boolean mammal,boolean carnivorous,int mood) {
		this.mammal = mammal;
		this.carnivorous = carnivorous;
		this.mood = mood;
	}
	public void sayHello(int mood) {
		if(mood>5) {
			System.out.println("Dog:汪汪……");
		}
		else {
			System.out.println("Dog:摇尾巴");
		}
	}
	public String getNumberOfLegs() {
		return "狗有4条腿";
	}
}
//类Frog 继承 抽象类Animal 并实现 接口LandAnimal和WaterAnimal
public class Frog extends Animal implements WaterAnimal,LandAnimal{
	public Frog(boolean mammal,boolean carnivorous,int mood) {
		this.mammal = mammal;
		this.carnivorous = carnivorous;
		this.mood = mood;
	}
	@Override
	public String getNumberOfLegs() {
		return "青蛙有4条腿";
	}
	@Override
	void sayHello(int mood) {
		if(mood>5) 
			System.out.println("Frog:直接跳进水里");
		else 
			System.out.println("Frog:呱呱……");
	}
	@Override
	public boolean hasGills() {
		return true;
	}
	@Override
	public boolean layEggs() {
		return true;
	}
}
//测试类
public class AnimalTest {
	public static void main(String[] args) {
		Cat cat = new Cat(true,true,4);
		cat.sayHello(cat.mood);
		cat.setMood(cat.mood);
		System.out.println(cat.getNumberOfLegs());
		cat.isMammal();
		cat.isCarnivorous();

		Dog dog = new Dog(true,true,3);
		dog.sayHello(dog.mood);
		dog.setMood(dog.mood);
		System.out.println(dog.getNumberOfLegs());
		dog.isMammal();
		dog.isCarnivorous();

		Frog frog = new Frog(false,true,7);
		frog.sayHello(frog.mood);
		frog.setMood(frog.mood);
		System.out.println(frog.getNumberOfLegs());
		frog.isMammal();
		frog.isCarnivorous();
		System.out.println("有鳃："+frog.hasGills());
		System.out.println("产卵："+frog.layEggs());
	}
}