Java编程思想重点阐述（部分容易模糊的概念）

末蓝、 2022-06-14 04:37 209阅读 0赞

1、Java 采用三个显式（明确）关键字以及一个隐式（暗示）关键字来设置类边界：

public，private，protected 以及暗示性的friendly。若未明确指定其他关键字，则默认为后者。这些关键字的使用和含义都是相当直观的，它们决定了谁能使用后续的定义内容。

“public”（公共）意味着后续的定义任何人均可使用。

“private”（私有）意味着除您自己、类型的创建者以及那个类型的内部函数成员，其他任何人都不能访问后续的定义信息。private 在您与客户程序员之间竖起了一堵墙。若有人试图访问私有成员，就会得到一个编译期错误。

“friendly ”（友好的）涉及“包装”或“封装”（Package）的概念——即Java 用来构建库的方法。若某样东西是“友好的”，意味着它只能在这个包装的范围内使用（所以这一访问级别有时也叫作“包装访问”）。

“protected”（受保护的）与“private”相似，只是一个继承的类可访问受保护的成员，但不能访问私有成员。

通过这些边界定义，使库建设者可以保护自己设计的库不被使用者破坏。

2、许多人认为代码或设计方案的重复使用是面向对象的程序设计提供的最伟大的一种杠杆。

为重复使用一个类，最简单的办法是仅直接使用那个类的对象。但同时也能将那个类的一个对象置入一个新类。我们把这叫作“创建一个成员对象”。新类可由任意数量和类型的其他对象构成。无论如何，只要新类达到了设计要求即可。这个概念叫作“组织”——在现有类的基础上组织一个新类。有时，我们也将组织称作“包含”关系，比如“一辆车包含了一个变速箱”。

对象的组织具有极大的灵活性。新类的“成员对象”**通常设为“私有”**（Private），使用这个类的客户程序员不能访问它们。这样一来，我们可在不干扰客户代码的前提下，从容地修改那些成员。也可以在“运行期”更改成员，这进一步增大了灵活性。然而“继承”并不具备这种灵活性，因为编译器必须对通过继承创建的类加以限制。

由于继承的重要性，所以在面向对象的程序设计中，它经常被重点强调。作为新加入这一领域的程序员，或许早已先入为主地认为“继承应当随处可见”。沿这种思路产生的设计将是非常笨拙的，会大大增加程序的复杂程度。相反，新建类的时候，首先应考虑“组织”对象；这样做显得更加简单和灵活。利用对象的组织，我们的设计可保持清爽。一旦需要用到继承，就会明显意识到这一点。

3、“继承”是针现有类进行克隆和添加修改而设计的。但继承并不完全等价于克隆。在继承过程中，若原始类（正式名称叫作基础类、超类或父类）发生了变化，修改过的“克隆”类（正式名称叫作继承类或者子类）也会反映出这种变化。在Java 语言中，继承是通过extends 关键字实现的使用继承时，相当于创建了一个新类。这个新类不仅包含了现有类型的所有成员（尽管private 成员被隐藏起来，且不能访问），但更重要的是，它复制了基础类的接口。也就是说，可向基础类的对象发送的所有消息亦可原样发给衍生类的对象。根据可以发送的消息，我们能知道类的类型。这意味着衍生类具有与基础类相同的类型！

**为真正理解面向对象程序设计的含义，首先必须认识到这种类型的等价关系。**

由于基础类和衍生类具有相同的接口，所以那个接口必须进行特殊的设计。也就是说，对象接收到一条特定的消息后，必须有一个“方法”能够执行。若只是简单地继承一个类，并不做其他任何事情，来自基础类接口的方法就会直接照搬到衍生类。这意味着衍生类的对象不仅有相同的类型，也有同样的行为，这一后果通常是我们不愿见到的。

有两种做法可将新得的衍生类与原来的基础类区分开。

第一种做法十分简单：为衍生类添加新函数（功能）。这些新函数并非基础类接口的一部分。进行这种处理时，一般都是意识到基础类不能满足我们的要求，所以需要添加更多的函数。这是一种最简单、最基本的继承用法，大多数时候都可完美地解决我们的问题。

第二个办法是改变基础类一个现有函数的行为。我们将其称作“改善”那个函数。也就是我们常说的“**重载**”。为改善一个函数，只需为衍生类的函数建立一个新定义即可。我们的目标是：“尽管使用的函数接口未变，但它的新版本具有不同的表现”。

4、![Image 1][]

