《C++程序设计》中简述面向对象方法的出发点和基本原则

1编程模型

所有计算机均由两种元素组成:代码和数据精确的说,有些程序是围绕着"什么正在发生"而编写,有些则是围绕"谁正在受影响"而编写的

第一种编程方式叫做"面向过程的模型",按这种模型编写的程序以一系列的线性步骤(代码)为特征,可被理解为作用于数据的代码如 C 等过程化语言

第二种编程方式叫做"面向对象的模型",按这种模型编写的程序围绕着程序的数据(对象)和针对该对象而严格定义的接口来组织程序,它的特点是数据控制代码的访问通过把控制权转移到数据上,面向对象的模型在组织方式上有:抽象,封装,继承和多态的好处

2抽象

面向对象程序设计的基本要素是抽象,程序员通过抽象来管理复杂性

管理抽象的有效方法是使用层次式的分类特性,这种方法允许用户根据物理含义分解一个复杂的系统,把它划分成更容易管理的块例如,一个计算机系统是一个独立的对象而在计算机系统内部由几个子系统组成:显示器,键盘,硬盘驱动器,DVD-ROM,软盘,音响等,这些子系统每个又由专门的部件组成关键是需要使用层次抽象来管理计算机系统(或其他任何复杂系统)的复杂性

面向对象程序设计的本质:这些抽象的对象可以被看作具体的实体,这些实体对用来告诉我们作什么的消息进行响应

/ (我的理解)

计算机是一个实体,我要输入字符,显示器显示出来,那么

计算机(对象)输入(键盘属性)显示(显示方法)

使用分层来引用, *** 作而不用管计算机内部如何处理

只要有计算机对象,它就能响应我的 *** 作,而我敲键盘,

计算机对象就把这个消息传给屏幕,屏幕显示

/

计算机对象包含了它所有的属性,以及 *** 作,这就是面向对象程序设计的三大原则之一:封装

3封装

封装是一种把代码和代码所 *** 作的数据捆绑在一起,使这两者不受外界干扰和误用的机制封装可被理解为一种用做保护的包装器,以防止代码和数据被包装器外部所定义的其他代码任意访问对包装器内部代码与数据的访问通过一个明确定义的接口来控制封装代码的好处是每个人都知道怎样访问代码,进而无需考虑实现细节就能直接使用它,同时不用担心不可预料的副作用

在JAVA中,最基本的封装单元是类,一个类定义着将由一组对象所共享的行为(数据和代码)一个类的每个对象均包含它所定义的结构与行为,这些对象就好象是一个模子铸造出来的所以对象也叫做类的实例

在定义一个类时,需要指定构成该类的代码与数据特别是,类所定义的对象叫做成员变量或实例变量 *** 作数据的代码叫做成员方法方法定义怎样使用成员变量,这意味着类的行为和接口要由 *** 作实例数据的方法来定义

由于类的用途是封装复杂性,所以类的内部有隐藏实现复杂性的机制所以JAVA中提供了私有和公有的访问模式,类的公有接口代表外部的用户应该知道或可以知道的每件东西私有的方法数据只能通过该类的成员代码来访问这就可以确保不会发生不希望的事情

4继承

继承是指一个对象从另一个对象中获得属性的过程是面向对象程序设计的三大原则之二,它支持按层次分类的概念例如,波斯猫是猫的一种,猫又是哺乳动物的一种,哺乳动物又是动物的一种如果不使用层次的概念,每个对象需要明确定义各自的全部特征通过层次分类方式,一个对象只需要在它的类中定义是它成为唯一的 各个属性,然后从父类中继承它的通用属性因此,正是由于继承机制,才使得一个对象可以成为一个通用类的一个特定实例一个深度继承的子类将继承它在类层次中的每个祖先的所有属性

继承与封装可以互相作用如果一个给定的类封装了某些属性,它的任何子类将会含有同样得属性,另加各个子类所有得属性这是面向对象程序在复杂性上呈线性而非几何增长的一个重要概念新的子类继承其所有祖先的所有属性子类和系统中的其他代码不会产生无法预料的交互作用

5多态

