【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;//访问父类的属性//父类使用权限protectedDog(){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("狗是哺乳动物");elseSystem.out.println("狗不是哺乳动物");if(dog.carnivorous)System.out.println("狗是肉食动物");elseSystem.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表达式，期待后面的学习