对这样的一系列类，我们要进行的一项重要处理就是将衍生类的对象当作基础类的一个对象对待。这一点是非常重要的，因为它意味着我们只需编写单一的代码，令其忽略类型的特定细节，只与基础类打交道。这样一来，那些代码就可与类型信息分开。所以更易编写，也更易理解。此外，若通过继承增添了一种新类型，如“三角形”，那么我们为“Shape”新类型编写的代码会象在旧类型里一样良好地工作。所以说程序具备了“扩展能力”，具有“扩展性”。

以上面的例子为基础，假设我们用Java 写了这样一个函数：  
void doStuff(Shape s)

\{  
s.erase();  
// ...  
s.draw();

\}  
这个函数可与任何“几何形状”（Shape）衍生类及基础类通信，所以完全独立于它要描绘（draw）和删除（erase）的任何特定类型的对象。如果我们在其他一些程序里使用doStuff()函数：  
Circle c = new Circle();  
Triangle t = new Triangle();  
Line l = new Line();  
doStuff(c);  
doStuff(t);  
doStuff(l);  
**那么对doStuff()的调用会自动良好地工作，无论对象的具体类型是什么。**  
这实际是一个非常有用的编程技巧。请考虑下面这行代码：  
doStuff(c);  
此时，一个Circle（圆）句柄传递给一个本来期待Shape（形状）句柄的函数。由于圆是一种几何形状，所以doStuff()能正确地进行处理。也就是说，凡是doStuff()能发给一个Shape 的消息，Circle 也能接收。所以这样做是安全的，不会造成错误。  
我们将这种把衍生类型当作它的基本类型处理的过程叫作“Upcasting”（上溯造型）。其中，“cast”（造型）是指根据一个现成的模型创建；而“Up”（向上）表明继承的方向是从“上面”来的——即基础类位于顶部，而衍生类在下方展开。所以，根据基础类进行造型就是一个从上面继承的过程，即“Upcasting”。  
在面向对象的程序里，通常都要用到上溯造型技术。这是避免去调查准确类型的一个好办法。请看看doStuff()里的代码：  
s.erase();  
// ...  
s.draw();  
注意它并未这样表达：“如果你是一个Circle，就这样做；如果你是一个Square，就那样做；等等”。若那样编写代码，就需检查一个Shape 所有可能的类型，如圆、矩形等等。这显然是非常麻烦的，而且每次添加了一种新的Shape 类型后，都要相应地进行修改。在这儿，我们只需说：“你是一种几何形状，我知道你能将自己删掉，即erase()；请自己采取那个行动，并自己去控制所有的细节吧。”

将一条消息发给对象时，如果并不知道对方的具体类型是什么，但采取的行动同样是正确的，这种情况就叫作“多形性”（Polymorphism）。

对面向对象的程序设计语言来说，它们用以实现多形性的方法叫作“动态绑定”。在C++中，“动态绑定”这个关键字是virtual。在Java 中，我们则完全不必记住添加一个关键字，因为函数的动态绑定是自动进行的。

5、我们经常对abstract关键字使用感到迷糊，究竟创造他有何意义。

（1）设计程序时，我们经常都希望基础类只为自己的衍生类提供一个接口。也就是说，我们不想其他任何人实际创建基础类的一个对象，只对上溯造型成它，以便使用它们的接口。为达到这个目的，需要把那个类变成“抽象”的——使用abstract 关键字。若有人试图创建抽象类的一个对象，编译器就会阻止他们。这种工具可有效强制实行一种特殊的设计。这是比较重要的作用。  
（2）可用abstract 关键字描述一个尚未实现的方法——作为一个“根”类使用，指出：“这是适用于从这个类继承的所有类型的一个接口函数，但目前尚没有对它进行任何形式的实现。”抽象方法也许只能在一个抽象类里创建。但在其他类继承了之后，那个方法就必须实现，否则继承的类也会变成“抽象”类。通过创建一个抽象方法，我们可以将一个方法置入接口中，不必再为那个方法提供可能毫无意义的主体代码。

6、interface（接口）关键字将抽象类的概念更延伸了一步，它完全禁止了所有的函数定义。“接口”是一种相  
当有效和常用的工具。另外如果自己愿意，亦可将多个接口都合并到一起（不能从多个普通class 或abstract class 中继承）。interface的作用就是进行一个分类作用，使编程者对要创建的对象有一个有效的分类合并。

一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

接口定义的一般形式为：

\[访问控制符\]interface <接口名> \{

类型标识符final 符号常量名n = 常数；

返回值类型 方法名(\[参数列表\]);

…

**接口的特点：**

1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"\_"分隔)

2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化

3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法

4、接口中没有构造方法,不能被实例化

5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口

6、Java接口必须通过类来实现它的抽象方法