多态是指一个方法只能有一个名称,但可以有许多形态,也就是程序中可以定义多个同名的方法,用"一个接口,多个方法"来描述可以通过方法的参数和类型引用

6封装,继承,多态的组合使用

在由封装，继承,多态所组成的环境中,程序员可以编写出比面向过程模型更健壮,更具扩展性的程序经过仔细设计的类层次结构是重用代码的基础封装能让程序员不必修改公有接口的代码即可实现程序的移植多态能使程序员开发出简洁,易懂,易修改的代码例如:汽车

从继承的角度看,驾驶员都依靠继承性来驾驶不同类型(子类)的汽车,无论这辆车是轿车还是卡车,是奔驰牌还是菲亚特牌,驾驶员都能找到方向盘,手刹,换档器经过一段时间驾驶后,都能知道手动档与自动档之间的差别,因为他们实际上都知道这两者的共同超类:传动装置

从封装的角度看,驾驶员总是看到封装好的特性刹车隐藏了许多复杂性,其外观如此简单,用脚就能 *** 作它发动机,手刹,轮胎大小的实现对与刹车类的定义没有影响

从多态的角度看,刹车系统有正锁反锁之分,驾驶员只用脚踩刹车停车,同样的接口可以用来控制若干种不同的实现(正锁或反锁)

这样各个独立的构件才被转换为汽车这个对象的同样,通过使用面向对象的设计原则,程序员可以把一个复杂程序的各个构件组合在一起,形成一个一致,健壮,可维护的程序

第1章 Java语言基础知识

14基本数据类型与表达式

141变量与常量

标识符命名的规则 必须字母、“_”或“￥”开头

final声明了一个常量

142基本数据类型

数字型 布尔型boolean 字符型char

143表达式与运算符

144类型转换

扩展转换

窄化转换

15数组

1、数组声明 int[] arryname; int[] a=new int[8];

2、数组的初始化:

3、数组元素的引用

第2章 类与对象的基本概念

21面向对象程序设计的特征

1、抽象(过程抽象和数据抽象)

2、封装

3、继承（继承与派生、派生、重用）Java只支持单继承

4、多态

22类与对象

1、类和对象的含义（类是对象的抽象，是对象的模板；对象是类的实例）

2、类的声明

[public][abstract/final] class 类名称[<Type {,Type}>][extends 父类名称][implements 接口名称列表]{

成员变量（变量成员声明及初始化）

成员方法（方法声明及方法体）

}（类体）

3、对象的创建

类名 对象名 = new 类名(实参列表);

or

类名 对象名;

对象名=new 类名();

4、类的数据成员

没有static修饰的变量称为实例变量，有static修饰的变量称为类变量

实例变量：<实例名><实例变量名>， xradious

类变量：<实例名/类名><类变量名> xPI CirclePI(类变量在整个类中只有一个值)

5、类的方法成员

[public|protected|private][static][final][abstract][native][synchronized][<Type{,Type}>]返回类型 方法名([参数列表])

{

方法体

}

<对象名><方法名>([参数列表])

实例方法：

类方法：要加static修饰符，类方法表示具体实例的类中对象的共有行为，在使用时可以将类方法发送给类名

6、成员的访问权限getF方法，set方法，this的用法（若形参与实参变量名相同，在实参变量前加this）

23对象初始化和回收

构造方法：作用、特征

构造函数是写在类体中的。

特征：构造方法的方法名与类名相同，构造方法没有返回类型，构造方法通常被声明为公有的（public）,构造方法可以有多个参数，构造方法主要作用是完成对象的初始化工作，构造方法不能再程序中显示的调用，在生成一个对象时系统会紫铜调用该类的构造方法为新生成的对象初始化。

第3章 类的方法

增强型for循环

for(数组类型 变量名：数组名){

}

第4章 类的重用

41类的继承

1、继承的含义和作用

派生出来了类称为子类

已有的类称为超类（父类）、基类

java只支持单继承，通过接口来实现多继承

2、继承语法

[ClassModifier] class ClassName [extends SuperClassName] [implement interface]

{}//类体

子类不能直接访问从父类中继承的私有属性及方法，但可以使用公有（及保护）方法进行访问。可以用get()方法来获取

