【Java语言基础】面向对象之封装、继承、抽象类、接口、多态综合知识习题及总结day11
这几天逐渐被idea所折服，越来越喜欢这个优雅又强大的代码编辑器，有很多人说idea对很多初学者不友好，但是在我看来，只要你足够自律，并且英语不会太差，语法上关键的几个单词没什么大问题，idea对初学者是有很大帮助的。因为idea强大的语法检查功能对初学者十分友好，idea提供各种错误提示，以及各个需要注意的地方，这让初学者可以轻松找到出错的代码块。好了，下面来看题目吧！
1.根据以下这段话的描述，用面向对象的思想实现
狗生活在陆地上（是一种陆生动物），既是哺乳类的也是肉食性的。
狗通常的时候和人打招呼会通过“摇摇尾巴”，在被抚摸情绪很好的时候，
会“旺旺叫”，而在受到惊吓情绪烦躁时，会发出“呜呜”声；
猫也生活在陆地上（是一种陆生动物），既是哺乳类的也是肉食性的。
猫通常的时候和人打招呼会发出“喵～”的声音，在被抚摸情绪很好时，
会发出“咕噜咕噜”声，而在受到惊吓时，会发出“嘶嘶”声；
青蛙是一种两栖动物（既是水生动物也是陆生动物），既不是哺乳类的也不是肉食性的，
属于卵生。青蛙通常的时候和人打招呼会通过“呱呱叫”，当青蛙情绪好的时候，
会在岸边“呱呱呱”的唱歌，而在受到惊吓时，会“扑通一声跳入水中”
//下面只实现了狗的模块，猫和青蛙模块同理，不再赘述
//因为水生和陆生不能抽象处出来共性，因此将其定义为接口
package com.company;
abstract class Animal
{
static final int HAPPY = 1;
static final int UNHAPPY = 0;
protected boolean carnivorous; //肉食
protected boolean mammal; //哺乳
public abstract void sayHello();
public abstract void sayHello(int mood);
public boolean isCarnivorous()
{
return carnivorous;
}
public boolean isMammal()
{
return mammal;
}
}
//水生动物
interface Water
{
boolean hasGillFlag(); //是否有腮
}
//陆生动物
interface Land
{
int getLegNumber(); //有多少条腿
}
class Dog extends Animal implements Land
{
private int dogLegNumber = 4;
//访问父类的属性
//父类使用权限protected
Dog()
{
this.carnivorous = true;
this.mammal = true;
}
public void sayHello()
{
System.out.println("摇摇尾巴");
}
public void sayHello(int mood)
{
switch (mood)
{
case HAPPY:
System.out.println("汪汪叫");
break;
case UNHAPPY:
System.out.println("呜呜叫");
break;
default:
System.out.println("摇摇尾巴");
}
}
public int getLegNumber()
{
return dogLegNumber;
}
}
public class TaskDay09_4 {
public static void main(String[] args)
{
Dog dog = new Dog();
if(dog.mammal)
System.out.println("狗是哺乳动物");
else
System.out.println("狗不是哺乳动物");
if(dog.carnivorous)
System.out.println("狗是肉食动物");
else
System.out.println("狗不是肉食性动物");
System.out.print("狗通常的打招呼方式是：" );
dog.sayHello();
System.out.print("狗开心的时候的打招呼方式是：" );
dog.sayHello(Animal.HAPPY);
System.out.print("狗不开心的时候的打招呼方式是：" );
dog.sayHello(Animal.UNHAPPY);
System.out.println("狗是肉食动物,狗有" + dog.getLegNumber() + "条腿");
}
}
总结：这道题因为水生和陆生不能抽象处出来共性，因此需要将其定义为接口
2.已知电脑有三个USB接口，分别去实例化一个鼠标，一个键盘，一个U盘来连接到电脑上。输出每一个USB接口连接的设备信息
package com.company;
interface Usb
{
String getDeviceInfo();
}
class Mouse implements Usb
{
public String getDeviceInfo()
{
return "鼠标";
}
}
class KeyBoard implements Usb
{
public String getDeviceInfo()
{
return "键盘";
}
}
class Upan implements Usb
{
public String getDeviceInfo()
{
return "U盘";
}
}
class Computer
{
private Usb usb1;
private Usb usb2;
private Usb usb3;
public Computer(){}
public Computer(Usb usb1, Usb usb2, Usb usb3)
{
this.usb1 = usb1;
this.usb2 = usb2;
this.usb3 = usb3;
}
public void showInfo()
{
System.out.println(usb1.getDeviceInfo());
System.out.println(usb2.getDeviceInfo());
System.out.println(usb3.getDeviceInfo());
}
}
public class TaskDay09_1 {
public static void main(String[] args)
{
Usb usb1 = new Mouse();
Usb usb2 = new KeyBoard();
Usb usb3 = new Upan();
Computer com = new Computer(usb1, usb2, usb3);
com.showInfo();
}
}
总结：在做这道题的时候面向对象的思想不明确，导致题意不懂。
只需要将USB定义为接口，接口的作用是用来展示键盘、鼠标、U盘各个设备的信息。键盘、鼠标、U盘只需要分别定义为一个类实现接口即可。将电脑定义为一个类，其中包含了三个USB对象，并通过方法试实现展示功能。
注意：接口是抽象的，不能用来实例化对象，只能通过实现接口的各个类和实例化对象。因此在main函数中利用多态来实现函数功能。
3.设计一个交通工具抽象类，提供抽象方法–驾驶
汽车作为交通工具的一种，实现了驾驶的方法(在马路上驾驶)
火车作为交通工具的一种，实现了驾驶的方法(在铁路上驾驶)
飞机作为交通工具的一种，实现了驾驶的方法(在天上驾驶)
需求：做一个测试类，在测试类的main函数中，分别实例化一个汽车的对象，火车的对象和飞机的对象，并分别描述驾驶行为
package com.company;
abstract class Transportation
{
abstract void Drive();
}
class Car extends Transportation
{
public void Drive()
{
System.out.println("马路上行驶");
}
}
class Train extends Transportation
{
public void Drive()
{
System.out.println("铁路上行驶");
}
}
class Plane extends Transportation
{
public void Drive()
{
System.out.println("天上行驶");
}
}
public class TaskDay09_2
{
public static void main(String[] args)
{
Car car = new Car();
Train train = new Train();
Plane plane = new Plane();
func(car);
func(train);
func(plane);
}
//多态：父类的引用指向了子类
public static void func(Transportation tool)
{
tool.Drive();
}
}
总结：同样的，这题也是通过多态实现，但是这题是抽象类，但是第2题是接口。
多态的过程细节：多态与继承、方法重写密切相关，我们在方法中接收父类类型作为参数，在方法实现中调用父类类型的各种方法。当把子类作为参数传递给这个方法时，java虚拟机会根据实际创建的对象类型，调用子类中相应的方法（存在方法重写时）。
因此可以继续总结多态实现的三个条件，一定要记下来！
1.需要有继承关系（普通子父类的继承和抽象类的继承）或者实现（接口）的存在。
2.需要有方法的重写。
3.需要有父类的引用指向子类对象。
4.设计一个家政服务规范(接口): 洗衣服, 扫地, 买菜, 做饭
设计一个保姆类, 保姆需要遵循这些规范
需求：在测试类中，实例化一个保姆的对象，然后让保姆买菜，做饭，扫地
package com.company;
interface Service
{
void wishClothes();
void sweepFloor();
void cookRice();
}
class Nurse implements Service
{
private String name;
Nurse(){}
Nurse(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public void wishClothes()
{
System.out.println("wishClothes");
}
public void sweepFloor()
{
System.out.println("sweepFloor");
}
public void cookRice()
{
System.out.println("cookRice");
}
}
public class TaskDay09_3
{
public static void main(String[] args)
{
Nurse nurse = new Nurse("Tom");
System.out.println(nurse.getName());
show(nurse);
}
public static void show(Service ser)
{
ser.wishClothes();
ser.sweepFloor();
ser.cookRice();
}
}
这一题同样是用到了多态，和上面两道题不一样的是，这一题里面的子类包含了自己特有的属性，因此先先定义了一个子类对象nurse，利用子类对象nurse对其属性先赋初始值。之后利用多态，创建ser（接口）对象，再将ser对象指向子类对象nurse，实例化的同样只是子类，而不是接口。
经过这三道题目的踪总结，对于多态应当有了更深入的理解。
5.设计一个动物类，属性: 姓名，性别
设计一个猫类，设计一个狗类， 猫和狗都继承自动物类
需求：在测试类中设计一个方法，这个方法需要一个参数，参数的类型可以是猫类，也可以是狗类 -->多态(动物类 )
package com.company;
abstract class Animals
{
private String name;
private String sex;
Animals(){}
Animals(String name, String sex)
{
this.name = name;
this.sex = sex;
}
public void setName(String name)
{
this.name = name;
}
public void setSex(String sex)
{
this.sex = sex;
}
public String getName()
{
return name;
}
public String getSex()
{
return sex;
}
}
class Cat extends Animals
{
Cat(){}
Cat(String name, String sex)
{
super(name, sex);
}
}
class Dog1 extends Animals
{
Dog1(){}
Dog1(String name, String sex)
{
super(name, sex);
}
}
class TaskDay09_4
{
public static void main(String[] args)
{
Cat cat = new Cat("Tom","M");
Dog1 dog1= new Dog1("Amy", "W");
testAnimals(cat);
testAnimals(dog1);
}
public static void testAnimals(Animals ani)
{
if (ani instanceof Cat)
{
//下面这段可以进行封装，但是懒。。。
String name = ani.getName();
String sex = ani.getSex();
System.out.println(name);
System.out.println(sex);
}
if (ani instanceof Dog1)
{
String name = ani.getName();
String sex = ani.getSex();
System.out.println(name);
System.out.println(sex);
}
}
}
总结：认真做到这一道题目的时候已经对面向对象、抽象类、多态有比较深入的理解了！
1.抽象类也是一个类，也应当包含构造方法。
2.子类在继承抽象类时，构造方法应当重写，并继承父类的构造器。
3.为了更加细致地体现面向对象的思想，在main方法中定义的对象应当有明确的指向，例如Cat cat = new Cat(“Tom”,“M”); 此处定义的对象cat应当指向Cat类，而不是指向的Animals类，同时利用构造器对该对象赋初始值更加方便快捷
4.细节上来说，每次重写构造器时都应当写上该类的默认构造器，若不写上，则利用该类作为父类定义子类时，子类找不到父类的默认构造方法出现意想不到的错误。坚持一个良好习惯就成功了一半！
6.设计一个数据传输接口：Type-C标准
设计一个防水的接口：防水
设计一个手机类，实现这个数据传输接口，采用Type-C；同时实现了防水的接口
package com.company;
interface TypeC
{
}
interface waterProof
{
}
class Phone implements TypeC,waterProof
{
}
public class TaskDay09_5
{
public static void main(String[] args)
{
Phone phone = new Phone();
}
}
总结：实现多个接口
7.模拟 Arrays.sort 方法，实现如下方法，实现对一个Person数组的排序，给第二个参数传递对象时使用匿名内部类。
MyArrays.sort(Person[] array, MyComparator comparator);
Person是一个类，MyComparator是一个比较器，包含了compare抽象函数，需要使用匿名内部类重写
package com.company;
interface MyComparator
{
int compare(Person ren1, Person ren2);
}
class Person
{
private String name;
private int age;
public Person(){}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
//重写toString方法
public String toString()
{
return name+"," +age;
}
}
public class TaskDay09_6 {
public static void main(String[] args)
{
Person[] arr = {new Person("lisi", 20), new Person("zhosi", 35),
new Person("wangzi", 18), new Person("gangzi", 40), };
sort(arr, new MyComparator(){
public int compare(Person ren1, Person ren2)
{
return ren1.getAge() - ren2.getAge();
}
});
for (Person person:arr)
{
System.out.println(person.toString());
}
}
//选择排序，排序器用来比较大小的，只有这么一个功能
public static void sort(Person[] array, MyComparator comparator)
{
for (int i=0; i<array.length-1; i++)
{
for(int j=i+1; j<array.length; j++)
{
if(comparator.compare(array[j], array[i])>0)
{
Person temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}
}
}
}
按照题目要求做即可，这里对Person排序指的是对Person里的age排序。
比较震撼的是lambda表达式，idea直接可以将匿名内部类换成lambda表达式，期待后面的学习