《 Java 编程思想》CH08 多态
- 在面向对象的程序设计语言中，多态是继数据抽象和继承之后的第三种基本特征。
- 多态通过分离做什么和怎么做，从另一个角度将接口和实现分离开来。
- “封装”通过合并特征和行为来创建新的数据类型。“实现隐藏”则通过将细节“私有化”把接口和实现分离开来，而多态的作用则是消除类型之间的耦合关系。
再论向上转型 & 转机
- 对象既可以作为它自己本身的类型使用，也可以作为它的基类使用，而这种把某个对象的引用视为其基类的引用的做法被称为“向上转型”
- 将一个方法调用同一个方法主体关联起来被称为绑定。
- 若在程序执行前进行绑定（如果有的话，由编译器和链接器实现），叫做前期绑定。
- 若在运行时根据对象的类型进行绑定，则叫做后期绑定，也叫做动态绑定或运行时绑定。
- Java 中除了 static 方法和 final 方法（private 方法属于 final 方法）外，其他所有方法都是后期绑定的。
- Java 用动态绑定实现了多态后，我们可以只编写与基类相关的代码，而这些代码可以对所有该基类的导出类正确运行。
- 多态的例子可以参考练习2。
- 在一个设计良好的 OOP 程序中，大多数或所有方法都只与基类接口通信。这样的程序是可扩展的，因为可以从通用的基类继承出新的数据类型，从而新添加一些功能。
- 域没有多态。
- 如果一个方法是静态的，那么它的行为就不具有多态性。静态方法是与类，而不是与单个对象相关联的。
- 由于 final 方法是无法覆盖的，所以 private 也是无法覆盖的，因此没办法进行动态绑定。即只有非 private 方法可以覆盖，但是“覆盖”private 方法编译器不会报错，但运行结果往往与预期不符：
package com.company.ch08;
public class PrivateOverride {
private void func() {
System.out.println("private func()");
}
public static void main(String[] args) {
PrivateOverride privateOverride = new Derived();
privateOverride.func();
}
}
class Derived extends PrivateOverride {
public void func() { // 这里其实没有覆盖。
System.out.println("Derived func()");
}
}
// private func()
构造器和多态
构造器不具有多态性，它们实际上是 static 方法，只不过该 static 是隐式声明的。
构造器的调用顺序
- 基类的构造器总是在导出类的构造过程中调用，而且按照继承层次逐渐向上链接，以使每个基类的构造器都能得到调用。
- 在导出类的构造器主体中，如果没有明确指定调用某个基类构造器，它会默默地调用默认构造器。如果不存在默认构造器，编译器就会出错（如果某个类没有任何构造器，则编译器会给他添加一个默认构造器）
构造器的调用顺序：
- 调用基类构造器。
- 按照声明顺序调用成员的初始化方法。
- 调用导出类的构造器的主体。
继承与清理
Java 中通常不需要考虑清理的问题，垃圾回收机制会解决大部分问题，但是如果真的需要进行清理操作时，我们需要手动调用某个特定的函数进行清理操作。因为继承的原因，我们在覆盖基类的清理函数时，需要调用基类版本的清理函数。通常在导出类清理函数的末尾。同时如果成员对象也有需要清理的话，也需要在清理函数中调用该成员的清理函数。调用的原则就是：清理的顺序应该与初始化的顺序相同。
如果某些成员对象存在于其他一个或多个对象共享的情况下，我们不能简单的调用其清理函数，我们可以使用“引用计数”来跟踪访问着共享对象的对象数量（就是C++中的shared_ptr）。
构造器内部的多态方法的行为：
如果在一个构造器的内部调用正在构造的对象的某个动态绑定方法，会发生什么？
package com.company.ch08;
class Glyph {
void draw() {
System.out.println("Glyph.draw()");
}
Glyph() {
System.out.println("Glyph() before draw()");
draw();
System.out.println("Glyph() after draw()");
}
}
class RoundGlyph extends Glyph {
private int radius = 1;
RoundGlyph(int r) {
radius = r;
System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);
}
@Override
void draw() {
System.out.println("RoundGlyph.draw(), radius = " + radius);
}
}
public class PolyConstructors {
public static void main(String[] args) {
new RoundGlyph(5);
}
}
// Glyph() before draw()
// RoundGlyph.draw(), radius = 0
// Glyph() after draw()
// RoundGlyph.RoundGlyph(), radius = 5
从上面的输出可以看出，在基类中调用动态方法，的确会调用到对应导出类的方法，但是导出类的域却未完成初始化。
初始化实例的过程：
- 在其他任何事物发生之前，将分配给对象的存储空间初始化成二进制的零
- 调用基类构造器
- 按声明顺序调用成员的初始化方法
- 调用导出类的构造器主题。
在构造器内唯一能够安全调用的那些方法是基类中 final 方法（private 方法属于 final 方法）
协变返回类型
Java SE5 中添加了协变返回类型，它表示在导出类中的被覆盖方法可以返回基类方法的返回类型的某种导出类型。
package com.company.ch08;
class Grain {
@Override
public String toString() {
return "Grain";
}
}
class Wheat extends Grain {
@Override
public String toString() {
return "Wheat";
}
}
class Mill {
Grain process() {
return new Grain();
}
}
class WheatMill extends Mill {
@Override
Wheat process() { // 关键在这里，原本返回类型应该是 Grain，而这里使用了 Grain 的导出类 Wheat
return new Wheat();
}
}
public class CovariantReturn {
public static void main(String[] args) {
Mill mill = new Mill();
Grain grain = mill.process();
System.out.println("grain = " + grain);
mill = new WheatMill();
grain = mill.process();
System.out.println("grain = " + grain);
}
}
// grain = Grain
// grain = Wheat
用继承进行设计
我们应该首先选择“组合”，尤其是不能十分确定应该使用哪种方法时。组合不会强制我们的程序谁叫进入继承的层次结构。而且，组合更加灵活，他可以动态选择类型。
package com.company.ch08;
class Actor {
public void act() {}
}
class HappyActor extends Actor {
@Override
public void act() {
System.out.println("HappyActor");
}
}
class SadActor extends Actor {
@Override
public void act() {
System.out.println("SadActor");
}
}
class Stage {
private Actor actor = new HappyActor();
public void change() {
actor = new SadActor();
}
public void performPlay() {
actor.act();
}
}
public class Transmogrify {
public static void main(String[] args) {
Stage stage = new Stage();
stage.performPlay();
stage.change();
stage.performPlay();
}
}
// HappyActor
// SadActor
我们通过在运行时将引用与不同的对象重新绑定起来，可以让我们在运行期间获得动态灵活性（也称为“状态模式”）。
继承表示行为间的差异，字段表示状态上的变化。
纯继承与扩展
- is-a 关系（纯继承）：只覆盖在基类中已有的方法，不对其进行扩展
- 导出类和基类有完全相同的接口。
- 只需要从导出类向上转型，永远不需要知道正在处理的对象的确切类型
- is-like-a 关系：对基类进行了扩展
- 导出类接口中扩展部分不能被基类访问。
向下转型与运行时类型识别
在 Java 中，所有转型都会得到检查。即使我们只是进行一次普通的加括弧形式的类型转换，在进入运行期时仍然会对其进行检查，如果不是我们想要转换的类型，那么会返回一个 ClassCastException。
练习
练习1
package com.company.ch08;
public class Cycle {
void run() {
System.out.println("Cycle run");
}
}
class Unicycle extends Cycle {
@Override
void run() {
System.out.println("Unicycle run");
}
}
class Bicycle extends Cycle {
@Override
void run() {
System.out.println("Bicycle run");
}
}
class Tricycle extends Cycle {
@Override
void run() {
System.out.println("Tricycle run");
}
}
class Test {
static void ride(Cycle c) {
c.run();
}
public static void main(String[] args) {
Unicycle unicycle = new Unicycle();
Bicycle bicycle = new Bicycle();
Tricycle tricycle = new Tricycle();
unicycle.run();
bicycle.run();
tricycle.run();
}
}
// Unicycle run
// Bicycle run
// Tricycle run
练习2
package com.company.ch08;
public class Shape {
public void draw() {}
public void erase() {}
}
package com.company.ch08;
public class Circle extends Shape{
@Override
public void draw() {
System.out.println("Circle draw");
}
@Override
public void erase() {
System.out.println("Circle erase");
}
}
package com.company.ch08;
public class Square extends Shape{
@Override
public void draw() {
System.out.println("Square draw");
}
@Override
public void erase() {
System.out.println("Square erase");
}
}
package com.company.ch08;
public class Triangle extends Shape {
@Override
public void draw() {
System.out.println("Triangle draw");
}
@Override
public void erase() {
System.out.println("Triangle erase");
}
}
package com.company.ch08;
import java.util.Random;
// 工厂模式
public class RandomShapeGenerator {
private Random random = new Random(47);
public Shape next() {
switch (random.nextInt(3)) {
default:
case 0: return new Circle();
case 1: return new Square();
case 2: return new Triangle();
}
}
}
package com.company.ch08;
public class Shapes {
private static RandomShapeGenerator randomShapeGenerator = new RandomShapeGenerator();
public static void main(String[] args) {
Shape[] shapes = new Shape[9];
for (int i = 0;i < 9;i++) {
shapes[i] = randomShapeGenerator.next();
}
for (Shape shape: shapes) {
shape.draw();
}
}
}
// Triangle draw
// Triangle draw
// Square draw
// Triangle draw
// Square draw
// Triangle draw
// Square draw
// Triangle draw
// Circle draw
练习3
public class Shape {
public void draw() {}
public void erase() {}
public void info() {
System.out.println("Shape info");
}
}
即使导出类没有覆盖它，但是由于继承的原因，导出类任然会有该方法。
package com.company.ch08;
public class Circle extends Shape{
@Override
public void draw() {
System.out.println("Circle draw");
}
@Override
public void erase() {
System.out.println("Circle erase");
}
@Override
public void info() {
System.out.println("Circle info");
}
}
package com.company.ch08;
public class Shapes {
private static RandomShapeGenerator randomShapeGenerator = new RandomShapeGenerator();
public static void main(String[] args) {
Shape[] shapes = new Shape[9];
for (int i = 0;i < 9;i++) {
shapes[i] = randomShapeGenerator.next();
}
for (Shape shape: shapes) {
shape.info();
}
}
}
// Shape info
// Shape info
// Circle info
// Circle info
// Shape info
// Shape info
// Shape info
// Shape info
// Circle info
如果只有一个导出类Circle覆盖了该方法，只有在正式类型为Circle的Shape调用info时，才会调用到覆盖后的方法，而其余的则是调用到基类的方法。
练习4
class Line extends Shape {
@Override
public void draw() {
System.out.println("Line draw");
}
@Override
public void erase() {
System.out.println("Line erase");
}
}
public class Shapes {
private static RandomShapeGenerator randomShapeGenerator = new RandomShapeGenerator();
public static void main(String[] args) {
Shape[] shapes = new Shape[9];
for (int i = 0;i < 9;i++) {
shapes[i] = randomShapeGenerator.next();
}
for (Shape shape: shapes) {
shape.draw();
}
shapes[0] = new Line();
shapes[0].draw();
}
}
//Shape info
//Shape info
//Circle info
//Circle info
//Shape info
//Shape info
//Shape info
//Shape info
//Circle info
练习5
package com.company.ch08;
public class Cycle {
void run() {
System.out.println("Cycle run");
}
int wheels() {
return 0;
}
}
class Unicycle extends Cycle {
@Override
void run() {
System.out.println("Unicycle run");
}
@Override
int wheels() {
return 1;
}
}
class Bicycle extends Cycle {
@Override
void run() {
System.out.println("Bicycle run");
}
@Override
int wheels() {
return 2;
}
}
class Tricycle extends Cycle {
@Override
void run() {
System.out.println("Tricycle run");
}
@Override
int wheels() {
return 3;
}
}
class Test {
static void ride(Cycle c) {
c.run();
}
public static void main(String[] args) {
Unicycle unicycle = new Unicycle();
Bicycle bicycle = new Bicycle();
Tricycle tricycle = new Tricycle();
unicycle.run();
bicycle.run();
tricycle.run();
Cycle[] cycles = new Cycle[]{unicycle, bicycle, tricycle};
for (Cycle cycle: cycles) {
System.out.println("cycle.wheels() = " + cycle.wheels());
}
}
}
// Unicycle run
// Bicycle run
// Tricycle run
// cycle.wheels() = 1
// cycle.wheels() = 2
// cycle.wheels() = 3
练习6
package com.company.ch08;
enum Note {
MIDDLE_C, C_SHARP, B_FLAT;
}
class Instrument {
void play(Note n) {
System.out.println("Instrument.play() n = " + n);
}
@Override
public String toString() {
return "Instrument";
}
void adjust() {
System.out.println("Adusting Instrument");
}
}
class Wind extends Instrument {
@Override
void play(Note n) {
System.out.println("Wind.play() n = " + n);
}
}
class Percussion extends Instrument {
@Override
void play(Note n) {
System.out.println("Percussion.play() n = " + n);
}
@Override
public String toString() {
return "Percussion";
}
@Override
void adjust() {
System.out.println("Adjusting Percussion");
}
}
class Stringed extends Instrument {
@Override
void play(Note n) {
System.out.println("Stringed.play() n = " + n);
}
@Override
public String toString() {
return "Stringed";
}
@Override
void adjust() {
System.out.println("Adjusting Stringed");
}
}
class Brass extends Wind {
@Override
void play(Note n) {
System.out.println("Brass.play() n = " + n);
}
@Override
void adjust() {
System.out.println("Adjusting Brass");
}
}
class Woodwind extends Wind {
@Override
void play(Note n) {
System.out.println("Woodwind.play() n = " + n);
}
@Override
public String toString() {
return "Woodwind";
}
}
public class Music3 {
public static void tune(Instrument i) {
i.play(Note.MIDDLE_C);
}
public static void tuneAll(Instrument[] instruments) {
for (Instrument instrument: instruments) {
tune(instrument);
}
}
public static void main(String[] args) {
Instrument[] instruments = {
new Wind(),
new Percussion(),
new Stringed(),
new Brass(),
new Woodwind(),
};
tuneAll(instruments);
for (Instrument instrument: instruments) {
System.out.println(instrument);
}
}
}
// Wind.play() n = MIDDLE_C
// Percussion.play() n = MIDDLE_C
// Stringed.play() n = MIDDLE_C
// Brass.play() n = MIDDLE_C
// Woodwind.play() n = MIDDLE_C
// Instrument
// Percussion
// Stringed
// Instrument
// Woodwind
练习7
class Piano extends Instrument {
@Override
void play(Note n) {
System.out.println("Piano.play() n = " + n);
}
@Override
public String toString() {
return "Piano";
}
@Override
void adjust() {
System.out.println("Adjusting Piano");
}
}
public class Music3 {
public static void tune(Instrument i) {
i.play(Note.MIDDLE_C);
}
public static void tuneAll(Instrument[] instruments) {
for (Instrument instrument: instruments) {
tune(instrument);
}
}
public static void main(String[] args) {
Instrument[] instruments = {
new Wind(),
new Percussion(),
new Stringed(),
new Brass(),
new Woodwind(),
new Piano(),
};
tuneAll(instruments);
for (Instrument instrument: instruments) {
System.out.println(instrument);
}
}
}
// Wind.play() n = MIDDLE_C
// Percussion.play() n = MIDDLE_C
// Stringed.play() n = MIDDLE_C
// Brass.play() n = MIDDLE_C
// Woodwind.play() n = MIDDLE_C
// Piano.play() n = MIDDLE_C
// Instrument
// Percussion
// Stringed
// Instrument
// Woodwind
// Piano
练习8
class InstrumentGenerator {
private Random random = new Random(42);
public Instrument next() {
switch (random.nextInt(6)) {
default:
case 0: return new Wind();
case 1: return new Percussion();
case 2: return new Stringed();
case 3: return new Brass();
case 4: return new Woodwind();
case 5: return new Piano();
}
}
}
public class Music3 {
public static void tune(Instrument i) {
i.play(Note.MIDDLE_C);
}
public static void tuneAll(Instrument[] instruments) {
for (Instrument instrument: instruments) {
tune(instrument);
}
}
public static void main(String[] args) {
Instrument[] instruments = new Instrument[10];
InstrumentGenerator instrumentGenerator = new InstrumentGenerator();
for (int i = 0;i < 10; i++) {
instruments[i] = instrumentGenerator.next();
}
tuneAll(instruments);
for (Instrument instrument: instruments) {
System.out.println(instrument);
}
}
}
// Stringed.play() n = MIDDLE_C
// Brass.play() n = MIDDLE_C
// Wind.play() n = MIDDLE_C
// Stringed.play() n = MIDDLE_C
// Wind.play() n = MIDDLE_C
// Percussion.play() n = MIDDLE_C
// Piano.play() n = MIDDLE_C
// Stringed.play() n = MIDDLE_C
// Percussion.play() n = MIDDLE_C
// Piano.play() n = MIDDLE_C
// Stringed
// Instrument
// Instrument
// Stringed
// Instrument
// Percussion
// Piano
// Stringed
// Percussion
// Piano
练习9
package com.company.ch08;
public class Rodent {
void eat() {
System.out.println("Rodent.eat()");
}
public static void main(String[] args) {
Rodent[] rodents = new Rodent[] {
new Rodent(),
new Mouse(),
new Gerbil(),
new Hamster(),
};
for (Rodent rodent: rodents) {
rodent.eat();
}
}
}
class Mouse extends Rodent {
@Override
void eat() {
System.out.println("Mouse.eat()");
}
}
class Gerbil extends Rodent {
@Override
void eat() {
System.out.println("Gerbil.eat()");
}
}
class Hamster extends Rodent {
@Override
void eat() {
System.out.println("Hamster.eat()");
}
}
// Rodent.eat()
// Mouse.eat()
// Gerbil.eat()
// Hamster.eat()
练习10
package com.company.ch08;
class Base {
void func1() {
func2();
}
void func2() {
System.out.println("Base");
}
}
public class Ex10 extends Base {
@Override
void func2() {
System.out.println("Ex10");
}
public static void main(String[] args) {
Base base = new Ex10();
base.func1();
}
}
// Ex10
因为func2既不是static也不是final，所以他是动态绑定的，因此基类的 func1 中调用 func2 方法也是调用到导出类的 func2。
练习11
package com.company.ch08;
class Meal {
Meal() {
System.out.println("Meal()");
}
}
class Bread {
Bread() {
System.out.println("Bread()");
}
}
class Cheese {
Cheese() {
System.out.println("Cheese()");
}
}
class Lettuce {
Lettuce() {
System.out.println("Lettuce()");
}
}
class Lunch extends Meal {
Lunch() {
System.out.println("Lunch()");
}
}
class PortableLunch extends Lunch {
PortableLunch() {
System.out.println("PortableLunch()");
}
}
class Pickle {
Pickle() {
System.out.println("Pickle");
}
}
public class Sandwich extends PortableLunch {
private Bread b = new Bread();
private Cheese c = new Cheese();
private Lettuce l = new Lettuce();
private Pickle p = new Pickle();
public Sandwich() {
System.out.println("Sandwich()");
}
public static void main(String[] args) {
new Sandwich();
}
}
练习12
package com.company.ch08;
public class Rodent {
Rodent() {
System.out.println("Rodent");
}
void eat() {
System.out.println("Rodent.eat()");
}
public static void main(String[] args) {
Rodent[] rodents = new Rodent[] {
new Rodent(),
new Mouse(),
new Gerbil(),
new Hamster(),
};
for (Rodent rodent: rodents) {
rodent.eat();
}
}
}
class Mouse extends Rodent {
Mouse() {
System.out.println("Mouse");
}
@Override
void eat() {
System.out.println("Mouse.eat()");
}
}
class Gerbil extends Rodent {
Gerbil() {
System.out.println("Gerbil");
}
@Override
void eat() {
System.out.println("Gerbil.eat()");
}
}
class Hamster extends Rodent {
Hamster() {
System.out.println("Hamster");
}
@Override
void eat() {
System.out.println("Hamster.eat()");
}
}
练习13
package com.company.ch08;
class Shared {
private int refcount = 0;
private static long counter = 0;
private final long id = counter++;
public Shared() {
System.out.println("Create " + this);
}
void addRef() {
refcount++;
}
protected void dispose() {
if(--refcount == 0)
System.out.println("Disposing " + this);
}
@Override
public String toString() {
return "Shared{" +
"id=" + id +
'}';
}
@Override
protected void finalize() throws Throwable {
System.out.println("finalize()");
if (refcount != 0) {
System.out.println("refcount != 0");
}
super.finalize();
}
}
class Composing {
private Shared shared;
private static long counter = 0;
private final long id = counter++;
public Composing(Shared shared) {
System.out.println("Creating " + this);
this.shared = shared;
this.shared.addRef();
}
protected void dispose() {
System.out.println("disposing " + this);
shared.dispose();
}
@Override
public String toString() {
return "Composing{" +
"id=" + id +
'}';
}
}
public class ReferenceCounting {
public static void main(String[] args) {
// Shared shared = new Shared();
// Composing[] composings = {
// new Composing(shared), new Composing(shared),
// new Composing(shared), new Composing(shared),
// new Composing(shared)
// };
//
// for (Composing composing: composings) {
// composing.dispose();
// }
new Composing(new Shared());
System.gc();
}
}
练习14
练习15
package com.company.ch08;
class Glyph {
void draw() {
System.out.println("Glyph.draw()");
}
Glyph() {
System.out.println("Glyph() before draw()");
draw();
System.out.println("Glyph() after draw()");
}
}
class RoundGlyph extends Glyph {
private int radius = 1;
RoundGlyph(int r) {
radius = r;
System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);
}
@Override
void draw() {
System.out.println("RoundGlyph.draw(), radius = " + radius);
}
}
class RectangularGlygh extends Glyph {
private int length;
RectangularGlygh(int length) {
this.length = length;
System.out.println("RectanguarGlygh length = " + length);
}
@Override
void draw() {
System.out.println("RectanguarGlygh.draw() length = " + length);
}
}
public class PolyConstructors {
public static void main(String[] args) {
new RectangularGlygh(10);
}
}
// Glyph() before draw()
// RectanguarGlygh.draw() length = 0
// Glyph() after draw()
// RectanguarGlygh length = 10
练习16
package com.company.ch08;
class Status {
void func() {}
}
class StatusA extends Status {
void func() {
System.out.println("Status A");
}
}
class StatusB extends Status {
void func() {
System.out.println("Status B");
}
}
class StatusC extends Status {
void func() {
System.out.println("Status C");
}
}
class AlterStatus {
Status status = new StatusA();
void A() {
status = new StatusA();
}
void B() {
status = new StatusB();
}
void C() {
status = new StatusC();
}
void call() {
status.func();
}
}
public class Starship {
public static void main(String[] args) {
AlterStatus alterStatus = new AlterStatus();
alterStatus.call();
alterStatus.B();
alterStatus.call();
alterStatus.C();
alterStatus.call();
alterStatus.A();
alterStatus.call();
}
}
// Status A
// Status B
// Status C
// Status A
练习17
package com.company.ch08;
public class Cycle {
void run() {
System.out.println("Cycle run");
}
int wheels() {
return 0;
}
}
class Unicycle extends Cycle {
@Override
void run() {
System.out.println("Unicycle run");
}
@Override
int wheels() {
return 1;
}
void balance() {}
}
class Bicycle extends Cycle {
@Override
void run() {
System.out.println("Bicycle run");
}
@Override
int wheels() {
return 2;
}
void balance() {}
}
class Tricycle extends Cycle {
@Override
void run() {
System.out.println("Tricycle run");
}
@Override
int wheels() {
return 3;
}
}
class Test {
static void ride(Cycle c) {
c.run();
}
public static void main(String[] args) {
Cycle[] cycles = new Cycle[]{new Unicycle(), new Bicycle(), new Tricycle()};
// for(Cycle cycle: cycles) {
// cycle.balance(); // 无法调用
// }
Unicycle unicycle = (Unicycle)cycles[0];
Bicycle bicycle = (Bicycle)cycles[1];
Tricycle tricycle = (Tricycle)cycles[2];
unicycle.balance();
bicycle.balance();
// tricycle.balance(); //无法调用
}
}
首发与Code & Fun
《 Java 编程思想》CH08 多态的更多相关文章
- 【学习笔记】JAva编程思想之多态
1.如果java的基类拥有某个已被多次重载的方法名称,那么在导出类中重新定义该方法名称并不会屏蔽在基类的任何版本.因此,无论是在该层或者他的基类中对方法进行定义,重载机制都可以正常工作. 2.使用@O ...
- Java编程思想之八多态
在面向对象的程序设计语言中,多态是继数据和继承之后的第三张基本特征 多态不但能够改善代码组织结构和可读性,还能够创建可扩展的程序--即无论在项目最初创建时还是在需要添加新功能时都可以"生长& ...
- 《java编程思想》多态与接口
向上转型 定义:把某个对象的引用视为对其基类类型的引用的做法被称为向上转型方法调用绑定 将一个方法调用同一个方法主体关联起来被称作绑定. 前期绑定:程序执行前进行的绑定叫做前期绑定,前期绑定也是jav ...
- （七）《Java编程思想》——多态的缺陷
1.不能“覆盖”私有方法 package chapter8; /** * 不能"覆盖"私有方法 */ public class PrivateOverride { private ...
- Java编程思想(四) —— 复用类
看了老罗罗升阳的专訪,不由自主地佩服,非常年轻,我之前以为和罗永浩一个级别的年龄.也是见过的不是初高中编程的一位大牛之中的一个,专訪之后.发现老罗也是一步一个脚印的人. 别说什么难做,做不了.你根本就 ...
- Java编程思想学习(一)----对象导论中多态的理解
1.1抽象过程 1)万物皆对象. 2)程序是对象的集合,他们通过发送消息来告知彼此所要求做的. 3)每个对象都有自己的由其他对象所构成的存储. 4)每个对象都拥有其类型. 5)某一特定类型的所有对象都 ...
- 《Java编程思想》学习笔记_多态
多态 多态指一个行为产生多种状态,针对父类类型可接收其子类类型,最终执行的状态由具体子类确定,其不同子类可呈现出不同状态.例如人[父类]都会跑步[行为],但小孩[子类]跑步.成年人[子类]跑步.运动员 ...
- 《Java编程思想》学习笔记（二）——类加载及执行顺序
<Java编程思想>学习笔记(二)--类加载及执行顺序 (这是很久之前写的,保存在印象笔记上,今天写在博客上.) 今天看Java编程思想,看到这样一道代码 //: OrderOfIniti ...
- Java编程思想重点笔记（Java开发必看）
Java编程思想重点笔记(Java开发必看) Java编程思想,Java学习必读经典,不管是初学者还是大牛都值得一读,这里总结书中的重点知识,这些知识不仅经常出现在各大知名公司的笔试面试过程中,而 ...
- java编程思想-复用类总结
今天继续读<java 编程思想>,读到了复用类一章,看到总结写的很好,现贴上来,给大家分享. 继承和组合都能从现有类型生成新类型.组合一般是将现有类型作为新类型底层实现的一部分来加以复用, ...
随机推荐
- Spring--2.Spring之IOC--了解IOC容器
IOC(容器),用来集成别的框架 1.IOC(Inversion(反转)Of Control):控制反转 控制:资源的获取方式: 主动式: BookServlet{ BookService bs=ne ...
- 78.纯 CSS 创作 Windows 启动界面
原文地址:https://segmentfault.com/a/1190000015632759 学习后效果地址:https://scrimba.com/c/cPgWmZCg HTML code: & ...
- kafka 中 zookeeper 具体是做什么的？
zookeeper 是 kafka 不可分割的一部分,可见其重要程度,所以我们有必要了解一下 zookeeper 在 kafka 中的具体工作内容. 而且,这也是面试时经常问的. zookeeper ...
- Java入门 - 面向对象 - 01.继承
原文地址:http://www.work100.net/training/java-inheritance.html 更多教程:光束云 - 免费课程 继承 序号 文内章节 视频 1 概述 2 继承的特 ...
- 【杂项】各类文件头结合winhex使用-转载
———常用文件头——— JPEG (jpg),文件头:FFD8FFE1 PNG (png),文件头:89504E47 (0D0A1A0A) GIF (gif),文件头:47494638 ZIP Arc ...
- 深入浅出MyBatis技术原理与实战
第1 章 MyBatis 简介..................................................................................... ...
- web api 的 安全 认证问题 ， 对外开放 的 时候 需要考虑到安全的问题
关于 OWIN OAuth , web api的认证,全局验证, 安全方面的验证 有必要 去 自己捣鼓一下.
- Charles的安装及使用过程
一.charles的使用 1.1 charles的说明 Charles其实是一款代理服务器,通过过将自己设置成系统(电脑或者浏览器)的网络访问代理服务器,然后截取请求和请求结果达到分析抓包的目的.该 ...
- CountDownLatch CyclicBarrier和 Semaphore
CountDownLatch CyclicBarrier和 Semaphore 原理 基于AQS实现. 让需要的暂时阻塞的线程,进入一个死循环里面,得到某个条件后再退出循环,以此实现阻塞当前线程的效果 ...
- C语言博客作业7
本周作业头 这个作业属于那个课程 C语言程序设计II 这个作业要求在哪里 作业链接 我在这个课程的目标是 熟练运用switch语句 这个作业在那个具体方面帮助我实现目标 完成pta作业 参考文献 文章 ...