3、隐藏和覆盖

隐藏和覆盖是指子类对从父类继承来的属性变量及方法可以重新加以定义。

属性的隐藏：子类对父类继承来的属性变量重新加以定义，则从父类的继承的属性将被隐藏。super域名来访问被隐藏的父类域。

子类不能继承父类中的静态属性，但可以对父类中的静态属性进行 *** 作。

方法的覆盖：如果子类不需要使用从父类继承来的方法功能，则可以声明自己的方法。在声明的过程中，使用相同的方法名及参数，但执行不同的功能。

4、继承时的构造方法

构造方法是类的一种特殊方法，他可以重载，但不能从父类继承。

可以调用父类的构造方法super(),存在于子类构造函数的第一行。

42Object类

1、Object类是所有类的父类,处在类层次最高点

2、equals（）方法：数值上相等 ，两个对象具有相同的类型及相同的属性值。

3、Object类中的equals()方法，因此所有类都继承了equals()方法，其主要作用是判断两个对象是否同一；如果要判断两个对象是否属性相同，则不能使用Object类中继承的equals()方法，而是在在类中声明对equals()的重写

4、等号==：同一，如果两个引用变量指向的是同一个对象

43终结类与终结方法

1、终结类：含义 特点

如果一个类被Final修饰符定义，说明这个类不可能有子类，即final类不能有派生类

通常有固定的作用、用来完成某种标准功能的类，不能被继承以达到修改的目的

2、终结方法：含义 特点

final修饰符所修饰的方法是功能和内部语句不能被更改的最终方法，，不能被派生类覆盖，即不能被重新改写

44抽象类

1、抽象类:含义、特征

所谓抽象类就是不能使用new 方法进行实例化的类，即没有具体实例对象的类。一个类被声明为抽象类时，要在这个类前加修饰符abstract。

public abstract class Shape{

//类体

}

作用是让其他类来继承它的抽象化的特征，在抽象类中可以包括被他的所有子类共享的公共属性，不能作为模板创造实例

抽象类有构造函数

2、抽象方法：含义 特征

public abstract <returnType><methodName>(…);//没有方法体

返回类型 方法名

一个抽象类的子类如果不是抽象类，则他必须为父类中所有抽象方法书写方法体，即重写父类中所有的抽象方法，只有抽象类才能拥有抽象方法，除了抽象方法，抽象类还包括非抽象类。

46类的组合

1、继承：纵向

2、组合：横向

第5章接口与多态

51接口

1、接口含义

与抽象类不同的是：接口允许在看起来不相干的类之间定义共同行为

2、接口的声明

[接口修饰符] interface 接口名称 [<Type,{,Type}>][extends 父类名]{…//方法的原型声明或静态常量

}

接口中声明的方法都是抽象方法

在接口声明中，Java允许省略数据成员的final关键字、方法public及abstract关键字

3、接口的特征

4、接口的实现

利用接口构造类的过程，称为接口的实现

[类修饰符]class 类名称 implements 接口名称{}；

完成接口的类必须实现接口中的所有抽象方法，注意在实现一个接口的时候，来自接口的方法必须声明成public。具体实现一个接口后，就获得了一个普通的类，可以用标准的方式对其进行扩充。

5、多重继承

一个类可以有多个接口，可实现多继承。

[类修饰符]class 类名称 Implements 接口1，接口2…

{

…

}

6、接口的扩展（继承）

interface 子接口的名称 extends 父接口的名称1，父接口的名称2，……

{……

}

52塑型

1、塑型的含义(自定义对象类型的转换)

对象只能被塑性为任何一个父类类型，对象所属的类实现的一个接口，或者回到他自己所在的类。

2、塑料的原则

对于对象，塑性并不是转换，而仅仅是将对象暂时当成更一般的对象来对待，并没有改变其类型。

3、方法的查找（实例方法）

当子类对象塑性成父类之后，若子类和父类有共同的方法，则先在子类中调用此方法，如果不存在，才会到父类中调用该方法。

53多态的概念

1、多态：含义 作用

2、绑定的概念

