方法重写3之多态

Main.m

#import <Foundation/Foundation.h>
#import "ColorPrinte.h"
#import "Blackprinter.h"
#import "ThreeDPrinter.h"
#import "Printer.h"
#import "Person.h"

int main(int argc, const char * argv[])
{

    /*
    //使用彩色打印机打印
    Person *person = [[Person alloc] init];
//    ColorPrinte *colorPrint = [[ColorPrinte alloc] init];
    Blackprinter *blackPrint = [[Blackprinter alloc] init];
//    [person printWithColorkPrint:colorPrint];
    //使用黑白打印机打印
//    [person printWithBlackPrint:blackPrint];

    //使用3D打印机
    ThreeDPrinter *threeDPrint = [[ThreeDPrinter alloc] init];
    [person printWith3DPrint:threeDPrint];
     */

    /*

     人 *人 = [男人 alloc]init];

     */
    //用父类声明的变量指向子类的对象
//    Printer *printer = [[ColorPrinte alloc] init];
//    [printer print];

    //--------------------多态---------------------
    Person *person = [[Person alloc] init];
    //创建三个打印机
    ColorPrinte *colorPrint = [[ColorPrinte alloc] init];
    Blackprinter *blackPrint = [[Blackprinter alloc] init];
    ThreeDPrinter *threeDPrint = [[ThreeDPrinter alloc] init];

    int cmd;

    while (1) {
        NSLog(@"请输入选择的打印机类型(1、黑白,2、彩色,3、3D):");
        scanf("%d",&cmd);

        if (cmd == 1) {
            [person printer:blackPrint];
        }else if (cmd == 2) {
            [person printer:colorPrint];
        }else if (cmd == 3) {
            [person printer:threeDPrint];
        }else {
            NSLog(@"输入有误");
        }
    }

    /*

     多态:
     1、继承
     2、方法重写
     3、父类声明的变量指向子类对象
     */

    return 0;

Person.h

#import <Foundation/Foundation.h>
#import "Blackprinter.h"
#import "ColorPrinte.h"
#import "ThreeDPrinter.h"
#import "Printer.h"

@interface Person : NSObject

/*
//使用黑白打印机
- (void)printWithBlackPrint:(Blackprinter *)blackPrint;
//使用彩色打印机
- (void)printWithColorkPrint:(ColorPrinte *)colorPrint;

//使用3D打印机
- (void)printWith3DPrint:(ThreeDPrinter *)threeDPrint;
*/

- (void)printer:(Printer *)printer;

Person.m

#import "Person.h"

@implementation Person

/*
//使用黑白打印机
- (void)printWithBlackPrint:(Blackprinter *)blackPrint {

    //调用黑白打印机的打印方法
    [blackPrint print];

}

//使用彩色打印机
- (void)printWithColorkPrint:(ColorPrinte *)colorPrint {

    //调用彩色打印机的打印方法
    [colorPrint print];

}

//使用3D打印机
- (void)printWith3DPrint:(ThreeDPrinter *)threeDPrint {

    [threeDPrint print];

}
 */

- (void)printer:(Printer *)printer {

    [printer print];

}

Printer.h

- (void)print;

Printer.m

- (void)print {

    NSLog(@"打印机打印纸张");

}

BlackPrinter.m

- (void)print {

    NSLog(@"黑白打印机打黑白印纸张");

}

ColorPrinter.m

- (void)print {

    NSLog(@"彩色打印机打印彩色纸张");

}

ThreeDPrinter.m

- (void)print {

    NSLog(@"3D打印机打印3D");

}
时间: 2024-10-11 07:33:33

方法重写3之多态的相关文章

c# 中面相对性的三个特点:封装,继承,多态, 以及c#中隐藏(new)和方法重写(override)和重载(overload)的区别

封装 1)封装原则:将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共方法对其访问,通常有两种访问方式:set 设置,get 获取. 2)封装结果:存在但是不可见. 3) 访问修饰符 声明的可访问性                                 含义 public                                    访问不受限制. protected                              访问仅限于本类或者其子类(可以跨程序集). p

虚方法,重写————继承、多态、面向对象!

