Java面向对象的总结和综合练习
Java语言面向对象知识小结及答疑
方法重载：在类中存在两个同名的方法，但方法的参数类型不相同。
void print(int x) {…}
void print(int a) {…}
注意，上面写的这两个方法不能叫重载的（参数个数、类型完全相同）
throw new IllegalArgumentException();
for (i=1; i<=num; i++)
n = n * i;
System.out.println(args[0] + "的阶乘是:" + n);
} catch(ArrayIndexOutOfBoundsException e1) {
现在可以这样调用上面的check()方法了：
try {
num = Integer.parseInt(args[0]);
check(num);
for (i=1; i<=num; i++)
n = n * i;
System.out.println(args[0] + "的阶乘是:" + n);
if (num <= 0) {
System.out.println("难道要计算负数的阶乘?");
return;
}
// 计算num的阶乘，存放在n变量中
for (i=1; i<=num; i++)
n = n * i;
方法重写/覆盖：在子类和父中存在两个同名、同参数的方法。
访问修饰符：private，protected，public，(默认)
java面向对象设计知识点总结
java面向对象设计知识点总结Java面向对象（Object-Oriented）编程是一种广泛应用的编程思想，它将现实世界中的事物抽象为对象，并通过定义类、封装、继承和多态等概念来实现程序的设计与开发。
以下是Java面向对象设计中的一些重要知识点的总结和整理。
一、类与对象1. 类（Class）：类是对象的抽象模板，用于描述对象具有的属性和行为。
它可以包含属性（成员变量）和方法（成员函数）。
2. 对象（Object）：对象是类的实例化结果，具有独立的状态和行为。
通过new关键字可以创建对象，并通过对象来访问和调用类中的方法和属性。
3. 属性（成员变量）：属性是类中用于描述对象状态的变量。
它可以是基本数据类型或其他自定义类型。
4. 方法（成员函数）：方法是类中用于描述对象行为的函数。
它定义了类的行为和操作，并对外提供了接口。
二、封装1. 封装（Encapsulation）：封装是面向对象编程的重要特征之一，通过将数据和对数据的操作封装在一起，实现了数据的隐藏和保护。
封装可以提高程序的安全性和可维护性。
2. 访问修饰符（Access Modifiers）：Java提供了四种访问修饰符，分别是public、protected、default（包级访问）和private。
它们用于控制类成员的访问权限。
三、继承1. 继承（Inheritance）：继承是面向对象编程的另一个重要特性，它允许一个类继承另一个类的属性和方法。
通过继承，子类可以重用父类的代码，并且可以在子类中添加新的属性和方法。
2. 继承关系（Inheritance Hierarchy）：Java中的类可以按照父子关系来组织，形成一个继承层次结构。
3. 超类和子类（Superclass and Subclass）：继承关系中，被继承的类称为超类（或父类），继承超类的类称为子类。
4. 方法重写（Method Overriding）：子类可以重写父类中的方法，以实现子类特有的功能。
java面向对象程序设计知识点总结
java面向对象程序设计知识点总结
以下是 Java 面向对象程序设计的一些重要知识点总结：
1. 类和对象：类是对象的抽象，对象是类的实例。
在 Java 中，通过定义类来描述对象的属性和方法。
2. 封装：将对象的属性和方法封装在一起，隐藏对象的内部实现细节，只暴露外部接口。
这有助于提高代码的可维护性和安全性。
3. 继承：允许一个类继承另一个类的属性和方法，从而实现代码的重用和扩展。
Java 中的继承是单一继承，即每个子类只能有一个父类。
4. 多态：指同一个方法在不同的对象上可以有不同的表现形式。
通过方法重写和接口实现来实现多态。
5. 抽象类和接口：抽象类是包含抽象方法的类，不能实例化；接口是只包含抽象方法的抽象类，用于定义一组行为规范。
6. 异常处理：Java 中的异常机制用于处理程序运行时可能发生的错误或异常情况。
通过使用 try-catch 块来捕获和处理异常。
7. 集合框架：Java 提供了丰富的集合类，用于存储和操作一组对象。
包括数组、列表、集合、映射等。
8. 文件 I/O：用于读取和写入文件。
包括文件的创建、打开、读取、写入、关闭等操作。
9. 线程：线程是程序执行的最小单位。
Java 提供了多线程编程的支持，包括创建线程、线程同步、线程通信等。
10. 数据库操作：Java 提供了 JDBC 库来与数据库进行交互，包括连接数据库、执行SQL 查询、处理结果集等。
以上是 Java 面向对象程序设计的一些重要知识点总结，希望对你有所帮助。
java面向对象总结（一）
java⾯向对象总结（⼀）1. 对象的概念及⾯向对象的三个基本特征⾯向对象的三⼤核⼼特性⾯向对象开发模式更有利于⼈们开拓思维，在具体的开发过程中便于程序的划分，⽅便程序员分⼯合作，提⾼开发效率。
⾯向对象程序设计有以下优点。
1. 可重⽤性：它是⾯向对象软件开发的核⼼思路，提⾼了开发效率。
⾯向对象程序设计的抽象、继承、封装和多态四⼤特点都围绕这个核⼼。
2. 可扩展性：它使⾯向对象设计脱离了基于模块的设计，便于软件的修改。
3. 可管理性：能够将功能与数据结合，⽅便管理。
该开发模式之所以使程序设计更加完善和强⼤，主要是因为⾯向对象具有继承、封装和多态 3 个核⼼特性。
继承性如同⽣活中的⼦⼥继承⽗母拥有的所有财产，程序中的继承性是指⼦类拥有⽗类数据结构的⽅法和机制，这是类之间的⼀种关系；继承只能是单继承。
例如定义⼀个语⽂⽼师类和数学⽼师类，如果不采⽤继承⽅式，那么两个类中需要定义的属性和⽅法.语⽂⽼师类和数学⽼师类中的许多属性和⽅法相同，这些相同的属性和⽅法可以提取出来放在⼀个⽗类中，这个⽗类⽤于被语⽂⽼师类和数学⽼师类继承。
当然⽗类还可以继承别的类，学校主要⼈员是⼀个⼤的类别，⽼师和学⽣是学校主要⼈员的两个⼦类，⽽⽼师⼜可以分为语⽂⽼师和数学⽼师两个⼦类，学⽣也可以分为班长和组长两个⼦类。
使⽤这种层次形的分类⽅式，是为了将多个类的通⽤属性和⽅法提取出来，放在它们的⽗类中，然后只需要在⼦类中各⾃定义⾃⼰独有的属性和⽅法，并以继承的形式在⽗类中获取它们的通⽤属性和⽅法即可。
封装性封装是将代码及其处理的数据绑定在⼀起的⼀种编程机制，该机制保证了程序和数据都不受外部⼲扰且不被误⽤。
封装的⽬的在于保护信息，使⽤它的主要优点如下。
保护类中的信息，它可以阻⽌在外部定义的代码随意访问内部代码和数据。
隐藏细节信息，⼀些不需要程序员修改和使⽤的信息，⽐如取款机中的键盘，⽤户只需要知道按哪个键实现什么操作就可以，⾄于它内部是如何运⾏的，⽤户不需要知道。
java 面向对象 练习题
java 面向对象练习题Java面向对象练习题1. 场景描述：小明是一名学生，他参加了一场Java编程的培训。
在课堂上，老师出了一些面向对象的练习题，希望学生能够通过练习加深对Java面向对象的理解。
2. 第一题：设计一个名为"Person"的类，该类包括以下数据成员：- 姓名（name）- 年龄（age）- 性别（gender）并且提供以下方法：- 构造方法（带参数初始化所有数据成员）- getter和setter方法- 显示个人信息的方法（输出姓名、年龄和性别）编写测试类，创建两个Person对象并设置相关属性后，分别通过调用显示个人信息的方法来展示它们的信息。
3. 第二题：设计一个名为"Student"的类，该类继承自Person类，并且新增以下数据成员：- 学号（studentID）- 成绩（score）其中，学号和成绩均为整型数据。
并且提供以下方法：- 构造方法（带参数初始化所有数据成员）- getter和setter方法- 重写父类的显示个人信息的方法，包括学号和成绩的输出编写测试类，创建一个Student对象并设置相关属性后，通过调用显示个人信息的方法展示其信息。
4. 第三题：设计一个名为"Teacher"的类，该类继承自Person类，并且新增以下数据成员：- 工号（teacherID）- 工龄（workingYears）其中，工号为字符串类型，工龄为整型数据。
并且提供以下方法：- 构造方法（带参数初始化所有数据成员）- getter和setter方法- 重写父类的显示个人信息的方法，包括工号和工龄的输出编写测试类，创建一个Teacher对象并设置相关属性后，通过调用显示个人信息的方法展示其信息。
5. 第四题：设计一个名为"Shape"的抽象类，该类包括以下数据成员：- 形状名称（name）并且提供以下方法：- 构造方法（带参数初始化形状名称）- 抽象方法"calculateArea"，用于计算形状的面积设计并实现两个继承自Shape类的具体子类：- 圆形类（Circle）：新增数据成员半径（radius），重写calculateArea方法来计算圆形的面积（3.14 * 半径 * 半径）- 矩形类（Rectangle）：新增数据成员长度（length）和宽度（width），重写calculateArea方法来计算矩形的面积（长度 * 宽度）编写测试类，创建一个Circle对象和一个Rectangle对象并设置相关属性后，分别调用calculateArea方法来计算它们的面积，并输出结果。
JAVA面向对象总结心得(精选3篇)
JA V A面向对象总结心得(精选3篇)JAVA面向对象总结心得第1篇当子类需要父类的功能，而子类有新的内容，可以重写父类中的方法。
在实际开发过程中，随着代码量的逐渐增加，维护成了一个很大的问题，如果需要对某个方法进行修改，其本身代码以及其子类代码都会受到影响，而重写则很好的解决了这个问题。
方法重写又称为方法覆盖、方法复写。
方法签名 = 方法名 + 参数(顺序+类型+个数)当父类和子类的方法签名一致时，我们认为子类重写了父类的方法子类要重写的方法，方法的权限修饰符不能比父类更低（public 、protected 、default 、private 权限依次增加）父类私有的方法，子类不能进行方法重写方法重写：子类和父类中方法相同，两个类之间的关系，函数的返回值类型、函数名、参数列表都一样，当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。
返回值类型、方法名、参数列表必须相同，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。
构造方法无法被重写方法重载：指在同一个类中，多个方法名相同，他们的参数列表不同（个数不同，数据类型不同），同样的一个方法能够根据输入数据的不同，做出不同的处理方法的重写要遵循“两同两小一大”“两同”即方法名相同、形参列表相同；“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。
关于重写的返回值类型这里需要额外多说明一下，上面的表述不太清晰准确：如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改。
但是如果方法的返回值是引用类型，重写时是可以返回该引用类型的子类的。
JAVA面向对象总结心得第2篇封装封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。
但是可以提供一些可以被外界访问的方法来操作属性。
java实训个人总结8篇
java实训个人总结8篇篇1时间过得真快，转眼间我已经实训了4个月了。
在这4个月的时间里，我学到了很多关于Java的知识，也积累了一些工作经验。
现在，我对这段时间的学习和工作进行一下总结，以便更好地反思和提高。
一、Java基础学习在实训初期，我主要学习了Java的基础知识，包括Java的基本语法、面向对象编程的思想、常用的数据结构和算法等。
通过不断练习和巩固，我逐渐掌握了这些基础知识，并能够灵活运用它们来解决实际问题。
二、项目实践在掌握了Java基础之后，我开始了项目实践的阶段。
在这个过程中，我参与了一个小型项目的开发，主要负责后端接口的设计和实现。
通过实践，我深刻体会到了Java在实际应用中的强大之处，同时也锻炼了我的团队协作能力和解决问题的能力。
在项目实践中，我遇到了很多挑战。
例如，在实现某个功能时，我最初的设计方案并不完美，导致后续的修改和调整花费了很多时间和精力。
但是，通过不断学习和摸索，我逐渐找到了更好的解决方案，并成功完成了任务。
这个过程让我深刻认识到了学习和实践的重要性，也让我更加自信地面对未来的工作。
三、团队协作在实训期间，我还锻炼了团队协作的能力。
我们经常需要一起开会讨论、分工合作、共同解决问题。
在这个过程中，我学会了如何与他人有效沟通、如何分工协作、如何处理团队冲突等。
这些能力对于未来的工作和生活都非常有用。
四、自我提升除了学习和项目实践之外，我还注重自我提升。
我不断阅读相关的技术文档和书籍、观看视频和参加线上线下的技术交流活动等。
这些经历不仅让我更加深入地了解了Java技术栈的各个方面，还让我结识了很多志同道合的朋友和业界大咖。
通过与他们的交流和学习，我受益匪浅。
五、总结与展望总的来说，这次Java实训让我收获颇丰。
我不仅掌握了Java的基础知识，还锻炼了项目实践和团队协作的能力。
同时，我也认识到了自己的不足之处并努力加以改进。
在未来的学习和工作中我会继续努力提升自己的技术水平和综合素质以更好地适应市场需求和企业发展需求！篇2一、实训背景与目标本次Java实训旨在通过实践操作，深化理论知识，提高编程技能，以便更好地适应工作岗位需求。
java面向对象编程练习题答案
java面向对象编程练习题答案一、选择题1. 以下哪个是Java面向对象编程的三个基本特征？A. 封装、继承、多态B. 抽象、封装、继承C. 继承、多态、抽象D. 封装、继承、抽象答案：A2. 在Java中，哪个关键字用于定义类？A. classB. interfaceC. abstractD. final答案：A3. 以下哪个是Java中的访问修饰符？A. publicB. staticC. voidD. main答案：A4. 以下哪个是Java中创建对象的语法？A. new Object();B. new ClassName();C. new ClassName().method();D. ClassName();答案：B5. 在Java中，哪个关键字用于实现多态？A. extendsB. implementsB. overrideD. abstract答案：A二、简答题1. 简述Java面向对象编程中的封装性。
答案：封装性是面向对象编程的一个基本概念，它指的是将对象的实现细节隐藏起来，只暴露出一个可以被外界访问的接口。
封装性有助于提高代码的安全性和可维护性。
2. 什么是继承？继承在Java中是如何实现的？答案：继承是一种机制，允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。
在Java中，继承是通过关键字`extends`来实现的。
3. 什么是多态？Java中如何实现多态？答案：多态是指允许不同类的对象对同一消息做出响应的能力，即同一个接口可以被不同的实例以不同的方式实现。
在Java中，多态主要通过方法重载和方法重写来实现。
三、编程题1. 创建一个名为`Animal`的抽象类，它包含一个抽象方法`makeSound()`。
然后创建两个类`Dog`和`Cat`，它们继承自`Animal`类，并分别实现`makeSound()`方法。
答案：```javaabstract class Animal {abstract void makeSound();}class Dog extends Animal {public void makeSound() {System.out.println("Woof!");}}class Cat extends Animal {public void makeSound() {System.out.println("Meow!");}}```2. 编写一个Java程序，使用封装性来创建一个名为`Student`的类，该类包含私有属性`name`和`age`，以及相应的公共方法来设置和获取这些属性。
java实训报告总结与心得(优秀5篇)
java实训报告总结与心得(优秀5篇)java实训报告总结与心得篇1在这次Java实训中，我深入了解了Java编程语言及其面向对象编程的精髓。
通过本次实训，我收获颇丰，不仅加深了对Java语言的理解，也提高了自己的编程能力。
在实训过程中，我遇到了许多问题。
但通过仔细查阅资料和向老师请教，我得以一一解决。
这次实训使我对Java的特性，如封装、继承、多态等有了更深入的理解。
同时，我也熟悉了Java常用的类库和使用方法。
在未来的学习过程中，我将继续努力，争取在Java编程领域取得更大的进步。
我还会加强自己的解决问题的能力，不断提高自己的编程水平。
总之，这次实训对我来说是一次宝贵的经历。
它让我更深入地了解了Java 编程，也让我对自己的学习能力和解决问题的能力有了更大的信心。
java实训报告总结与心得篇2时间过得真快，转眼间，在厦门万策实训基地短短20天的实训生活已悄然过去几天了，然而实训的过程还历历在目。
实训期间，让我学到了很多东西，不仅使我在理论上对IT领域有了全新的认识，在实践能力上也得到了提高，真正地做到了学以致用，更学到了很多做人的道理，对我来说受益匪浅。
除此以外，我还学会了如何更好地与别人沟通，如何更好地去陈述自己的观点，如何说服别人认同自己的观点。
这一次亲身感受到理论与实际的相结合，让我大开眼界。
也是对以前所学知识的一个初审吧！这次实训对于我以后学习、找工作也真是受益匪浅，在短短的20天中相信这些宝贵的经验会成为我今后成功的重要的基石。
作为一名大三的学生，经过差不多三年的在校学习，对程序设计有了理性的认识和理解。
在校期间，一直忙于理论知识的学习，只能偶尔练习一些小程序，没有机会也没有相应的经验来参与项目的开发。
所以在实训之前，软件项目开发对我来说是比较抽象的，一个完整的项目要怎么来分工以及完成该项目所要的基本步骤也不明确。
而经过这次实训，让我明白一个完整项目的开发，必须由团队来分工合作，并在每个阶段中进行必要的总结与论证。
java面向对象试题及答案
java面向对象试题及答案1. 试题一题目：什么是面向对象编程？请简要描述面向对象编程的优势和特点。
答案：面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，将程序中的数据和操作数据的方法进行了封装，使得程序更加模块化和易于理解。
面向对象编程的主要特点包括封装、继承和多态。
封装使得数据和对数据的操作集中在一个对象中，可以隐藏内部实现细节，提供公共的接口进行访问，增加了程序的安全性和灵活性。
继承允许新建的类继承已有类的属性和方法，通过扩展和重写已有类的功能，减少了代码的重复性，提高了代码的复用和可维护性。
多态允许不同的对象对相同的消息作出不同的响应，通过接口和抽象类的使用，实现了更加灵活和可扩展的程序设计。
面向对象编程的优势包括了代码的重用性、可维护性、可扩展性和灵活性。
通过封装和继承的应用，可以减少代码重复，提高开发效率，并且通过多态的应用，可以实现程序的灵活性，方便后续的扩展和修改。
2. 试题二题目：什么是类？请简要描述类的特点和组成部分。
答案：类是面向对象编程中的核心概念，是对一类具有相同属性和行为的对象进行抽象和封装的模板。
类是用来创建对象的蓝图，可以通过实例化类来创建对象。
类的特点包括了封装、继承和多态。
类通过封装将属性和方法进行了封装，提供了公共的接口与外部进行交互，隐藏了内部实现细节。
继承允许新建的类继承已有类的属性和方法，在原有基础上进行修改和扩展。
多态允许不同的对象对相同的消息作出不同的响应，实现了程序的灵活性和可扩展性。
类的组成部分包括了属性（Field）和方法（Method）。
属性（也称为成员变量）用于描述对象的状态，可以是基本类型或其他类的对象。
方法用于描述对象的行为，可以是处理属性的操作，也可以是其他业务逻辑的实现。
3. 试题三题目：请简要解释传值和传引用的区别，并用代码示例说明。
答案：传值和传引用是在方法调用时，参数传递的两种方式。
Java面向对象练习经典题
J a v a面向对象练习经典题(总3页) --本页仅作预览文档封面，使用时请删除本页--JAVA程序作业题1、设计一个包含多个构造函数的类，并分别用这些构造函数实例化对象。
2、编写一个类Calculate1，实现加、减两种运算，然后，编写另一个派生类Calculate2，实现乘、除两种运算。
3、建立三个类：居民、成人、官员。
居民包含身份证号、姓名、出生日期，而成人继承自居民，多包含学历、职业两项数据；官员则继承自成人，多包含党派、职务两项数据。
要求每个类的字段都以属性的方式对外提供数据输入输出的功能。
4、编写一个类，其中包含一个排序的方法sort(),当传入的是一串整数，就按照从小到大的顺序输出，如果传入的是一个字符串，就将字符串反序输出。
5. 编写一个控制台应用程序，定义一个类MyClass，类中包含有public、private以及protected数据成员及方法。
然后定义一个从MyClass类继承的类MyMain，将Main方法放在MyMain中，在Main方法中创建MyClass类的一个对象，并分别访问类中的数据成员及方法。
要求注明在试图访问所有类成员时哪些语句会产生编译错误。
7．创建一个类包含有protected数据。
在相同的文件里创建第二个类，用一个方法操纵第一个类里的protected数据9 编写一个控制台应用程序，完成下列功能，并回答提出的问题。
1) 创建一个类A，在构造函数中输出“A”，再创建一个类B，在构造函数中输出“B”。
2) 从A继承一个名为C的新类，并在C内创建一个成员变量B。
不要为C创建构造函数。
3) 在Main方法中创建类C的一个对象，写出运行程序后输出的结果。
4) 如果在C中也创建一个构造函数输出“C”，整个程序运行的结果又是什么10 编写一个控制台应用程序，完成下列功能，并写出运行程序后输出的结果。
1) 创建一个类A，在A中编写一个可以被重写的带int类型参数的方法MyMethod，并在该方法中输出传递的整型值加10后的结果。
java面向对象试题及答案(二)
java面向对象试题及答案(二)1. 什么是面向对象编程？- 面向对象编程（Object-Oriented Programming，OOP）是一种编程思想，它将现实中的事物抽象成对象，并通过对象之间的交互来完成程序的设计和实现。
2. 面向对象编程的特点有哪些？- 封装性：将数据和方法封装在一起，对外部隐藏实现细节，只提供公共接口。
- 继承性：通过继承可以实现代码复用，减少重复编写代码的工作量。
- 多态性：同一种方法可以有不同的实现方式，提高程序的灵活性和可扩展性。
3. 什么是类和对象？- 类是一种抽象的数据类型，它描述了一类事物的属性和行为。
- 对象是类的一个实例，具有该类所描述的属性和行为。
4. 什么是继承？- 继承是一种机制，它允许新的类在已有类的基础上进行扩展，从而实现代码的复用和扩展性的提高。
5. 什么是多态？- 多态是指同一个方法可以有不同的实现方式，具体的实现方式由调用该方法的对象决定。
6. 什么是重载和重写？- 重载是指在同一个类中定义多个同名方法，但参数列表不同，可以根据参数列表的不同来调用不同的方法。
- 重写是指在子类中重新定义父类中已有的方法，使得子类对象调用该方法时执行子类中的实现。
7. 什么是抽象类和接口？- 抽象类是一种不能被实例化的类，它只能被继承，用于定义一些抽象的方法和属性，子类必须实现这些抽象方法和属性才能被实例化。
- 接口是一种只包含抽象方法和常量的抽象类型，它定义了一些规范，子类必须实现这些抽象方法才能被实例化。
8. 什么是异常？- 异常是指程序在运行过程中出现的错误或意外情况，它会导致程序的中断或崩溃。
Java提供了异常处理机制，可以捕获和处理异常，保证程序的正常运行。
9. 什么是泛型？- 泛型是一种抽象的数据类型，它可以用来定义一种通用的类型，使得代码可以更加灵活和可扩展。
泛型可以在编译时检查类型安全，减少运行时错误。
10. 什么是反射？- 反射是指在程序运行时动态地获取类的信息，包括类的属性、方法和构造器等，可以在运行时动态地创建对象、调用方法和访问属性。
java面向对象编程练习题答案
java面向对象编程练习题答案Java面向对象编程练习题答案Java面向对象编程是计算机科学中非常重要的一部分，它是一种编程范式，通过它可以更好地组织和管理代码。
在学习Java面向对象编程时，经常会遇到一些练习题，下面我们来看一些常见的练习题及其答案。
1. 编写一个Java类，实现一个简单的学生信息管理系统。
```javapublic class Student {private String name;private int age;private String gender;public Student(String name, int age, String gender) { = name;this.age = age;this.gender = gender;}public String getName() {return name;}public int getAge() {return age;}public String getGender() {return gender;}public void setName(String name) { = name;}public void setAge(int age) {this.age = age;}public void setGender(String gender) {this.gender = gender;}}```2. 编写一个Java类，实现一个简单的图书管理系统。
```javapublic class Book {private String title;private String author;private int year;public Book(String title, String author, int year) {this.title = title;this.author = author;this.year = year;}public String getTitle() {return title;}public String getAuthor() {return author;}public int getYear() {return year;}public void setTitle(String title) {this.title = title;}public void setAuthor(String author) { this.author = author;}public void setYear(int year) {this.year = year;}}3. 编写一个Java类，实现一个简单的汽车租赁系统。
《面向对象程序设计(Java)》综合练习题
《面向对象程序设计（Java）》综合练习题一、判断题1、Java程序里，创建新的类对象用关键字new，回收无用的类对象使用关键字free。
2、对象可以赋值，只要使用赋值号（等号）即可，相当于生成了一个各属性与赋值对象相同的新对象。
3、有的类定义时可以不定义构造函数，所以构造函数不是必需的。
4、类及其属性、方法可以同时有一个以上的修饰符来修饰。
5、Java的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点.6、抽象方法必须在抽象类中，所以抽象类中的方法都必须是抽象方法。
7、final类中的属性和方法都必须被final修饰符修饰。
8、最终类不能派生子类，最终方法不能被覆盖。
9、子类要调用父类的方法，必须使用super关键字。
10、一个Java类可以有多个父类。
11、创建新的类对象用new，回收无用的类对象用free。
12、虽然有的类定义时可不定义构造函数，但构造函数是必需的。
13、Java的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点。
14、final类中的属性和方法都必须被final修饰符修饰。
15、子类要调用父类的方法，不必用super关键字。
16、如果p是父类Parent的对象，而c是子类Child的对象，则语句c = p是正确的。
17、当一个方法在运行过程中产生一个异常，则这个方法会终止，但整个程序不一定终止运行。
18、用+可以实现字符串的拼接，用-可以从一个字符串中去除一个字符子串。
19、设String对象s=”Hello”，运行语句System.out.println(s.concat(“w orld!”));后String对象s的内容为”Hello world!”，所以语句输出为：Hello world!20、一个容器中可以混合使用多种布局策略。
参考答案：1、×2、×3、×4、√5、×6、×7、×8、√9、×10、×11、×12、√13、×14、×15、√16、×17、√18、×19、×20、√二、单选题1、关于被私有访问控制符private修饰的成员变量，以下说法正确的是（）A、可被三种类引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类B、只能被该类自身所访问和修改C、只能被同一个包中的类访问D、可被两种类访问和引用：该类本身、该类的所有子类2、下列关于修饰符混用的说法，错误的是（）A、static方法中能处理非static的属性B、abstract方法必须在abstract类中C、abstract类中不可以有private的成员D、abstract不能与final并列修饰同一个类3、容器Panel和Applet缺省使用的布局编辑策略是（）A、BorderLayoutB、FlowLayoutC、GridLayoutD、CardLayout4、main方法是Application的入口点，以下main方法的方法头合法的是（）A、public static void main( )B、public static int main(String[ ] args)C、public static void main(String[ ] arg)D、public void main(String arg[ ])5、以下代码段执行后的输出结果为（）int x=3; int y=10; System.out.println(y%x);A、0B、1C、2D、36、编译运行以下程序后，关于输出结果的说明正确的是（）public class Conditional{public static void main(String args[ ]){int x=4;System.out.println(“value is “+ ((x>4) ? 99.9 : 9));}}A、输出结果为：value is 99.99B、输出结果为：value is 9C、输出结果为：value is 9.0D、编译错误7、以下声明合法的是（）A、public final static native int w( );B、default String s;C、abstract final double hyperbolicCosine( );D、abstract double d;8、关于以下程序代码的说明正确的是（）1．class HasStatic{2．private static int x=100;3．public static void main(String args[ ]){4．HasStatic hs1=new HasStatic( );5．hs1.x++;6．HasStatic hs2=new HasStatic( );7．hs2.x++;8．hs1=new HasStatic( );9．hs1.x++;10．HasStatic.x- -;11．System.out.println(“x=”+x);12．}13．}A、5行不能通过编译，因为引用了私有静态变量B、10行不能通过编译，因为x是私有静态变量C、程序通过编译，输出结果为：x=102D、程序通过编译，输出结果为：x=1039、类Test1定义如下：1．public class Test1{2．public float aMethod（float a，float b）{ }3．4．}将以下哪种方法插入行3是不合法的（）A、public float aMethod (float a，float b，float c) { }B、p ublic float aMethod (float c，float d) { }C、p ublic int aMethod (int a，int b) { }D、private float aMethod (int a，int b，int c) { }10、关于以下程序段，正确的说法是（）1．String s1=”abc” + ”def”;2．String s2=new String(s1);3．if (s1= =s2)4．System.out.print ln(“== succeeded”);5．if (s1.equals(s2))6．System.out.println(“.equals() succeeded”);A、行4与行6都将执行B、行4执行，行6不执行C、行6执行，行4不执行D、行4、行6都不执行11、被私有保护访问控制符private protected修饰的成员变量，以下说法正确的是（）A.可被三种类引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类B.可被两种类访问和引用：该类本身、该类的所有子类C.只能被该类自身所访问和修改D.只能被同一个包中的类访问12、以下标识符中哪项是不合法的（）A、BigMeaninglessNameB、$intC、3kuD、$113、执行完以下代码int [ ] x = new int[25];以下哪项说明是正确的（）A、x[24]为0B、x[24]未定义C、x[25]为0D、x[0]为空14、以下哪个表达式是不合法的（）A、String x=”Hello”; int y=9; x+=y;B、String x=”Hello”; int y=9; if(x= =y) { }C、String x=”Hello”; int y=9; x=x+y;D、String x=null; int y=(x!=null)&&(x.length>0) ? x.length : 015、一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可不相同。
Java程序设计2 面向对象编程(总结)
–
– – – – – – – – – –
class RectDemo3 { public static void main(String args[]) { RectConstructor rect1=new RectConstructor (20,10); RectConstructor rect2=new RectConstructor (6,3); double ar; ar = rect1.area(); System.out.println("第一个长方形的面积是： " + ar); ar = rect2.area(); System.out.println("第二个长方形的面积是： " + ar); } }
第2讲 面向对象编程
2.1.1 类和对象
•对一个用户自定义的类，要为类取一个名字，并指明 类中包含哪些变量和方法以及相应的类型、实现等， 这称为类的定义。类定义语句的一般形式为：
–
– – – –
[修饰符]class 类名 [extends 父类名] [implements 接口名表] { 成员变量声明 // 类体 方法成员声明 }
}
• 程序运行结果如下：
– Subclass : 200 – Superclass : 100
java面向对象基础练习题
java面向对象基础练习题Java面向对象基础练习题Java是一种面向对象的编程语言，它具有强大的面向对象特性和丰富的类库，使得开发者可以更加高效地编写可重用和可维护的代码。
为了巩固对Java面向对象基础的理解和应用，下面将介绍一些常见的练习题。
练习题一：学生类设计一个学生类，包括学生的姓名、年龄、性别和成绩等属性。
要求能够设置和获取学生的各个属性，并能够计算学生的平均成绩。
在主函数中创建多个学生对象，并输出每个学生的信息和平均成绩。
练习题二：图书类设计一个图书类，包括图书的名称、作者和价格等属性。
要求能够设置和获取图书的各个属性，并能够计算图书的折扣价。
在主函数中创建多个图书对象，并输出每本图书的信息和折扣价。
练习题三：汽车类设计一个汽车类，包括汽车的品牌、型号和价格等属性。
要求能够设置和获取汽车的各个属性，并能够计算汽车的年龄。
在主函数中创建多个汽车对象，并输出每辆汽车的信息和年龄。
练习题四：银行账户类设计一个银行账户类，包括账户的账号、姓名和余额等属性。
要求能够设置和获取账户的各个属性，并能够实现存款和取款的操作。
在主函数中创建多个银行账户对象，并进行存款和取款操作。
练习题五：商品类设计一个商品类，包括商品的名称、价格和库存等属性。
要求能够设置和获取商品的各个属性，并能够实现购买和退货的操作。
在主函数中创建多个商品对象，并进行购买和退货操作。
练习题六：手机类设计一个手机类，包括手机的品牌、型号和价格等属性。
要求能够设置和获取手机的各个属性，并能够实现打电话和发短信的操作。
在主函数中创建多个手机对象，并进行打电话和发短信操作。
练习题七：员工类设计一个员工类，包括员工的姓名、工号和工资等属性。
要求能够设置和获取员工的各个属性，并能够计算员工的年薪。
在主函数中创建多个员工对象，并输出每个员工的信息和年薪。
练习题八：动物类设计一个动物类，包括动物的名称、年龄和性别等属性。
要求能够设置和获取动物的各个属性，并能够实现动物的叫声。
Java面向对象编程习题总结
第一章面向对象开发方法概述1. 面向对象的软件开发有哪些优点？1）把软件系统看成是各种对象的集合，这更接近人类的自然思维方式。
2）软件需求的变动性往往是功能的变动，而功能的执行者——对象，一般不会有多大的变化，比结构化更稳定。
3）对象包括属性和行为，对象把数据及方法的具体实现方式一起封装起来，使得方法与之相关的数据不再分析，提高了每个子系统的相对对立性，从而提高软件的可维护性。
4）支持封装，抽象，继承和多态。
提高了软件的可重用性，可维护性和可扩展性。
2. 在软件系统中，为什么说一个孤立的不对外提供任何服务的对象是没有意义的？1）每个对象都具有特定的功能，相对于其他对象而言，它的功能就是为其他对象提供的服务。
2）从使用者角度出发，整个软件系统就是一个服务的提供者。
3）在系统内部，每个子系统也都是服务的提供者，它们其他子系统提供服务。
4）因此说一个孤立的部队为提供任何服务的系统是美欧任何意义的。
3. 列举一些现实生活中的例子，来说明什么是依赖关系、什么是聚集关系，以及什么是关联关系。
1）关联关系：关联是指类之间的特定对应关系，可以分为单向关联和双向关联，也可以分为一对一关联、一对多关联以及多对多关联。
A关联B，是指Class A与Class B之间存在特定的对应关系。
举例如学生和老师，订单和客户。
2）依赖关系：类之间的调用关系。
A依赖B，Class A访问Class B提供的服务。
如Panel 与Shape的关系。
3）聚集关系：是整体与部分之间的关系4. 列举一些显示生活中的例子，来说明什么是封装，什么是接口。
1) 接口：对象中所有向使用者公开的方法的声明构成了对象的接口。
2) 封装：隐藏对象的属性和实现细节，仅仅对外公开接口。
3) 接口的优点：a.提高系统之间松散耦合b.提高了系统的可扩展性。
4) 封装的有点：a. 便于使用者正确、方便地理解和使用系统，防止使用者错误修改系统的属性。
b. 有助于建立各个系统之间的松耦合关系，提高系统的独立性。
面向对象编程期末总结题
面向对象编程期末总结题一、引言面向对象编程（Object-oriented programming，简称OOP）是一种以对象作为基本单位的编程范式，它的出现使得程序的设计更加模块化、可维护性更强，并且能够提高代码的复用性和开发效率。
在本次面向对象编程的学习中，我对面向对象的思想和原则有了更深入的理解，并通过实践项目与练习，进一步巩固了所学的知识。
以下是我对本次课程学习的总结与反思。
二、学习的内容在本次课程学习中，主要包括以下几个方面的内容：1. 面向对象的基本概念：类、对象、继承、封装、多态等；2. 面向对象的核心原则：单一职责原则、开放封闭原则、里氏替换原则、接口隔离原则和依赖倒置原则；3. 面向对象的设计模式：单例模式、工厂模式、策略模式、观察者模式等；4. 面向对象的编程语言：Java、C++等。
三、学习的收获通过本次的学习，我收获了以下几个方面的知识与技能。
1. 对面向对象的理解更加深入：在学习中，我进一步理解了面向对象的思想和原则，并且能够灵活运用到实际的项目中；2. 学会了使用面向对象的设计模式：通过实践项目与练习，我学会了使用一些常见的设计模式，如单例模式、工厂模式、策略模式等；3. 提高了编程的能力：通过课程学习，我的编程能力得到了提高，我能够更加熟练地运用面向对象的编程思想和技巧，设计出更加简洁、高效的代码；4. 加深了对编程语言的理解：通过学习面向对象的编程语言，如Java，我对其语法和特性有了更深入的理解，并能够熟练地运用这些知识。
四、项目实践与练习在本次学习中，我完成了几个面向对象编程的项目实践和练习，这些项目涵盖了面向对象的基本概念和一些常见的设计模式，通过实践和练习，我对面向对象编程有了更深入的了解和掌握。
1. 学生管理系统在这个项目中，我使用Java编写了一个学生管理系统，实现了学生的增删改查功能。
我使用了面向对象的思想，将学生抽象成一个类，每个学生对象包含了姓名、年龄、性别等属性。
Java面向对象综合习题
3、当类的成员未用访问权限修饰符时，Java认为此成员的访问权限为（）。
A. privateB. protected
C.friendlyD.public
4、下面哪个关键字不是用来控制对类成员的访问的？（ ）
Ａ.publicB.protected
C.defaultD.private
1.选择题
1、下列关于变量的叙述哪个是错的？（）
A.实例变量是类的成员变量。
B.在方法中定义的局部变量在该方法被执行时创建。
C.实例变量用关键字static声明。
D.局部变量在使用前必须被初始化。
2、在Java语言中，下列哪个包是编译器自动导入的？（）
ng
//do something
}
A.String str;
B.static int PI=3.14;
C.public class MyClass{//do other thing…}
D.import java.awt.*;
9、下列关于变量的叙述哪个是错的？（）
A、实例变量是类的成员变量。
B、在方法中定义的局部变量在该方法被执行时创建。
6.建立一个人类（Person）和学生类（Student），功能要求如下：(练习继承、构造方法重载、this、super用法)
（1）Person中包含4个保护型的数据成员name、addr、sex、age分别为字符串、字符串、造方法、一个两个参数的构造方法、一个无参构造方法，一个输出方法显示4种属性。
3.编写一个部门Dept类，只读属性：部门编号、部门名称、所在位置，方法：打印部门信息。一个员工信息Emp类，只读属性：员工编号、员工姓名、工种、雇佣时间、工资、补助、部门，方法：打印员工信息，计算员工的薪水，修改员工补助并打印修改之后的薪水。
Java面向对象的总结和综合练习
Java面向对象的总结和综合案例练习一、难点突破下表列出本阶段的难点，如果某个难点没完全掌握，请写下你感到疑惑的地方，然后通过复习教材，从网上查找资料、与同学探讨、向老师请教等途径突破这些难点。
如果你掌握了这个难点，请在"是否掌握"一栏中打"√"。
这些技能是学习后面技能的基础，所以一定要在继续学习前突破。
如果你还有其他难点，也请填写在表中。
表1 本学习阶段难点记录表难点感到疑惑的地方突破方法是否掌握类的定义对象的创建this、super关键字的使用static、final关键字的使用面向对象设计的过程使用权限修饰符进行类的封装继承关系下构造方法的执行利用多态减少代码量，提高代码的可扩展性和可维护性接口与抽象类的异同包的概念和定义包装类的常见用法二、知识点梳理2.1 面向对象的封装2.2 类的定义2.3 对象的引用2.4 static的应用2.5 类的继承2.6 Java的多态2.7 Java的接口2.8 final和abstract的应用2.9 包装类2.10 包的定义及应用2.11 Object类2.12 内部类三、综合练习3.1 任务描述本次综合练习的任务是：以面向对象思想设计动物乐园系统。
动物乐园有猫、猴子等成员，还可能增加新成员。
猫和猴子都有自己的名字，都有腿，但腿的条数不同，都会发出叫声，猫的叫声是"喵喵喵……"，猴子的叫声是"吼吼吼……"，要求进行面向对象设计，画出类图并写出代码。
练习的难度不高，关键是明确面向对象设计是一个不断优化的过程，是为了有效解决业务问题。
3.2 上机练习阶段1：设计猫和猴子的类设计，画出类图并写出代码需求说明以面向对象思想设计猫和猴子的类结构，画出类图并写出代码。
实现思路根据任务表述，可以设计出两个类，猫类Cat和猴子类Monkey，它们均有名字、腿的条数属性，均具有吼叫的方法，由此可以提取出父类----Animal类，进行代码重用，让Cat、Monkey均继承Animal 类。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Java面向对象的总结和综合案例练习一、难点突破下表列出本阶段的难点，如果某个难点没完全掌握，请写下你感到疑惑的地方，然后通过复习教材，从网上查找资料、与同学探讨、向老师请教等途径突破这些难点。
如果你掌握了这个难点，请在"是否掌握"一栏中打"√"。
这些技能是学习后面技能的基础，所以一定要在继续学习前突破。
如果你还有其他难点，也请填写在表中。
表1 本学习阶段难点记录表难点感到疑惑的地方突破方法是否掌握类的定义对象的创建this、super关键字的使用static、final关键字的使用面向对象设计的过程使用权限修饰符进行类的封装继承关系下构造方法的执行利用多态减少代码量，提高代码的可扩展性和可维护性接口与抽象类的异同包的概念和定义包装类的常见用法二、知识点梳理2.1 面向对象的封装2.2 类的定义2.3 对象的引用2.4 static的应用2.5 类的继承2.6 Java的多态2.7 Java的接口2.8 final和abstract的应用2.9 包装类2.10 包的定义及应用2.11 Object类2.12 内部类三、综合练习3.1 任务描述本次综合练习的任务是：以面向对象思想设计动物乐园系统。
动物乐园有猫、猴子等成员，还可能增加新成员。
猫和猴子都有自己的名字，都有腿，但腿的条数不同，都会发出叫声，猫的叫声是"喵喵喵……"，猴子的叫声是"吼吼吼……"，要求进行面向对象设计，画出类图并写出代码。
练习的难度不高，关键是明确面向对象设计是一个不断优化的过程，是为了有效解决业务问题。
3.2 上机练习阶段1：设计猫和猴子的类设计，画出类图并写出代码需求说明以面向对象思想设计猫和猴子的类结构，画出类图并写出代码。
实现思路根据任务表述，可以设计出两个类，猫类Cat和猴子类Monkey，它们均有名字、腿的条数属性，均具有吼叫的方法，由此可以提取出父类----Animal类，进行代码重用，让Cat、Monkey均继承Animal 类。
但是Animal类不是一种具体的动物，创建Animal对象没有实际意义，Animal对象也无法真正发出叫声，且子类必须重写吼叫的方法，所以可以将Animal类设计成抽象类，把吼叫的方法设计成抽象方法。
阶段2：增加新成员海豚，重新设计类结构需求说明在动物乐园中增加一个新成员海豚Dolphin，海豚的叫声是"海豚音……"实现思路让海豚直接继承Animal类可以么？海豚没有腿，所以不能继承Animal类，但海豚又确实是一种动物，所以……，只有对Animal类进行重新设计，去掉腿的条数的属性。
但是问题又来了，如何再约束Cat和Monkey类呢？可以采用如下思路：创建Terrestrial(陆生的)接口，声明getLegNum()方法（获取腿的数量），然后让Cat和Monkey在继承Animal类的同时实现Terrestrial接口。
根据以上的描述画出类图，并写出Java代码。
阶段3：输出各种动物如何叫需求说明在阶段2编写的Java代码的基础上，分别创建Cat、Duck和Dolphin对象并放到一个数组中，对数组进行遍历输出各种动物如何叫，运行结果如图所示。
要求：创建Animal类型的数组存放各种动物对象，利用多态实现功能。
阶段4：输出各种动物腿的数量需求说明在阶段3编写的Java代码的基础上，分别创建Cat、Duck和Dolphin对象并放到一个数组中，对数组进行遍历输出各种动物动物腿的条数，运行结果如图所示。
提示：数组中有Dolphin对象元素，但海豚没有腿，输出是应判断各个对象是否实现了Terrestrial 接口，可以使用instanceof进行判断。
if(animal[i] instanceof Terrestrial) {//输出腿的条数}四、常用英文单词class、object、static、final、private、public、protected、overload、constructor、encapsulation inheritance、extend、super、override、abstract、polymorphism、instance、elapse、parameter、blockClassCastException、upcasting、downcasting、interface、implement、wrapper、NullPointerException、parseInt、valueOf、InnerClass、五、深入学习学习主题：面向对象的设计原则5.1 类和类之间的依赖、关联、聚合、组合关系1. 继承关系继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。
在Java中继承关系通过关键字extends明确标识，在设计时一般没有争议性。
在UML类图设计中，继承用一条带空心三角箭头的实线表示，从子类指向父类，或者子接口指向父接口。
2. 实现关系实现指的是一个class类实现interface接口（可以是多个）的功能，实现是类与接口之间最常见的关系。
在Java中此类关系通过关键字implements明确标识，在设计时一般没有争议性。
在UML 类图设计中，实现用一条带空心三角箭头的虚线表示，从类指向实现的接口。
3. 依赖关系简单的理解，依赖就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。
比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖。
表现在代码层面，为类B作为参数被类A在某个method方法中使用。
在UML类图设计中，依赖关系用由类A指向类B的带箭头虚线表示。
4. 关联关系关联体现的是两个类之间语义级别的一种强依赖关系，比如我和我的朋友，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的。
关联可以是单向、双向的。
表现在代码层面，为被关联类B以类的属性形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量。
在UML类图设计中，关联关系用由关联类A 指向被关联类B的带箭头实线表示，在关联的两端可以标注关联双方的角色和多重性标记。
5. 聚合关系聚合是关联关系的一种特例，它体现的是整体与部分的关系，即has-a的关系。
此时整体与部分之间是可分离的，它们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享。
比如计算机与CPU、公司与员工的关系等，比如一个航母编队包括海空母舰、驱护舰艇、舰载飞机及核动力攻击潜艇等。
表现在代码层面，和关联关系是一致的，只能从语义级别来区分。
在UML 类图设计中，聚合关系以空心菱形加实线箭头表示。
6. 组合关系组合也是关联关系的一种特例，它体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合。
它同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束，比如人和人的大脑。
表现在代码层面，和关联关系是一致的，只能从语义级别来区分。
在UML类图设计中，组合关系以实心菱形加实线箭头表示。
7. 总结对于继承、实现这两种关系没多少疑问，它们体现的是一种类和类、或者类与接口间的纵向关系。
其他的四种关系体现的是类和类、或者类与接口间的引用、横向关系，是比较难区分的，有很多事物间的关系要想准确定位是很难的。
前面也提到，这四种关系都是语义级别的，所以从代码层面并不能完全区分各种关系，但总的来说，后几种关系所表现的强弱程度依次为：组合>聚合>关联>依赖。
5.2 面向对象的基本原则什么是面向对象的基本原则？设计原则是基本的工具，应用这些规则可以使你的代码更加灵活、更容易维护，更容易扩展。
面向对象的基本原则包括：1.面向接口编程而不是面向实现[Code to an interface rather than to an implementation.]2.优先使用组合而非继承[Favor Composition Over Inheritance.]3.SRP: The single responsibility principle 单一职责系统中的每一个对象都应该只有一个单独的职责，而所有对象所关注的就是自身职责的完成。
[Every object in your system should have a single responsibility, and all the object s services should be focused on carrying out that single responsibility.]每一个职责都是一个设计的变因，需求变化的时候，需求变化反映为类职责的变化。
当你系统里面的对象都只有一个变化的原因的时候，你就已经很好的遵循了SRP原则。
如果一个类承担的职责过多，就等于把这些职责耦合在了一起。
一个职责的变化就可能削弱或者抑制这个类其它职责的能力。
这种设计会导致脆弱的设计。
当变化发生的时候，设计会遭到意想不到的破坏。
SRP 让这个系统更容易管理维护，因为不是所有的问题都搅在一起。
内聚[Cohesion]其实是SRP原则的另外一个名字，你写了高内聚的软件其实就是说你很好的应用了SRP原则。
4.DRY : Don't repeat yourself Principle 避免代码重复原则通过抽取公共部分放置在一个地方避免代码重复。
[Avoid duplicate code by abstracting out things that are common and placing those thing in a single location.]DRY很简单，但却是确保我们代码容易维护和复用的关键。
你尽力避免重复代码实际上是在确保每一个需求和功能在你的系统中只实现一次，否则就存在浪费！系统用例不存在交集，所以我们的代码更不应该重复，从这个角度看DRY可就不只是在说代码了。
DRY 关注的是系统内的信息和行为都放在一个单一的，明显的位置。
就像你可以猜到正则表达式在java中的位置一样，因为合理所以可以猜到。
DRY 原则：如何对系统职能进行良好的分割！职责清晰的界限一定程度上保证了代码的单一性。
5.OCP : Open-Close Principle 开放闭合原则类应该对修改关闭，对扩展打开；[Classes should be open for extension, and closed for modification.]OCP 关注的是灵活性，改动是通过增加代码进行的，而不是改动现有的代码；OCP的应用限定在可能会发生的变化上，通过创建抽象来隔离以后可能发生的同类变化OCP原则传递出来这样一个思想：一旦你写出来了可以工作的代码，就要努力保证这段代码一直可以工作。