Java编程思想读书笔记（七）_阅读java编程思想读书笔记

点击蓝字 关注我们

今天是端午节，在这里祝大家端午节安康。过节的同时也不要忘记知识储备，今天我 为大家带来了Java编程思想第七节多形性读书笔记。请大家一起品鉴，如果发现里面有啥写的不对的地方，请大家指出，公众号评论功能还没有开启，大家可以加我微信，与我一起探讨。话不多说，开整。

“对于面向对象的程序设计语言，多形性是第三种最基本的特征（前两种是抽象和继承）”

多形性(Polymorphism)从另一个角度将接口从具体的实施细节分离出来，即实现了“是什么”与“怎么做”两个模块的分离。利用多形性的概念，代码的组织以及可读性均能获得改善。此外还可以创建“易于拓展”的程序。

第一节 上塑造型

上一章的末尾，我们提出来上塑造型这一概念。这一节开头又提出来这一概念。上塑造型是指一个对象作为他自己的类型使用，也可以作为其他对象的基础类型的对象来使用。就是之前我举得那个例子，创建一个哺乳动物的对象，它作为一个基础对象，在创建一个人对象，一个狗对象，一个猫对象，这三个对象以哺乳动物这个基础对象作为基础，继承哺乳动物的方法和属性，又有自己独有的属性，比如人对象，它可以有思考，有感情，有创造性的方法。而猫猫与狗狗对象它们可以有它们独有的方法，比如狗狗它可以看家，猫猫可以抓老鼠。当然他们最终的上塑造型就是哺乳动物。这是我对上塑造型这一概念的理解，有可能不太对。

第二节 深入理解

这一节是对上塑造性这一概念的深入挖掘，说的不只只是第一节那么简单，上塑造性有自己其他的独有特性。

1、方法的调用和绑定

将一个方法调用同一个方法主体连接到一起就称为“绑定（Binding）”。Java中绑定的所有方法都采用后期绑定技术，除非一个方法已被声明成final。这意味着我们通常不必决定是否应进行后期绑定–它是自动发生的。

final关键字在上一节已经介绍啦，为啥要把一个方法设置为final呢？是为了防止其他人覆盖该方法，设置为final的方法，方法是不能随意更改或覆盖的。

2、产生正确行为

刚刚说Java里绑定的方法都采用后期绑定的，具有多形性。举个例子吧。

Shape s = new Circle;
1

这个例子按照Java编程思想画出来的，当我们创建一个Circle对象，并将结果句柄立即赋给一个Shape对象。就像上面的代码，看起来很不合理，但是这个完全符合编译器的认可的。当我们调用Shape基础类里面的方法也是可以的。

3、拓展性

我们以Java编程思想中的乐器（instrument）例子，它的拓展性可以从下面继承它的三个类。基础类为instrument，其余的三个类是对乐器类的拓展。

public class Music3 {
    static void tune(Instrument3 i){
        i.play();
    }
    static void tuneAll(Instrument3[] e){
        for (int i = 0; i < e.length; i++) {
            tune(e[i]);
        }
    }