3、多态的应用（二次分发）

55构造方法与多态

构造方法不存在多态

第8章多线程

81多线程编程基础

1、线程的概念

如果要实现一个程序中多段代码同时并发执行，急需要产生多个线程，并指定每个线程上所要运行的程序段，这就是多线程，有两种方法：继承Thread类和实现Runnable 接口

2、用Thread类实现多线程

class TestThread extends Thread{//声明一个类继承Thread类

public void run(){

for(int i=0;i<20;i++){

Systemoutprintln("执行了自定义线程"+i);

}

Systemoutprintln("自定义线程结束！");

}

}

/1声明类，继承Thread类

2重写Thread类的Run方法

3定义对象，调用线程start()方法

start作用：

启动线程

调用run方法

/

public class Test1 {

public static void main(String[] args) {

TestThread tt=new TestThread();

ttstart();

for(int i=0;i<20;i++){

Systemoutprintln("执行了主线程"+i);

}

Systemoutprintln("主线程结束！");

}

}

——————————————————test2————————————————

class TestTicket extends Thread{

private int num=20;

public void run(){

while(num>0){

Systemoutprintln(ThreadcurrentThread()getName()+"#####"+num--);

}

}

}

public class Test2 {

public static void main(String[] args) {

TestTicket tt0=new TestTicket();

TestTicket tt1=new TestTicket();

TestTicket tt2=new TestTicket();

tt0start();

tt1start();

tt2start();

}

}

3、用Runnable接口实现多线程

/1声明类TestTicket,实现Runnable接口

2在TestTicket类中，重写Runnable接口的Run()方法

3在main方法中，建立TestTicket类的对象tt

4声明Thread类的对象t0,t1,t2,用tt作为调用构造方法的实参Thread t0=new Thread(tt)

3通过Thread类建立线程对象

4将Runnable接口的子类对象作为调用Thread类的构造方法

5调用Thread类的start()方法，开启线程，并调用Runnable接口子类TestTicket的run()方法/

class TestTicket implements Runnable{

private int num=1000;

private Object obj=new Object();

public void run() {

while(true){

synchronized(obj){

if(num>0){

try {

Threadsleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

eprintStackTrace();

}

Systemoutprintln(ThreadcurrentThread()getName()+" ##### "+num);

num--;

}

}

}

}

}

public class Test3 {

public static void main(String[] args) {

TestTicket tt=new TestTicket();

Thread t0=new Thread(tt);//public Thread(Runnable target)target的取值是Runable接口子类的对象

Thread t1=new Thread(tt);

Thread t2=new Thread(tt);

t0start();

t1start();

t2start();//1开启线程2调用tt对象的run方法，t0,t1,t2处理的对象是tt,三个线程共享tt的数据

//Thread t3=new Thread();

//t3start();//1开启线程2调用Thread类的run方法是空的

}

}4、多线程间的同步控制

类就是相同的数据和相同的一组对象的集合，即类是对具有相同数据结构和相同 *** 作的一类对象的描述；对象是描述其属性的数据以及对这些数据施加的一组 *** 作封装在一起构成的统一体，对象可以认为是：数据＋ *** 作；类和对象之间的关系是抽象和具体的关系。修改

1、Smalltalk：

Smalltalk，被公认为历史上第二个面向对象的程序设计语言，和第一个真正的集成开发环境（IDE）。

Smalltalk对其它众多的程序设计语言的产生起到了极大的推动作用，主要有：C++，C#，Objective-C，Actor，Java和Ruby等。90年代的许多软件开发思想得利于Smalltalk，例如设计模式、敏捷编程和代码重构等。

2、Eiffel：

Eiffel语言是继Smalltalk-80之后的另一个“纯”OOPL。这种语言是由OOP领域中著名的专家Bertrand Meyer等人20世纪80年代后期在ISE公司开发的，它的主要特点是全面的静态类型化、有大量的开发工具、支持多继承。

3、C++：

C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计，因而C++就适应的问题规模而论，大小由之。

4、java：

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。

Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

扩展资料