7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类

8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例

9、一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.

**接口的用法**

1、精简程序结构，免除重复定义

比如，有两个及上的的类拥有相同的方法，但是实现功能不一样，就可以定义一个接口，将这个方法提炼出来，在需要使用该方法的类中去实现，就免除了多个类定义系统方法的麻烦。

举例：鸟类和昆虫类都具有飞行的功能，这个功能是相同的，但是其它功能是不同的，在程序实现的过程中，就可以定义一个接口，专门描述飞行。

下图是分别定义鸟类和昆虫类，其都有飞行的方法。

![1341984229_9858.png][]

下图定义了接口，其类图如下：

![1341984239_5276.png][]

实现代码如下：

**\[java\]** [view plain][] [copy][view plain]

1.  **interface** Flyanimal\{ 
2.  **void** fly(); 
3.  \} 
4.  **class** Insect \{ 
5.  **int** legnum=6; 
6.  \} 
7.  **class** Bird \{ 
8.  **int** legnum=2; 
9.  **void** egg()\{\}; 
10. \} 
11. **class** Ant extendsInsect **implements** Flyanimal \{ 
12. **public****void** fly()\{ 
13.  System.out.println("Ant can fly"); 
14.  \} 
15. \} 
16. classPigeon **extends** Bird **implements** Flyanimal \{ 
17. **public****void** fly()\{ 
18.  System.out.println("pigeon can fly"); 
19.  \} 
20. **public****void** egg()\{ 
21.  System.out.println("pigeon can lay eggs "); 
22.  \} 
23. \} 
24. **public** classInterfaceDemo\{ 
25. **public****static****void** main(String args\[\])\{ 
26.  Ant a=**new** Ant(); 
27.  a.fly(); 
28.  System.out.println("Ant's legs are"\+ a.legnum); 
29.  Pigeon p= **new** Pigeon(); 
30.  p.fly(); 
31.  p.egg(); 
32.  \} 
33. \}

程序运行结果：

**Ant can fly**

**Ant'slegs are 6**

**pigeon can fly**

**pigeon can lay eggs**

二、拓展程序功能，应对需求变化。

假设一个学校接待方面的程序，招待不同身份的人的食宿问题，其对应规则如下：

理论上，当然可以对每个不同身份的人各定义一个对应的类，并实现各自的方法，但是观察这写类，可以归纳出其有一个共同的模板，即“人”的“食、宿”问题。这时候，就可以发挥接口的功能了。实现代码如下：

**\[java\]** [view plain][] [copy][view plain]

程序执行结果：

学生去食堂吃饭！

学生回寝室睡觉！

教师去教工餐厅吃饭！

教师回学校公寓睡觉！

家长去招待所饭馆吃饭！

家长回招待所睡觉！

现在需要添加一些功能，即现在需要添加“外宾、上级领导”两类角色，并且以后工具需要还要添加相应的身份角色的人进来，此时，只需要根据需要添加“外宾”类、“领导”类，而主类仍然可以拿来就用，无需进行更多的修改。此时就可以显示出接口的作用了。

在上面的程序中添加如下两个类即可。

**\[java\]** [view plain][] [copy][view plain]

1.  **class** Foreign **implements** Person\{ 
2.   publicvoid eat()\{ 
3.   System.out.println("外宾去酒店吃饭！"); 
4.   \} 
5.  **public****void** sleep()\{ 
6.   System.out.println("外宾回酒店睡觉！"); 
7.   \} 
8.  \} 
9.  
10. **class** Leader **implements** Person\{ 
11.  publicvoid eat()\{ 
12.  System.out.println("领导去宾馆吃饭！"); 
13.  \} 
14. **public****void** sleep()\{ 
15.  System.out.println("外宾回宾馆睡觉！"); 
16.  \} 
17. \}

而主函数中用法仍然一样。

下面给出完整的代码：

**\[java\]** [view plain][] [copy][view plain]

