OOP with Java 通知 Project 3: 4 月 19 日晚 9 点

Size: px

Start display at page:

Download "OOP with Java 通知 Project 3: 4 月 19 日晚 9 点"

儿夜范
6 years ago
Views:

1 OOP with Java Yuanbin Wu

2 OOP with Java 通知 Project 3: 4 月 19 日晚 9 点

3 复习 Upcasting 同一基类的不同子类可以被视为同一类型 ( 基类 ) 放宽类型一致性简化接口 class A{ class B{ A a = new A(); B b = new B(); // A a = new B(); compile error class A{ class B extends A{ A a = new A(); B b = new B(); A a = new B(); // upcasting

4 复习多态 class Instrument { public void play(int note) { System.out.println( Instrument.play() + n); public class Wind extends Instrument { public void play(int note) { System.out.println( Wind.play() + n); public class Music { public static void tune(instrument i) { i.play(); public static void main(string []args){ Wind flute = new Wind(); Stringed violin = new Stringed(); Brass frenchhorn = new Brass(); tune(flute); tune(violin); tune(frenchhorn); public class Stringed extends Instrument { public void play(int note) { System.out.println( Stringed.play() + n); public class Brass extends Instrument { public void play(int note) { System.out.println( Brass.play() + n); 多态 (Polymorphism) 参数 Instrument I 可以代表不同的子类, 并能正确调用它们的方法 ( 即, 有多种表现形态 )

5 复习静态绑定函数的调用在编译后便确定, 也称为 early binding 优点 : 快速, 易于 debug, 缺点 : 接口繁琐动态绑定函数的调用在运行时才能确定也称 late binding 优点 : 接口简洁缺点 : 函数调用需要额外开销 Java 中的所有方法都采用动态绑定, 除了 final Static 数据成员不动态绑定

6 OOP with Java 抽象类接口定义实现多个接口扩展接口接口适配器应用 : 工厂模式

7 抽象类父类的方法 Instrument: play() 子类重写父类的方法 Wind: play() Stringed: play() Brass: play() 可扩展性用户程序仅知父类方法子类修改不会影响用户程序 play() Wind Instrument play() Stringed play() play() Brass public class Music { public static void tune(instrument i) { i.play(); public static void main(string []args){ Wind flute = new Wind(); Stringed violin = new Stringed(); Brass frenchhorn = new Brass(); tune(flute); tune(violin); tune(frenchhorn);

8 抽象类如果所有子类都将重写该方法 Instrument: play()?? 是否有机制 : 在父类中不指定该方法的具体实现禁止调用父类的该方法 Instrument play() play() Wind Stringed play() play() Brass

9 抽象类抽象方法 (abstract method) 仅提供方法的名称, 参数和返回值没有具体实现使用 abstract 关键字 class Instrument { public void play(int note) { System.out.println( Instrument.play() + n); abstract class Instrument { public abstract void play(int note) ; 普通方法抽象方法

10 抽象类抽象类 (abstract class) 包含抽象方法的类称为抽象类

11 抽象类抽象类 abstract class Instrument { public abstract void play(int note) ; public class Wind extends Instrument { public void play(int note) { System.out.println( Wind.play() + n); public class Stringed extends Instrument { public void play(int note) { System.out.println( Stringed.play() + n); public class Brass extends Instrument { public void play(int note) { System.out.println( Brass.play() + n);

12 抽象类是否能创建抽象类的对象? 否抽象类是不完整的类其中的抽象方法需要在子类补充完整 ( 重写 ) 后才有意义

13 抽象类无法创建该类的对象 abstract class Instrument { public abstract void play(int note) ; class Test { public static void main(string []args){ // Instrument in = new Instrument(); // compile error: can not create instances of an abstract class

14 抽象类 abstract Instrument abstract void play(); String what() { /* */ extends Wind Stringed Percussion void play() String what() void play() String what() void play() String what() extends Woodwind void play() String what() Brass void play() String what()

15 abstract class Instrument { public abstract void play(int note) ; public String what() {return Instrument ; class Stringed extends Instrument { public void play(int note) { System.out.println( Stringed.play() + n); public String what() {return Stringed ; public class Music { public static void tune(instrument i) { i.play(); public static void main(string []args){ Wind flute = new Wind(); Stringed violin = new Stringed(); Brass frenchhorn = new Brass(); tune(flute); tune(violin); tune(frenchhorn); class Percussion extends Instrument { public void play(int note) { System.out.println( Percussion.play() + n); public String what() {return Percussion ; abstract class Wind extends Instrument { public abstract void play(int note) ; public String what() {return Wind ; 若子类没有重写父类中的抽象方法, 子类仍为抽象类 class Woodwind extends Wind { public void play(int note) { System.out.println( Woodwind.play() + n); public String what() {return Woodwind ; class Brass extends Wind { public void play(int note) { System.out.println( Brass.play() + n); public String what() {return Brass ;

16 抽象类总结抽象类包含抽象方法, 只有方法名, 参数, 返回值, 没有方法的实现抽象类不能实例化若子类没有重写父类中的抽象方法, 子类仍为抽象类

17 接口接口定义实现多个接口扩展接口接口适配器应用 : 工厂模式

18 接口抽象类抽象方法普通方法 abstract class Instrument { public abstract void play(int note) ; public String what() {return Instrument ;

19 接口接口 (Interface) 所有方法都是抽象方法只有方法的名称, 参数和返回值没有方法的实现 abstract class Instrument { public abstract void play(int note); public abstract String what(); interface Instrument { void play(int note) ; String what();

20 接口继承重用 (class reusing) 子类重用父类的方法 / 数据 upcasting 和多态接口父类出现之处可用子类代替能够调用正确的子类方法 ( 动态绑定 ) 没有代码重用, 仅仅保留 upcasting 和多态

21 接口接口所有实现该接口的类都具有接口提供的方法任何使用该接口类型的方法, 都可以使用他的任何一种实现某种协议 (protocol)

22 接口接口的实现接口 : 方法长什么样? 实现 : 方法具体怎样工作?

23 接口接口的实现 abstract class Instrument { public abstract void play(int note); public abstract String what(); interface Instrument { void play(int note) ; String what(); class Stringed extends Instrument { public void play(int note) { System.out.println( Stringed.play() + n); public String what() {return Stringed ; class Stringed implements Instrument { public void play(int note) { System.out.println( Stringed.play() + n); public String what() {return Stringed ; 继承 : 1. extends 关键字 2. 父类, 子类关系 3. class, extends 接口 : 1. implements 关键字 2. 接口, 实现关系 3. interface, implements

24 interface Instrument void play(); String what(); implements Wind Stringed Percussion void play() String what() void play() String what() void play() String what() extends Woodwind void play() String what() Brass void play() String what()

25 interface class Instrument { void play(int note) ; String what(); class Stringed implements Instrument { public void play(int note) { System.out.println( Stringed.play() + n); public String what() {return Stringed ; public class Music { public static void tune(instrument i) { i.play(); public static void main(string []args){ Wind flute = new Wind(); Stringed violin = new Stringed(); Brass frenchhorn = new Brass(); tune(flute); tune(violin); tune(frenchhorn); class Percussion implements Instrument { public void play(int note) { System.out.println( Percussion.play() + n); public String what() {return Percussion ; class Wind implements Instrument { public void play(int note) { System.out.println( Wind.play() + n); public String what() {return Wind ; 普通类, 抽象类, 接口 class Woodwind extends Wind { public void play(int note) { System.out.println( Woodwind.play() + n); public String what() {return Woodwind ; class Brass extends Wind { public void play(int note) { System.out.println( Brass.play() + n); public String what() {return Brass ;

26 接口接口所有方法默认为 public interface Instrument { void play(int note) ; String what(); interface Instrument { public void play(int note) ; public String what();

27 接口接口所有数据默认为 final static 定义常量 interface Week { int MONDAY = 1; int TUESDAY = 2; int WEDNESDAY = 3; int THURSDAY = 4; int FRIDAY = 5; int SATURDAY = 6; int SUNDAY = 7; class Week { public static final int MONDAY = 1; public static final int TUESDAY = 2; public static final int WEDNESDAY = 3; public static final int THURSDAY = 4; public static final int FRIDAY = 5; public static final int SATURDAY = 6; public static final int SUNDAY = 7;

28 接口接口定义实现多个接口扩展接口接口适配器应用 : 工厂模式

29 接口一个类实现多个接口 Interface Plane void fly() Interface Boat void sail() implements Seaplane void fly() void sail()

30 接口一个类实现多接口 interface Plane { void fly(); interface Boat { void sail(); class Seaplane implements Plane, Boat { public void fly(){ System.out.println( Fly! ); public void sail(){ System.out.println( Sail! );

31 接口问题 : 如果将接口替换成普通类会如何? Interface Plane Interface Boat Plane Boat void fly() void sail() void fly() void sail() implements? extends Seaplane Seaplane void fly() void sail() void fly() void sail()

32 接口多继承问题 Diamond problem Transportation void forward() void backward() Seaplane s = new Seaplane(); // s.forward() which one? extends Plane void forward() void backward() void fly() Boat void forward() void backward() void sail() extends Seaplane void forward() void backward() void fly() void sail()

33 接口多继承问题父类只能有一个普通类 / 抽象类 class A { class B { /* error class C extends A, B { */

34 接口 Abstract or Concrete Base class interface 1 interface 2 interface n Base class methods interface 1 interface 2... interface n Methods of the derived class

35 interface CanFight { void fight(); interface CanSwim { void swim(); interface CanFly { void fly(); class ActionCharacter { public void fight() { class Hero extends ActionCharacter Implements CanFight, CanSwim, CanFly{ public void fly() { public void swim() { public class Adventure { public static void t(canfight x) { x.fight(); public static void u(canswim x) { x.swim(); public static void v(canfly x) { x.fly(); public static void w(actioncharacter x) { x.fight(); public static void main(string []args) { Hero h = new Hero(); t(h); u(h); v(h); w(h); 1. 实现多个接口可以 upcast 到不同的类 2. abstract class or interface?

36 接口实现多个接口名字冲突 interface I1 { void f(); class C1 implements I1, I2{ public void f() { interface I2 { void f(); interface I3 { void f(int i); interface I4 { int f(); class C2 implements I1, I3{ public void f() { public void f(int i) { /* compile error: return type incompatible class C2 implements I1, I4{ public void f() { */

37 接口接口定义实现多个接口扩展接口接口适配器应用 : 工厂模式

38 接口扩展接口 interface A { interface B extends A{ interface D { interface D extends A, C{

interface Monster { void menace(); interface DangerousMonster extends Monster{ void destroy(); class DragonZilla implements DangerousMonster{ public void menace() { public void destroy() { public

39 interface Monster { void menace(); interface DangerousMonster extends Monster{ void destroy(); class DragonZilla implements DangerousMonster{ public void menace() { public void destroy() { public class HorrorShow { public static void u(monster x) { x.menace(); public static void v(dangerousmonster x) { x.menace(); x.destroy(); public static void w(lethal x) { x.kill(); public static void main(string []args) { DangerousMonster m = DangerousZilla(); u(m); v(m); Vampire a = VeryBadVampire(); u(a); v(a); w(a); interface Lethal { void kill(); interface Vampire extends DangerousMonster, Lethal{ void drinkblood(); class VeryBadVampire implements Vampire{ public void menace() { public void destroy() { public void kill() { public void drinkblood() {

40 接口接口定义实现多个接口扩展接口接口适配器应用 : 工厂模式

41 接口接口适配器 (Adapter) 方法 f(interface1 i) 类 A 已经写好, 但在并没有实现 Interface1 接口希望方法 f() 能处理类 A 的对象复用方法 f() 的代码

42 interface CanFly { void fly(); class Bird implements CanFly{ public void fly() { class Person { public void walk(){ public void buyticket(){ public void takeflight(){ class Insect implements CanFly{ public void fly() {? class Adventure { public static void travel(canfly c) { c.fly(); public static void main(string []args){ Bird b = new Bird(); Insect ins = new Insect(); travel(b); travel(ins);

43 interface CanFly { void fly(); class Person { public void walk(){ public void buyticket(){ public void takeflight(){ class Adventure { public static void travel(canfly c) { c.fly(); public static void main(string []args){ Bird b = new Bird(); Insect ins = new Insect(); travel(b); travel(ins); Person p = new Person(); PersonAdapter pd = new PersonAdapter(p); travel(pd); class PersonAdapter implements CanFly{ private Person p; public PersonAdapter(Person p{ this.p = p; public void fly(){ p.buyticket(); p.takeflight();

44 接口接口适配器通过增加一个接口的实现, 使得现有类能够被适配到该接口

45 接口接口适配器 Existing class (Person) Adapter (PersonAdapter) Existing interface (CanFly)

46 接口接口定义实现多个接口扩展接口接口适配器应用 : 工厂模式

47 接口应用 : 工厂模式更灵活的构造对象方式

48 interface Service { void method1(); void method2(); class Impl1 implements Service { public void method1() { System.out.println( Imp1.method1 ); public void method2() { System.out.println( Imp1.method2 ); public class TestService { public static void consume(service s) { s.method1(); s.method2(); public static void main(string []args){ Service s1 = new Impl1(); Service s2 = new Impl2(); consume(s1); consume(s2); class Impl2 implements Service { public void method1() { System.out.println( Imp2.method1 ); public void method2() { System.out.println( Imp2.method2 ); 当构造对象 / 初始化比较繁琐时, 可以增加一层包装

49 interface Service { void method1(); void method2(); class Impl1 implements Service { public void method1() { System.out.println( Imp1.method1 ); public void method2() { System.out.println( Imp1.method2 ); class Impl2 implements Service { public void method1() { System.out.println( Imp2.method1 ); public void method2() { System.out.println( Imp2.method2 ); interface ServiceFactory { Service getservice(); class Impl1Factory implements ServiceFactory { public Service getservice() { return new Impl1(); class Impl2Factory implements ServiceFactory { public Service getservice() { return new Impl2(); public class TestService { public static void consume(servicefactory sf) { Service s = sf.getservice(); s.method1(); s.method2(); public static void main(string []args){ ServiceFactory sf1 = new Impl1Factory(); ServiceFactory sf2 = new Impl2Factory(); consume(sf1); consume(sf2);

50 总结抽象类抽象方法 : 只给出方法的名字, 参数, 返回值, 没有具体实现抽象类 : 包含抽象方法的类 abstract 关键字接口所有的方法都是抽象方法 interface, inplements 关键字接口的扩展 : extends 实现多个接口接口适配器

OOP with Java 通知 Project 4: 推迟至 4 月 25 日晚 9 点

OOP with Java Yuanbin Wu cs@ecnu OOP with Java 通知 Project 4: 推迟至 4 月 25 日晚 9 点复习 Protected 可以被子类 / 同一包中的类访问, 不能被其他类访问弱化的 private 同时赋予 package access class MyType { public int i; public double d; public