面向对象语言既可以用面向对象语言实现，也可以用非面向对象语言实现。面向对象程序设计语言本身就支持面向对象概念的实现，其编译程序可以自动地实现面向对象概念到目标程序的映射。

面向对象的采用方法从问题域表示到面向对象分析，再到面向对象设计与实现始终稳定不变。一致的表示方法不但有利于在软件开发过程中始终使用统一的概念，也有利于维护人员理解软件的各种配置成分。

概述C++语言特点

C++是由C发展而来的，与C兼容。用C语言写的程序基本上可以不加修改地用于C++。从C++的名字可以看出它是C的超越和集中。下面是我整理的关于概述C++语言特点，希望大家认真阅读!

面向对象的程序设计是在面向过程的程序设计的基础上一个质的飞跃。要学会面向对象的程序设计，首先要学会一种面向对象的语言，即要学会用VC编程，就要先有C++的基础，而学习C++语言首先要认识它面向对象的特性和实现面向对象的方法。

C++语言是一种面向对象的程序设计语言

当你首次学习C++时，总会碰到一些在C++语言从未见过的概念，如：类、对象、抽象、封装、继承、多态性、虚函数等等。这些概念是C++所具有，下面简单的介绍一下C++ 对面向对象程序设计方法的支持和实现。

1、C++支持数据封装支持数据封装就是支持数据抽象。在C++中，类是支持数据封装的工具，对象则是数据封装的实现。面向过程的程序设计方法与面向对象的程序设计方法在对待数据和函数关系上是不同的。

在面向对象的程序设计中，将数据和对该数据进行合法 *** 作的函数封装在一起作为一个类的定义，数据将被隐藏在封装体中，该封装体通过 *** 作接口与外界交换信息。对象被说明具有一个给定类的变量，类类似于C语言中的结构，在C语言中可以定义结构，但这种结构中包含数据，而不包含函数。C++语言中的类是数据和函数的封装体。在C++中，结构可作为一种特殊的类，它虽然可以包含函数，但是它没有私有或保护的成员。

2、C++类中包含私有、公有和保护成员C++类中可定义三种不同访控制权限的成员。一种是私有(Private)成员，只有在类中说明的函数才能访问该类的私有成员，而在该类外的函数不可以访问私有成员;另一种是公有(Public)成员，类外面也可访问公有成员，成为该类的接口;还有一种是保护 (Protected)成员，这种成员只有该类的派生类可以访问，其余的在这个类外不能访问。

3、C++语言中通过发关消息来处理对象C++中是通过向对象发关消息来处理对象的，每个对象根据所接收到的消息的性质来决定需要采取的行动，以响应这个消息。响应这些消息是一系列的方法，方法是在类定义中使用函数来定义的，使用一种类似于函数调用的机制把消息发送到一个对象上。

4、C++中允许友元破坏封装性类中的私有成员一般是不允许该类外面的任何函数访问的，但是友元便可打破这条禁令，它可以访问该类的私有成员(包含数据成员和成员函数)。友元可以是在类外定义的函数，也可以是在类外定义的整个类，前者称友元函数，后者称为友元类。友元打破了类的封装性，它是C++语言另一个面向对象的重要牲。

5、C++允许函数名和运算符重载C++支持多态性，C++允许一个相同的标识符或运算符代表多个不同实现的函数，这就称标识符或运算符的重载，用户可以根据需要定义标识符重载或运算符重载。

6、C++支持继承性C++中可以允许单继承和多继承。一个类可以根据需要生成派生类。派生类继承了基类的所有方法，另外派生类自身还可以定义所需要的不包含在父类中的新方法。一个子类的每个对象包含有从父类那里继承来的数据成员以及自己所特有的数据成员。