1. this 不能直接调用 非static成员class A{static public void M1(){ Hello(); // 错误 在static成员中不能 直接调用非static成员 A a=new A(); a.Hello();}public void Hello(){ F1 =10: M1(); A.M1(); this.M1() //错误 不能调用}} 2. 静态类不能new: 静态类中不能声明非静态成员. 3.sealed 密闭类不能被继承 Fromwork 4.Paint

面向对象的过程、继承、封装、多态;抽象类、访问修饰符的使用、引用类型强制转换、方法重写@override与重载、空指针异常、super关键字

面向对象设计的过程:     发现类-发现类的属性-发现类的方法-优化设计: 封装: private类型的,只可以在本类中使用,当其他类调用此类时,不可使用,因此可以设置setget方法,如下所示: 构造------------------------ 默认有无参构造,若设置了有参构造,则就没有默认的无参构造了,需要自己再添加一个 方法重载------------------- 方法名相同,参数列表不同(类型,数量,顺序不同,与参数名无关): 与返回值,访问修饰符无关 面向对象(OO)的优点--

多态,虚方法重写,抽象类,接口

简而言之就是龙生九子,各有不同 有了继承,才有了多态 1.虚方法 virtual重写 override 父类中的方法,在子类中并不适用,那么子类需要自主更改继承的方法或者是属性,那父类中加了virtual关键字的方法才可以被子类重写 子类重写父类的方法使用的是override关键字 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace 多态 { public

类与接口(五)java多态、方法重写、隐藏

一.Java多态性 面向对象的三大特性:封装.继承.多态. 多态的类型,分为以下两种: 编译时多态: 指的是 方法重载.编译时多态是在编译时确定调用处选择那个重载方法,所以也叫 静态多态,算不上真正的多态.所以,一般说的多态都是运行时的多态. 运行时多态: 由于 方法重写,所以想要确定引用变量所调用的方法的入口,必须根据运行时的引用变量所指向的实例对象来确定.从而使得同一个引用变量调用同一个方法,但不同的实例对象表现出不同的行为.再简单点来说,就是在运行时,可以通过指向基类的指针,来调用实现子类

继承、多态及方法重写、重载

1.多态: 多态指的是同一个方法的调用,由于对象不同可能会有不同的行为.现实生活中,同一个方法,具体实现完全不同. 多态的要点: (1)多态是方法的多态,不是属性的多态(多态与属性无关): (2)多态的存在要有3个必要条件:继承.方法重写.父类引用指向子类对象: (3)父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了. /** * - - - (1)多态是方法的多态,不死属性的多态(多态与属性无关): * - - - (2)多态的存在要有3个必要条件:继承.方法重写.父类

java的方法重写 ,多态和关键字 instanceof和final

package cn.pen; /*final 是一个java的关键字,用于修饰局部变量.属性.方法.类,表示最终的意思. final修饰类表示最终类,无法被继承.public final class Penguin{} final修饰符方法,方法就不能被重写.所以final修饰的是最终子类或最终类 final 修饰属性,经常和static搭配使用,形成静态常量.静态常量不能被改变 修饰变量final 修饰基本数据类型 ,表示a中的内容(值)不能被改变final int a = 10; fina

什么是多态、方法重写与重载

什么是多态 多态的概念呢比较简单,就是同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果. 如果按照这个概念来定义的话,那么多态应该是一种运行期的状态. 为了实现运行期的多态,或者说是动态绑定,需要满足三个条件. 即有类继承或者接口实现.子类要重写父类的方法.父类的引用指向子类的对象. public class Parent{ public void call(){ sout("im Parent"); } } public class Son extends Parent

Java之方法重写、方法重载、多态

Java之方法重写.方法重载.多态博客分类: java语言Java重写重载多态 一.方法重写(Override) 子类可以重写父类的方法. 方法的返回值类型.参数类型.参数个数都不能改变,只能重写方法体. 方法的重写规则 参数列表必须完全与被重写方法的相同: 返回类型必须完全与被重写方法的返回类型相同: 访问权限不能比父类中被重写的方法的访问权限更低. 例如:如果父类的一个方法被声明为public,那么在子类中重写该方法就不能声明为protected. 解释:用于多态(父类引用子类对象). 声明