1.  interfacePerson\{ 
2.  **void** eat(); 
3.  **void** sleep(); 
4.  \} 
5.  
6.  **class** Studentimplements Person\{ 
7.  **public****void** eat()\{ 
8.   System.out.println("学生去食堂吃饭！"); 
9.   \} 
10. **public****void** sleep()\{ 
11.  System.out.println("学生回寝室睡觉！"); 
12.  \} 
13. \} 
14. 
15. **class** Teacherimplements Person\{ 
16. **public****void** eat()\{ 
17.  System.out.println("教师去教工餐厅吃饭！"); 
18.  \} 
19. **public****void** sleep()\{ 
20.  System.out.println("教师回学校公寓睡觉！"); 
21.  \} 
22. \} 
23. **class** Parents **implements** Person\{ 
24.  publicvoid eat()\{ 
25.  System.out.println("家长去招待所饭馆吃饭！"); 
26.  \} 
27. **public****void** sleep()\{ 
28.  System.out.println("家长回招待所睡觉！"); 
29.  \} 
30. \} 
31. **class** Foreign **implements** Person\{ 
32.  publicvoid eat()\{ 
33.  System.out.println("外宾去酒店吃饭！"); 
34.  \} 
35. **public****void** sleep()\{ 
36.  System.out.println("外宾回酒店睡觉！"); 
37.  \} 
38. \} 
39. 
40. **class** Leader **implements** Person\{ 
41.  publicvoid eat()\{ 
42.  System.out.println("领导去宾馆吃饭！"); 
43.  \} 
44. **public****void** sleep()\{ 
45.  System.out.println("领导回宾馆睡觉！"); 
46.  \} 
47. \} 
48. 
49. **public****class** PersonInterface\{ 
50. **public****static****void** main(String\[\] args) 
51.  \{ 
52.  Person p=**new** Student(); 
53.  p.eat(); 
54.  p.sleep(); 
55.  p=**new** Teacher(); 
56.  p.eat(); 
57.  p.sleep(); 
58.  p=**new** Parents(); 
59.  p.eat(); 
60.  p.sleep(); 
61.  p=**new** Foreign(); 
62.  p.eat(); 
63.  p.sleep(); 
64.  p=**new** Leader(); 
65.  p.eat(); 
66.  p.sleep(); 
67.  \} 
68. \}

程序执行结果：

学生去食堂吃饭！

学生回寝室睡觉！

教师去教工餐厅吃饭！

教师回学校公寓睡觉！

家长去招待所饭馆吃饭！

家长回招待所睡觉！

外宾去酒店吃饭！

外宾回酒店睡觉！

领导去宾馆吃饭！

领导回宾馆睡觉！

举例二：

用来计算每一种交通工具运行1000公里所需的时间，已知每种交通工具的参数都是3个整数A、B、C的表达式。现有两种工具：

Car 和Plane，其中Car 的速度运算公式为：A\*B/C

Plane 的速度运算公式为：A+B+C。

如果增加第3种交通工具的时候，比如火车（Train）不必修改以前的任何程序，只需要编写新的交通工具的程序。

**\[java\]** [view plain][] [copy][view plain]

1.  **import** java.lang.\*; 
2.  **interface** Common \{ 
3.  **double** runTimer(**double** a, **double** b, **double** c); 
4.   String getName(); //获取交通工具的名称
5.  \} 
6.  
7.  **class** Plane implementsCommon \{ 
8.  **public** doublerunTimer(**double** a, **double** b, **double** c) \{ 
9.  **return** (a+ b + c); 
10.  \} 
11. **public** String getName()\{ 
12. **return**"Plane"; 
13.  \} 
14. \} 
15. **class** Car **implements** Common \{ 
16. **public** doublerunTimer(**double** a, **double** b, **double** c) \{ 
17. **return** ( a\*b/c ); 
18.  \} 
19. **public** String getName()\{ 
20. **return**"Car"; 
21.  \} 
22. \} 
23. 
24. **public****class** ComputeTime \{ 
25. 
26. **public****static****void** main(Stringargs\[\]) \{ 
27. **double** A=3; 
28. **double** B=5; 
29. **double** C=6; 
30. **double** v,t; 
31.  Commond=**new** Car(); 
32.  v=d.runTimer(A,B,C); 
33.  t=1000/v; 
34.  System.out.println(d.getName()+"的平均速度: "\+v+" km/h"); 
35.  System.out.println(d.getName()+"的运行时间："\+t+" 小时"); 
36.  d=newPlane(); 
37.  v=d.runTimer(10,30,40); 
38.  t=1000/v; 
39.  System.out.println(d.getName()+"的平均速度: "\+v+" km/h"); 
40.  System.out.println(d.getName()+"的运行时间："\+t+" 小时"); 
41.  \} 
42. \}

程序运行结果；

Car的平均速度: 2.5 km/h

Car的运行时间：400.0 小时

Plane的平均速度: 80.0 km/h

Plane的运行时间：12.5 小时

[Image 1]: 
[1341984229_9858.png]: https://img-my.csdn.net/uploads/201207/11/1341984229_9858.png
[1341984239_5276.png]: https://img-my.csdn.net/uploads/201207/11/1341984239_5276.png
[view plain]: http://blog.csdn.net/liujun13579/article/details/7736116/#