    public static void main(String[] args) {
        Instrument3[] orachestra = new Instrument3[5];
        int i = 0;
        orachestra[i++] = new Wind3();
        orachestra[i++] = new Percussion3();
        orachestra[i++] = new Stringed3();
        orachestra[i++] = new Brass3();
        orachestra[i++] = new WoodWind3();
        tuneAll(orachestra);
    }
}
class Instrument3 {
    public void play(){
        System.out.println("Instrument3.play()");
    }
    public String what(){
        return "instrumnet3";
    }
    public void adjest() {
    }
}
class Wind3 extends Instrument3{
    public void play(){
        System.out.println("Wind3.play()");
    }
    public String what(){
        return "Wind3";
    }
    public void adjust() {
    }
}
class Percussion3 extends Instrument3{
    public void play(){
        System.out.println("Percussion3.play()");
    }
    public String what(){
        return "Percussion3";
    }
    public void adjust(){

    }
}
class Stringed3 extends Instrument3{
    public void play(){
        System.out.println("Stringed3.play()");
    }
    public String what(){
        return "Stringed3";
    }
    public void adjust(){

    }
}
class Brass3 extends Wind3{
    public void play(){
        System.out.println("Brass3.paly()");
    }
    public void adjust(){
        System.out.println("Brass3.adjust(0");
    }
}
class WoodWind3 extends Wind3{
    public void play(){
        System.out.println("WoodWind3.play()");
    }
    public String what(){
        return "WoodWind3";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

第三节 覆盖与过载

这一节为了我们解释了两个概念“过载”和“覆盖”。

过载：指的是同一样东西在不同的地方具有许多种含义；

覆盖：指的是它随时随地都只有一种含义，只是原先的含义完全被替代了。

其实过载就是方法的重载，方法重载指表示类中允许出现参数不同的同名方法；通俗的说有两个函数，它们的方法名称是一样的，但是参数不一样，所以它们是两个函数，而不是同一个函数。这里用了相同的名称去定义不同的函数，就是方法过载。。

覆盖通俗的说如果在子类中定义一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。

第四节 抽象类和方法

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

1、抽象类

我们可以通过以下方式继承 Employee 类的属性：在 Java 语言中使用 abstract class 来定义抽象类。如下实例：

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number)
{
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public double computePay()
{
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   public void mailCheck()
{
      System.out.println("Mailing a check to " + this.name
       + " " + this.address);
   }
   public String toString()
{
      return name + " " + address + " " + number;
   }
   public String getName()
{
      return name;
   }
   public String getAddress()
{
      return address;
   }
   public void setAddress(String newAddress)
{
      address = newAddress;
   }
   public int getNumber()
{
     return number;
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2、继承抽象类

我们可以通过以下方式继承 Employee 类的属性：

public class Salary extends Employee
{
   private double salary; //Annual salary
   public Salary(String name, String address, int number, double
      salary)
{
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck()
{
       System.out.println("Within mailCheck of Salary class ");
       System.out.println("Mailing check to " + getName()
       + " with salary " + salary);
   }
   public double getSalary()
{
       return salary;
   }
   public void setSalary(double newSalary)
{
       if(newSalary >= 0.0)
       {
          salary = newSalary;
       }
   }
   public double computePay()
{
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

尽管我们不能实例化一个 Employee 类的对象，但是如果我们实例化一个 Salary 类对象，该对象将从 Employee 类继承 7 个成员方法，且通过该方法可以设置或获取三个成员变量。

3、抽象方法

如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。

Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。

抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
}
1
2
3
4
5
6
7
8

声明抽象方法会造成以下两个结果：

如果一个类包含抽象方法，那么该类必须是抽象类。

任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。

如果Salary类继承了Employee类，那么它必须实现computePay()方法：

public class Salary extends Employee
{
   private double salary; // Annual salary
  
   public double computePay()
{
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
 
   //其余代码
}
1
2
3
4
5
6
7
8
9
10
11
12

4、抽象类总结规定

抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

4、抽象类总结规定

抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

第五节 接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

第六节 内部类

Java内部类：一个类嵌套另一个类，嵌套的类就叫做内部类。

内部类有两种类型：

1、非静态内部类

2、静态内部类

1、非静态内部类

非静态内部类是一个类中嵌套着另外一个类。它有访问外部类成员的权限， 通常被称为内部类。

由于内部类嵌套在外部类中，因此必须首先实例化外部类，然后创建内部类的对象来实现。

class OuterClass {
  int x = 10;

  class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、私有的内部类

内部类可以使用 private 或 protected 来修饰，如果你不希望内部类被外部类访问可以使用 private 修饰符。

class OuterClass {
  int x = 10;

  private class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3、静态内部类

静态内部类可以使用 static 关键字定义，静态内部类我们不需要创建外部类来访问，可以直接访问它：

class OuterClass {
  int x = 10;

  static class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass.InnerClass myInner = new OuterClass.InnerClass();
    System.out.println(myInner.y);
  }
1
2
3
4
5
6
7
8
9
10
11
12
13

4、从内部类访问外部类成员

内部类一个高级的用法就是可以访问外部类的属性和方法：

class OuterClass {
  int x = 10;

  class InnerClass {
    public int myInnerMethod() {
      return x;
    }
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.myInnerMethod());
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

第七节 构造器和多形性

构造器与其他种类的方法有区别，在涉及多形性的问题，这种方法依旧成立。

1、构造器调用顺序

构造器调用顺序遵从以下规则：

(1)、调用构造器前应该初始化类的所有属性。

(2)、调用基础类构建器。这个步骤会不断重复下去，直到分级结构的根部（顶级父类），此时根部最先得到构建，然后是下一个衍生类，直到抵达最深一层的衍生类。

(3)、按声明顺序调用初始化模块。

(4)、调用衍生构造器的主体。

2、构造器内部的多形性方法调用（动态绑定）

构造器的调用顺序会带来一个有趣的问题：若当前位于一个构建器的内部，同时调用准备构建的那个对象的一个动态绑定方法，那么会出现什么情况呢？首先我们可以确定的是，动态绑定的调用会在运行期间进行解析，因为对象不知道它到底从属于方法所在的那个类，还是从属于从它衍生出来的某些类。大家也许会认为被调用的方法应该是当前构造器所属对象的方法。但实际情况并非完全如此。若调用构建器内部一个动态绑定的方法，会使用那个方法被覆盖的定义，但调用该方法所产生的效果可能并不如我们所愿。如下范例展示了这种错觉效果。

abstract class Brush {
 
  public Brush() {
    System.out.println("Brush() begin");
    description();
    draw();
    System.out.println("Brush() end");
  }
  
  void description() {
    System.out.println("我是画笔");
  }
  
  abstract void draw();
}
 
class RoundBrush extends Brush {
 
  int radius = 1;
  
  public RoundBrush(int r) {
    radius = r;
    System.out.println("构造了一支可以画半径为" + radius + "的圆形画笔");
  }
  
  @Override
  void description() {
    System.out.println("我是一支可以画半径为" + radius + "的圆形画笔");
  }
  
  @Override
  void draw() {
    System.out.println("圆形画笔开始画半径为" + radius + "的圆");
  }
}
 
public class TestBrush {
  public static void main(String[] args) {
    new RoundBrush(10);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

由运行结果可知，构建器内部调用一个动态绑定的方法确实是被衍生类覆盖的方法，但description()和draw()输出的radius值既不是10，也不是1，而是0。这是因为基础类Brush构造方法执行的时候，衍生类RoundBrush还未实例化，但类属性的初始化已完成（radius为基本数据类型，初始化值为0），所以就出现了description()和draw()输出的radius值为0的结果。

像上述这种不符合期望的效果或者说是错误， 很轻易被人忽略，而且要花很长的时间才能找出。因此，设计构建器时一个特别有效的规则是：用尽可能简单的方法使对象进入就绪状态；如果可能，避免调用任何方法。在构建器内唯一能够安全调用的是在基础类中被final关键字修饰的那些方法（也适用于private方法，它们自动具有final关键字的效果）。因为这些方法不能被覆盖，所以不会出现上述潜在的问题。

总结：

多形性意味着不同的形式，在面向对象的程序设计中很常用。为使用多形性乃至面向对象的技术，当我们设计自己的程序时，我们必须将自己的编程视野拓展到不仅包括单独的类的成员方法和消息。也要包括类与类之间的关系，这样有利与后期的代码维护和拓展。

今天的分享到此结束，篇幅较长，感谢你阅读完，谢谢你对我的支持，觉得写的不错请点赞分享和转发，记得一键三连哦！！2022年6月3日19:43:58

参考资料：

https://www.runoob.com/java/java-interfaces.html

菜鸟教程《java接口》

https://www.runoob.com/java/java-inner-class.html

菜鸟教程《Java内部类》

https://blog.csdn.net/dong24k/article/details/109754112

Java覆盖与重载

https://blog.csdn.net/y1250056491/article/details/80890268

Java构造器的调用顺序和多形性

期待你的

分享

点赞

在看

扫码关注我们

微信号｜Wason_1024

Q    Q ｜1193749320