第七章 多态和接口 ② 代码
1.数据模型类（顺序原则） 0702
第六章 封装和继承 ① 笔记 数据模型类
结构/先后顺序：结构：属性 构造 成员方法 getName(){…} setName(String name){…}
面向对象编程 必须画图 图一画思路就清晰了
2.多态
特别注意：要清晰的区别于：第六章 封装和继承 ② 代码 中的 3.对象作为参数 Dog/Money/Feeder/Test
图片、代码的路径如下如所示：
代码如下：
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-02 11:43:51
*/
public class Pet {
//宠物名字
protected String name;
//宠物颜色
protected String color;
public Pet(String name, String color) {
this.name = name;
this.color = color;
}
//吃
public void eat(){
System.out.println("宠物吃东西....");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-02 11:46:39
*/
public class Cat extends Pet{
//构造
public Cat(String name, String color) {
super(name, color);
}
//重写吃的方法
@Override
public void eat() {
System.out.println(this.color+"的"+this.name+"吃小鱼");
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-02 11:47:11
*/
public class Dog extends Pet{
public Dog(String name, String color) {
super(name, color);
}
//重写
@Override
public void eat() {
System.out.println(this.color+"的"+this.name+"吃骨头");
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-02 11:47:46
*/
public class Test {
public static void main(String[] args) {
//父类指向子类:向上转型
//创建猫
Pet pet1 = new Cat("花花","白色");
//创建狗
Pet pet2 = new Dog("旺财","黄色");
//当用父类调用被重写的方法时，自动会使用指向的子类去进行具体的方法调用（里氏替换原则）
//从而体现子类方法的具体结果，这就是多态的效果。
pet1.eat();
pet2.eat();
//多态的实现步骤：
//1.在继承关系中,子类继承父类
//2.子类重写父类的特定方法
//3.定义父类变量指向子类对象(向上转型)
//4.通过父类变量调用父类被重写的方法时，不同的子类有不同结果
}
}
运行结果如下：
3.课前测&多态
代码的路径如下如所示：
代码如下：
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-04 09:33:33
*/
public class Pet {
//属性
protected String name;
protected String color;
//构造
public Pet(String name, String color) {
this.name = name;
this.color = color;
}
public void eat(){
System.out.println("宠物吃东西");
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-04 09:34:31
*/
public class Cat extends Pet{
public Cat(String name, String color) {
//子类构造调用父类构造，满足先有父，再有子的原则
super(name, color);
}
//重写eat方法
@Override
public void eat() {
System.out.println(this.color+"的"+this.name+"吃小鱼");
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-04 09:36:03
*/
public class Dog extends Pet{
public Dog(String name, String color) {
super(name, color);
}
@Override
public void eat() {
System.out.println(this.color+"的"+this.name+"吃骨头");
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-04 09:40:14
*/
public class Parrow extends Pet{
public Parrow(String name, String color) {
super(name, color);
}
@Override
public void eat() {
System.out.println(this.color+"的"+this.name+"吃小米");
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-04 09:55:33
*/
public class Turtle extends Pet{
public Turtle(String name, String color) {
super(name, color);
}
@Override
public void eat() {
System.out.println(this.color+"的"+this.name+"吃小虾");
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-04 09:36:41
*/
public class Master {
//属性
private String name;
//构造
public Master(String name) {
this.name = name;
}
//喂养宠物
public void feed(Pet pet){
System.out.println(this.name+"喂养宠物");
pet.eat();
}
/*
public void feed(Cat cat){
System.out.println(this.name+"喂养宠物");
cat.eat();
}
public void feed(Dog dog){
System.out.println(this.name+"喂养宠物");
dog.eat();
}
public void feed(Parrow parrow){
System.out.println(this.name+"喂养宠物");
parrow.eat();
}*/
//getter,setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Master{" +
"name='" + name + '\'' +
'}';
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-04 09:47:29
*/
public class Test2 {
public static void main(String[] args) {
//实现多态的步骤:
//1.在继承关系中，子类继承父类
//2.子类重写父类中的方法
//3.定义父类变量引用子类对象
//4.通过父类变量调用被重写的方法是，不同子类有不同结果
Pet p1 = new Cat("花花","白色");
Pet p2 = new Dog("旺财","黄色");
p1.eat();
p2.eat();
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-04 09:38:08
*/
public class Test {
public static void main(String[] args) {
Master master = new Master("小明");
Cat cat = new Cat("花花","白色");
Dog dog = new Dog("旺财","黄色");
master.feed(cat);
master.feed(dog);
Parrow parrow = new Parrow("八阿哥","绿色");
master.feed(parrow);
Turtle turtle = new Turtle("龟丞相","黑色");
master.feed(turtle);
//为了实现新功能:
//1.添加了新的业务类
//2.修改了核心业务代码
//这种方式违背了系统设计的开闭原则
//开:对功能扩展要开放
//闭:对功能修改要关闭(尽量不做业务代码修改)
//1.可扩展性 2.可维护性
//使用多态可以实现系统设计的开闭原则
}
}
向上/向下转型
package com.yzh70703.keqiance;
/**
* @author: XYT
* @create-date: 2022/7/4 9:03
*/
public abstract class Pet {
//public class Pet {
protected String name;
public Pet(String name) {
this.name = name;
}
public void eat(){
System.out.println("吃东西");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.yzh70703.keqiance;
/**
* @author: XYT
* @create-date: 2022/7/4 9:03
*/
public class Dog extends Pet{
public Dog(String name) {
super(name);
}
@Override
public void eat() {
System.out.println(name+"吃骨头");
}
public void seeDoor(){
System.out.println(name+"看门");
}
}
package com.yzh70703.keqiance;
/**
* @author: XYT
* @create-date: 2022/7/4 9:03
*/
public class Cat extends Pet{
public Cat(String name) {
super(name);
}
public void eat(){
System.out.println(name+"吃小鱼");
}
public void catchMouse(){
System.out.println(name+"抓老鼠");
}
}
package com.yzh70703.keqiance;
/**
* @author: XYT
* @create-date: 2022/7/4 9:03
*/
public class Test {
public static void main(String[] args) {
// Master m=new Master("小明");
// Cat c=new Cat("花花");
// Dog d=new Dog("旺财");
// m.feed(c);
// m.feed(d);
//
// Parrow p=new Parrow("鹦鹉");
// m.feed(p);
// 父类变量指向子类对象: 向上转型(装箱)
Pet c=new Cat("花花");
Pet d=new Dog("旺财");
// 父类变量指向对象,此时只能通过父类变量访问父类中定义的内容,子类的东西是访问不到
// 向上转型之后，子类的细节被屏蔽
// 如果想要访问子类的内容，需要进行向下转型(拆箱)
// 向下转型不安全
/*Cat cat = (Cat)c;
cat.eat();
Dog dog = (Dog) c;
dog.eat();*/
// 向下转型时可以通过instanceof(返回true/false) 关键字测试父类指向的对象类型
// 测试p1指向的对象是否是Cat类型的对象
if(c instanceof Cat){
Cat cat=(Cat)c;
cat.catchMouse();
}else if(c instanceof Dog){
Dog dog=(Dog)c;
dog.seeDoor();
}
System.out.println("=================================");
if(d instanceof Cat){
Cat cat=(Cat)d;
cat.catchMouse();
}else if(d instanceof Dog){
Dog dog=(Dog)d;
dog.seeDoor();
}
}
}
4.抽象类&抽象方法
代码的路径如下如所示：
代码如下：
package com.yzh7.test3;
/**
* @author: hy
* @create: 2022-07-04 10:50:18
*/
public abstract class MyParentCls {
private int num;
public MyParentCls() {
}
public void test1(){
}
//抽象方法
public abstract void test2();
}
package com.yzh7.test3;
/**
* @author: hy
* @create: 2022-07-04 10:53:53
*/
public class MySubCls extends MyParentCls{
public MySubCls(){
super();
}
@Override
public void test2() {
}
//子类继承了有抽象方法的抽象类
//1.子类变为抽象类
//2.子类实现父类的抽象方法
}
package com.yzh7.test3;
/**
* @author: hy
* @create: 2022-07-04 10:50:50
*/
public class Test {
public static void main(String[] args) {
//MyParentCls myParentCls = new MyParentCls();
//myParentCls.test1();
}
}
5.接口的多态
接口：
代码的路径如下如所示：
代码如下：
package com.yzh7.test4;
/**
* 接口: 表示能够跑
* @author: hy
* @create: 2022-07-04 11:25:24
*/
public interface IRun {
//接口中的方法都是公有抽象的
void pao();
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-04 11:27:52
*/
public class Car implements IRun{
@Override
public void pao() {
System.out.println("车用四个车轮跑....");
}
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-04 11:28:37
*/
public class Rabbit implements IRun{
@Override
public void pao() {
System.out.println("兔子跳着四条腿跑....");
}
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-04 11:28:58
*/
public class People implements IRun{
@Override
public void pao() {
System.out.println("人用两条腿跑");
}
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-04 11:29:20
*/
public class Test {
public static void main(String[] args) {
System.out.println("世界末日来临，洪水泛滥，一切事物都在跑...");
//接口的多态,接口变量指向实现类对象
IRun r1 = new Car();
IRun r2 = new Rabbit();
IRun r3 = new People();
//体现多态:接口变量调用被实现的方法，不同实现类的效果不同
r1.pao();
r2.pao();
r3.pao();
}
}
// An highlighted block
var foo = 'bar';
6.案例演练 USB接口 通过接口实现多态
代码的路径如下如所示：
代码如下：
package com.yzh7.test5;
/**
* usb接口
*/
public interface IUsb {
//能通过电脑做处理
void work();
}
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-04 11:36:35
*/
public class Mouse implements IUsb{
@Override
public void work() {
System.out.println("使用鼠标选择文件...");
}
}
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-04 11:37:01
*/
public class KeyBoard implements IUsb{
@Override
public void work() {
System.out.println("使用键盘编写文档...");
}
}
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-04 11:37:34
*/
public class Computer {
//usb接口
private IUsb usb;
//电脑开机
public void start(){
System.out.println("电脑开机了....");
//使用usb设备做事情
//通过接口实现了多态
this.usb.work();
}
//设置usb设备
public void setUsb(IUsb usb){
this.usb= usb;
}
}
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-04 11:39:45
*/
public class Test {
public static void main(String[] args) {
IUsb u1 = new Mouse();
IUsb u2 = new KeyBoard();
Computer computer = new Computer();
//电脑上设置鼠标
computer.setUsb(u1);
computer.start();
//电脑上设置键盘
computer.setUsb(u2);
computer.start();
}
}
Computer和Test通过“向下转换”的方式实现：
package com.yzh70703.test3USB;
/**
* @author: XYT
* @create-date: 2022/7/4 19:06
*/
public class Computer {
private IUsb iusb;
//向下转换
public void start(Mouse mouse){
System.out.println("电脑开始工作。。");
mouse.work();
}
public void start(KeyBoard keyBoard){
System.out.println("电脑开始工作。。");
keyBoard.work();
}
//通过接口实现多态
// public void start(){
// System.out.println("电脑开始工作。。");
// this.iusb.work();
// }
//错误写法
// public void start(IUsb iusb){ //IUsb为私有属性，外部只能通过setIusb将对象传进来
// System.out.println("电脑开始工作。。");
// this.iusb.work();
// }
public void setIusb(IUsb iusb){
this.iusb=iusb;
}
public IUsb getIusb(){
return iusb;
}
}
package com.yzh70703.test3USB;
import java.awt.event.KeyEvent;
/**
* @author: XYT
* @create-date: 2022/7/4 19:12
*/
public class Test {
public static void main(String[] args) {
IUsb iu1=new Mouse();
IUsb iu2=new KeyBoard();
Computer com=new Computer();
com.start((Mouse) iu1); //这里需要强制转换
com.start((KeyBoard)iu2); //这里需要强制转换
// Computer com=new Computer();
// com.setIusb(iu1); //传入参数值
// com.start(); //输出结果
//
// com.setIusb(iu2); //传入参数值
// com.start(); //输出结果
}
}
运行结果如下：
7.课前测试 多态与接口 0705
代码的路径如下如所示：
代码如下：
package com.yzh7.test1;
/**
* 课程接口
*/
public interface ICourse {
//抽象方法:课程技能
String skill();
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-05 09:26:50
*/
public class JavaCourse implements ICourse{
@Override
public String skill() {
return "能够使用java开发DVD管理系统";
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-05 09:27:33
*/
public class CSharpCourse implements ICourse{
@Override
public String skill() {
return "能狗使用CSharp开发ktv系统";
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-05 09:28:01
*/
public class HtmlCourse implements ICourse{
@Override
public String skill() {
return "能够使用html制作网上花店";
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-05 09:31:16
*/
public class Python implements ICourse{
@Override
public String skill() {
return "使用Python开发人工智能";
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-05 09:28:30
*/
public class Student {
private String name;
private ICourse course;
public Student(String name) {
this.name = name;
}
//学习
public void study(ICourse course){
System.out.println(this.name+"学习课程");
System.out.println(course.skill());
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-05 09:30:04
*/
public class Test {
public static void main(String[] args) {
JavaCourse javaCourse = new JavaCourse();
CSharpCourse cscourse = new CSharpCourse();
HtmlCourse htmlCourse = new HtmlCourse();
Python python = new Python();
Student student = new Student("小明");
student.study(javaCourse);
student.study(cscourse);
student.study(htmlCourse);
student.study(python);
//String s = null;
//System.out.println(s.length());
}
}
注意Student和Test：
package com.yzh70704.ceshi;
/**
* @author: XYT
* @create-date: 2022/7/5 9:06
*/
public class Student {
String name;
ICourse icourse;
public Student(String name) {
this.name = name;
}
//第一种方式
public void study(ICourse icourse){
System.out.println(this.name+"学习课程");
System.out.println( icourse.skill());
}
//第二种方式
// public void study(){
// System.out.println(this.name+"学习课程");
// System.out.println( icourse.skill());
//
// }
// public void setIcourse(ICourse icourse) {
// this.icourse = icourse;
// }
}
package com.yzh70704.ceshi;
/**
* @author: XYT
* @create-date: 2022/7/5 9:09
*/
public class Test {
public static void main(String[] args) {
//第一种方式
Java java=new Java();
Html html=new Html();
Cshar cshar=new Cshar();
Student s=new Student("张三");
s.study(java);
s.study(html);
s.study(cshar);
//第二种方式
// Java java=new Java();
// Html html=new Html();
// Cshar cshar=new Cshar();
// Student s=new Student("张三");
// s.setIcourse(java);
// s.study();
// s.setIcourse(html);
// s.study();
// s.setIcourse(cshar);
// s.study();
}
}
8.接口特点 static/abstrace/jdk1.8以后default/static
代码如下：
package com.yzh7.test2;
/**
* @author: hy
* @create: 2022-07-05 09:41:04
*/
public interface IA {
//接口中的变量默认都是公有静态常量:1.必须要赋值 2.赋值之后不能再改
// public static final
int num = 10;
//public abstract 抽象方法
void test1();
//jdk1.8之后新增了默认方法
public default void test2(){
System.out.println("这是默认方法test2");
}
//jdk1.8之后新增了静态方法
//1.接口中的静态方法不能被实现类实现 2.要通过接口直接调用
public static void test3(){
System.out.println("这是静态方法test3");
}
}
package com.yzh7.test2;
/**
* @author: hy
* @create: 2022-07-05 09:47:47
*/
public class MyCls implements IA{
@Override
public void test1() {
System.out.println("MyCls实现的test1方法");
}
//实现类可以重写默认方法，但是实现类不能重写静态方法
@Override
public void test2() {
System.out.println("MyCls重写的默认方法test2");
}
}
package com.yzh7.test2;
/**
* @author: hy
* @create: 2022-07-05 09:43:19
*/
public class Test {
public static void main(String[] args) {
System.out.println(IA.num);
//IA.num=100;
IA a = new MyCls();
a.test1();
a.test2();
//a.test3();
//接口中的静态方法，只能通过接口明直接调用
IA.test3();
}
}
9.接口特点 一类实现多接口 一接口继承多借口
代码如下：
package com.yzh7.test3;
public interface IY {
void testy();
}
package com.yzh7.test3;
public interface IZ {
void testz();
}
package com.yzh7.test3;
/**
* @author: hy
* @create: 2022-07-05 09:52:35
*/
public interface IX{
void testx();
}
package com.yzh7.test3;
/**
* @author: hy
* @create: 2022-07-05 09:53:19
*/
public class MyDemoCls implements IX,IY,IZ{
//实现类可以实现多个接口，要求必须实现所有接口中的抽象方法
@Override
public void testx() {
}
@Override
public void testy() {
}
@Override
public void testz() {
}
}
package com.yzh7.test3;
/**
* @author: hy
* @create: 2022-07-05 09:56:08
*/
public class MyDemoCls3 extends MyDemoCls implements IX,IY,IZ{
//一个类可以继承另外一个类，同时实现多个接口
}
修改IX:
package com.yzh7.test3;
/**
* @author: hy
* @create: 2022-07-05 09:52:35
*/
public interface IX extends IY,IZ{
//一个接口可以同时继承其他接口
void testx();
}
package com.yzh7.test3;
/**
* @author: hy
* @create: 2022-07-05 09:55:18
*/
public class MyDemoCls2 implements IX{
@Override
public void testx() {
}
@Override
public void testy() {
}
@Override
public void testz() {
}
}
10.案例演练 富豪黑白/彩色打印
代码的路径如下如所示：
代码如下：
package com.yzh7.test4;
/**
* 打印机接口
*/
public interface IPrinter {
//打印方法
void print(String info);
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-05 10:32:08
*/
public class ColorPrinter implements IPrinter{
@Override
public void print(String info) {
System.out.println("使用彩色打印机打印:"+info);
}
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-05 10:31:38
*/
public class BlackWhitePrinter implements IPrinter{
@Override
public void print(String info) {
System.out.println("使用黑白打印机打印:"+info);
}
}
package com.yzh7.test4;
/**
* 财产都是可以被描述的
*/
public interface IShow {
//返回财产的信息描述
String show();
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-05 10:34:10
*/
public class Plane implements IShow{
@Override
public String show() {
return "价值2亿的豪华飞机";
}
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-05 10:34:50
*/
public class Ship implements IShow{
@Override
public String show() {
return "价值1.7亿的豪华游艇";
}
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-05 10:35:30
*/
public class Master {
//姓名
private String name;
//打印机
private IPrinter printer;
//构造
public Master(String name) {
this.name = name;
}
//打印
public void dayin(IShow s){
System.out.println("富豪"+this.name+"打印财产");
this.printer.print(s.show());
}
//设置打印机
public void setPrinter(IPrinter printer){
this.printer = printer;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-05 10:39:36
*/
public class Test {
public static void main(String[] args) {
//富豪使用[不同打印机]打印[不同财产]
IPrinter p1 = new BlackWhitePrinter();
IPrinter p2 = new ColorPrinter();
IShow s1 = new Plane();
IShow s2 = new Ship();
Master master = new Master("小明");
//设置打印机
master.setPrinter(p2);
master.dayin(s1);
master.dayin(s2);
master.setPrinter(p1);
master.dayin(s1);
master.dayin(s2);
}
}
运行结果如下：
#pic_center
扫一扫
397
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