7、C++语言支持动态联编C++中可以定义虚函数，通过定义虚函数来支持动态联编。以上是所讲的是C++对面向对象程序设计中的一些主要特征的支持。C++的词法及词法规则1、C++的字符集字符是一些可以区分的最小符号。C++的字符集由大小写英文字母(a-z和A-Z)、数据字符(0-9)、特殊字符(空格，!，#，%，^，&，，_，<，>，，，,)组成。

扩展： C语言和C++之间的关系

C语言和C++之间的关系

C++ 读作”C加加“，是”C Plus Plus“的简称。

顾名思义，C++是在C的基础上增加新特性，玩出了新花样，所以叫”C Plus Plus“，就像 iPhone 7 和 iPhone 6、Win10 和 Win7 的关系。

C语言是1972年由美国贝尔实验室研制成功的，在当时算是高级语言，它的很多新特性都让汇编程序员羡慕不已，就像今天的Go语言，刚出生就受到追捧。C语言也是”时髦“的语言，后来的很多软件都用C语言开发，包括 Windows、Linux 等。

但是随着计算机性能的飞速提高，硬件配置与几十年前已有天壤之别，软件规模也不断增大，很多软件的体积都超过 1G，例如 PhotoShop、Visual Studio 等，用C语言开发这些软件就显得非常吃力了，这时候C++就应运而生了。

C++ 主要在C语言的基础上增加了面向对象和泛型的机制，提高了开发效率，以适用于大中型软件的编写。

C++和C的血缘关系

早期并没有”C++“这个名字，而是叫做”带类的C“。

”带类的C“是作为C语言的一个扩展和补充出现的，目的是提高开发效率，如果你有Java Web开发经验，那么你可以将它们的关系与 Java 和 JSP 的关系类比。

这个时期的C++非常粗糙，仅支持简单的面向对象编程，也没有自己的编译器，而是通过一个预处理程序(名字叫 cfront)，先将C++代码”翻译“为C语言代码，再通过C语言编译器合成最终的程序。

随着C++的流行，它的语法也越来越强大，已经能够很完善的支持面向对象编程和泛型编程。

但是一直也没有诞生出新的C++编译器，而是对原来C编译器不断扩展，让它支持C++的新特性，所以我们通常称为C/C++编译器，因为它同时支持C和C++，例如 Windows 下的微软编译器(clexe)，Linux 下的 GCC 编译器。

也就是说，你写的C、C++代码都会通过一个编译器来编译，很难说C++是一门独立的语言，还是对C的扩展。

C++是在C语言的基础上进行的扩展，C++包含了C语言的全部内容。

;

大学中，虽然很多专业都会学习c语言，但是专门学习c语言的专业是计算机专业。

计算机专业是计算机硬件与软件相结合、面向系统、侧重应用的宽口径专业。通过基础教学与专业训练，培养基础知识扎实、知识面宽、工程实践能力强，具有开拓创新意识，在计算机科学与技术领域从事科学研究、教育、开发和应用的高级人才。本专业开设的主要课程有：电子技术、离散数学、程序设计、数据结构、 *** 作系统、计算机组成原理、微机系统、计算机系统结构、编译原理、计算机网络、数据库系统、软件工程、人工智能、计算机图形学、数字图像处理、计算机通讯原理、多媒体信息处理技术、数字信号处理、计算机控制、网络计算、算法设计与分析、信息安全、应用密码学基础、信息对抗、移动计算、数论与有限域基础、人机界面设计、面向对象程序设计等。

C语言是面向过程的，面向过程语言的程序代码=算法+数据结构，而C++和JAVA是面向对象的语言，程序代码=对象+消息。

我认为面向对象和面向过程就没有本质的区别，只是使用不同的方法和角度去观察一个世界。软件设计就像写剧本，数据就是角色，流程就是情节，整个软件就象一部**，面向对象只不过是把数据和对这类数据的处理捆绑在一起，在设计情节的时候就不必关心某个角色是如何完成某个动作的，只要安排各个角色按顺序完成动作就好了。而面向过程怎么做呢？那就是安排各个角色按顺序完成动作，而如何完成动作参见第几章第几节或下面的注解。

从程序上或者剧本上看，面向对象就是先描述角色的特点和如何完成各种动作，然后才是具体情节；面向过程就是先描述角色的特点，然后讲述情节，情节中对角色如何完成某个动作再写一个小说明。从组织上看，面向对象的方法组织得更好更清楚一些，而没有更多的不同。

至于派生和继承只是把同类角色具有的相同特点和动作放在一起描述罢了，因为这个角色和那个角色与其它的角色相比在某个方面相同或类似，所以把它们分为一类，这个类就成了一个基类了，例如老师和作家都是知识分子，那么就在这里一起描述一些知识分子具有什么共同的特点，而不再在老师这类角色和作家这类角色里赘述了。

1、Smalltalk

Smalltalk被公认为历史上第二个面向对象的程序设计语言和第一个真正的集成开发环境 (IDE)。由Alan Kay，Dan Ingalls，Ted Kaehler，Adele Goldberg等于70年代初在Xerox PARC开发。

Smalltalk对其它众多的程序设计语言的产生起到了极大的推动作用，主要有:Objective-C，Actor， Java 和Ruby等。90年代的许多软件开发思想得利于Smalltalk，例如Design Patterns， Extreme Programming(XP)和Refactoring等。

2、Eiffel

Eiffel语言是继Smalltalk-80之后的另一个"纯"OOPL。这种语言是由OOP领域中著名的专家Bertrand Meyer等人20世纪80年代后期在ISE公司(Interactive Software Engineering Inc)开发的，它的主要特点是全面的静态类型化、有大量的开发工具、支持多继承。

3、C++

C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。

C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计，因而C++就适应的问题规模而论，大小由之。

4、Java

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。

Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。

Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等 。

扩展资料：

面向对象程序设计的原则：

1、单一职责原则：一个对象应该只包含单一的职责，并且该职责被完整地封装在一个类中。

单一职责原则是实现高内聚、低耦合的要素。类的职责主要包括两个方面：数据职责和行为职责，数据职责是通过其属性来体现的，行为职责是通过其方法来体现。如果职责过多将导致系统非常的脆弱，类被复用的可能性就越少，一个职责可能会影响其他职责。

2、开闭原则：一个软件实体应当对扩展开放，对修改关闭。

任何软件都需要面临一个问题，当软件系统需要面对新的需求时，我们要保证系统的设计框架是稳定的。为了满足开闭原则，需要对系统进行抽象化设计，抽象化是开闭原则的关键。百分百的开闭原则很难达到，但是要尽量使系统设计符合开闭原则。

3、里氏代换原则：所有引用基类（父类）的地方必须透明地使用其子类的对象。

里氏代换原则是实现开闭原则的重要方式之一，由于使用基类对象的地方都可以使用子类对象，因此在程序中尽量使用基类类型来对对象进行定义，而在运行时再确定其子类类型，用子类对象代替父类对象。子类的所有方法必须在父类中声明，或子类必须实现父类中声明的所有方法。

4、依赖倒转原则：高层模块不应该依赖低层模块，他们都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

依赖倒转原则是面向对象设计的主要手段。在代码中使用抽象类，而具体类放在配置文件中。里氏代换原则是依赖倒转原则的基础。如果系统行为发生变化，只需要扩展抽象层，并修改配置文件，而无需修改原有系统的源代码，满足开闭原则的设计要求。

5、接口隔离原则：客户端不应该依赖那些他不需要的接口。

首先需要满足单一职责原则。将一组相关的 *** 作定义在一个接口中，在满足高内聚的前提下，接口中的方法越少越好。可以在进行系统设计时采用定制服务的方式。

6、合成复用原则定义：尽量使用对象组合，而不是继承来达到复用的目的。

通过继承来实现复用很简单，而且子类易于扩展。但其主要问题是会破坏系统的封装性，继承会将基类的实现细节暴露给子类。同时没有足够的灵活性，如果基类发生变化，子类的实现也不得不发生改变。

7、迪米特法则原：每一个软件单位对其他的单位都只有最少的知识，而且局限于那些与本单位密切相关的软件单位。

在类的结构设计上，每一个类都应当尽量降低其成员变量和成员函数的访问权限。在类的设计上，只要有可能，一个类型应当设计成不变类。一个对象对其他对象的引用，应当降到最低。

参考资料：

百度百科-面向对象程序设计语言

以上就是关于《C++程序设计》中简述面向对象方法的出发点和基本原则全部的内容，包括:《C++程序设计》中简述面向对象方法的出发点和基本原则、求C语言代码、什么是类什么是对象对象与类的关系是什么等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！