面向对象编程思想

麦兜号

已于 2022-07-22 20:02:46 修改

阅读量319

点赞数

文章标签： java

于 2022-07-20 20:51:33 首次发布

本文链接：https://blog.csdn.net/m0_55814208/article/details/125880111

版权

JavaSE面向对象基础**

重点回顾
数组的创建：

动态创建：数据类型[] 数组变量名=new 数据类型[元素个数]
静态创建：数据类型[] 数组变量名={元素1,元素2,…}
动态创建并赋初始值：数据类型[] 数组变量名=new 数据类型[]{元素1,元素2,…}

数组特点：

只能存储相同类型的数据
数组中的值可以重复
数组的长度是固定的
数组是连续的内存空间

相关的算法

冒泡排序
二分法查找

系统预定义类型引入

基本类型及其包装类
字符串类型
日期类型基础

随机数

Math.random()
Random r=new Random()
练习题
第1题：用递归实现不死神兔：斐波那契在他的一部著作中提出了一个有趣的问题：假设一对刚出生的小
兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，没有发生死
亡，
问：现有一对刚出生的兔子2年后(24个月)会有多少对兔子

public class Test01 {
public static void main(String[] args) {
Count c = new Count();
int sum = c.sum(24);
System.out.println(sum);
}
}
class Count{
//从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子
/*
 - 第1个月，1对 f(1) = 1
 - 第2个月，1对 f(2) = 2
 - 第3个月，2对 老兔子本身1对，加上生出来的一对第1个月
 - f(3) = f(2) + f(1)
 - 第4个月，3对 老兔子本身1对，上月出生的兔子第2个月，老兔子又生出一对新的第1个
月
 - 整理： 老兔子本身1对，老兔子又生出一对新的第1个月==》等价于第3个月
的状态
上月出生的兔子第2个月，==>等价于第2个月的兔子状态
 - f(4) = f(3)+f(2)
 - 第5个月，5对 老兔子本身1对，老兔子又生出1对新的第1个月，第3个月初始的兔子也成
新的老兔子1对，
它也生出一对新的第1个月，第4个月出生的兔子第2个月1对
 - 整理分析：
*老兔子本身1对，老兔子又生出1对新的第1个月，第4个月出生的兔子第2个月1对 ==》等价于
第4个月的状态
*第3个月初始的兔子也成新的老兔子1对，它也生出一对新的第1个月 ==》等价于第2个月的兔
子状态
 - f(5) = f(4) + f(2)
 - .... f(n) = f(n-1) + f(n-2)
 - */
public int sum(int n){
if(n==1 || n==2){
return 1;
}else{
return sum(n-1) + sum(n-2);
}
}
}

第2题：猴子吃桃子问题，猴子第一天摘下若干个桃子，当即吃了快一半，还不过瘾，又多吃了一个。第
二天又将仅剩下的桃子吃掉了一半，又多吃了一个。以后每天都吃了前一天剩下的一半多一个。到第十
天，只剩下一个桃子。试求第一天共摘了多少桃子？

public class Test02 {
public static void main(String[] args) {
Count c = new Count();
System.out.println(c.sum(1));
System.out.println(c.sum(2));
System.out.println(c.sum(3));
System.out.println(c.sum(4));
System.out.println(c.sum(5));
System.out.println(c.sum(6));
System.out.println(c.sum(7));
System.out.println(c.sum(8));
System.out.println(c.sum(9));
System.out.println(c.sum(10));
}
}
class Count{
public int sum(int n){
if(n==10){//第10天
return 1;
}else{
/*
 - 第9天没吃之前是 第10天+1个的2倍
 - 第8天没吃之前是 第9天+1个的2倍
 - 。。。。
*/
return (sum(n+1)+1)*2;
}
}
}

第3题：通项公式如下：f(n)=n + (n-1) + (n-2) + … + 1，其中n是大于等于5并且小于10000的整数，例
如：f(5) = 5 + 4 + 3 + 2 + 1，f(10) = 10 + 9 + 8 + 7+ 6 + 5 + 4 + 3 + 2 + 1，请用递归的方式完成方法
long f( int n)的方法体。

public class Test3 {
public static void main(String[] args) {
Count c = new Count();
System.out.println(c.f(5));
System.out.println(c.f(10));
}
}
class Count{
public long f(int n) {
long sum = 0;
if(n==1){
sum += 1;
}else if(n>1){
sum += n + f(n-1);
}
return sum;
}
}

第4题：假设有n级台阶，一个人可以一次上1级或者2级台阶，问有多少种上法

/*
 - 1级：1
 - 2级：2 1步1步 和 2步
 - 3级：上到1级的总走法（因为从1级上到3级直接跨2步） + 上到2级的总走法（从2级上到3级直接
跨1步）
 - 因为从1级走1步就归到上到2级的走法里面了
 - 4级：上到2级的总走法 + 上到3级的总走法
 - ...
 -  - 即最后一步要么跨1步，要么跨2步
*/
public class Test4 {
public static void main(String[] args) {
Count c = new Count();
System.out.println(c.f(10));
}
}
class Count{
public int f(int n) {
if (n <= 2){
return n;
}
return f(n - 1) + f(n - 2);
}
}

面向对象概论

面向对象的三大基本特征是：封装、继承、多态

封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据
- 隐藏功能或者信息的细节，使用者只关注功能的使用，而不需要关心实现细节
继承是为了重用父类代码，同时为实现多态性作准备
- 关键字extends，子类可以集成父类的成员变量和成员方法
- java采用的是单根集成体系
多态性是发送消息给某个对象，让该对象自行决定响应何种行为。通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。
一个事物可以有多种表现形式
体现形式常见的有3种
父类型引用子类对象
方法重写
方法重载

面向对象三大特征的优缺点
设计目标：高内聚低耦合
可维护性提高
重用性提高
扩展性增强
执行效率

概述

面向过程是一种自上而下的程序设计方法，主要思路专注于算法的实现

自上而下的设计方法，设计者用一个main函数概括出整个应用需要做的事情，然后把main方法拆解成不同的步骤，对应不同的函数

过程式的特征是以函数为中心，用函数作为划分程序的基本单位；数据在过程式设计中处于从属的位置

过程式设计的优点是易于理解和掌握，这种逐步细化问题的设计方法与大多数人的思维方式比较接近

过程式设计是自上而下，这就要求设计者在开始时要对需要解决的问题有一定的理解，然而在问题比较复杂时，要做到这一点比较困难；当开发需求变化时，以前对问题的理解会变得不再适用

软件代码的重用性很差，即使重用，也是简单的复制和拷贝，代码数量急剧增加。而不能直接继承和应用

面向过程的方法将数据和过程分离，使得数据的改变很可能带来代码的变化

面向对象是一种自下而上的程序设计方法，以数据为中心，类是表现数据的单位，是划分程序的基本单位

面向对象设计是自下而上的特性，允许开发者从问题的局部开始，在开发过程中逐步加深对系统的理解。需求变化会作用到系统开发本身，形成一种螺旋式的开发方式

面向对象设计中，类封装了数据，而类的成员函数作为其对外的接口，抽象地描述类，用类将数据和操作这些数据的函数放在一起，这就是面向对象设计方法的本质

面向对象的概念

OO面向对象Object Oriented是软件开发方法

面向对象是一种新兴的程序设计方法,或者是一种新的程序设计规范paradigm，其基本思想是使用对象、类、继承、封装、消息等基本概念来进行程序设计
从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式
开发一个软件是为了解决某些问题，这些问题所涉及的业务范围称作该软件的问题域。其应用领域不仅仅是软件，还有计算机体系结构和人工智能等
面向对象的思想已经涉及到软件开发的各个方面。如面向对象的分析（OOA，Object Oriented Analysis），面向对象的设计（OOD，Object Oriented Design）、以及经常说的面向对象的编程实现（OOP，Object Oriented Programming）
OOP使得现实世界中的概念在计算机程序中编程模块，它包括构造程序的特征以及组织数据和算法的机制

面向对象是一种对现实世界理解和抽象的方法

传统的程序设计主张将程序看作一系列函数的集合，或者直接就是一系列对电脑下达的指令。面向对象程序设计中的每一个对象都应该能够接受数据、处理数据并将数据传达给其它对象，因此它们都可以被看作一个小型的“机器”，即对象
OOP语言有3大特征：封装、继承及多态，所有这些特征与类的概念是息息相关的
面向对象是指一种程序设计范型，同时也是一种程序开发的方法。对象指的是类的集合。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性
对象、类、实体之间的关系和面向对象的问题求解思维方式

对象

对象是要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。对象是一个客观存在的、唯一的实体，是一个类的动态实例，拥有自己的标识、数据与行为

在现实世界中：是客观世界中的一个实体
在计算机世界中：是一个可标识的存储区域
现实世界中所有的事物都是对象 ——对象都具有某些特征，并展现某些行为

对象的状态和行为

对象具有状态，一个对象用数据值来描述它的状态
对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为
对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中
对象的两个要素
属性：用于描述对象静态特性（结构特性）的一个数据项，描述一个人可用姓名、性别、身份证号等属性
方法（也称服务）：用于描述对象动态特性（行为特性）的一个操作系列——每个人都具有工作、学习等行为特性
对象将数据和施加于数据上的操作打包成一个不可分割的最基本的模块，使得仅有该类的有限个方法才可以操纵、改变这些数据

类

用Java语言对现实生活中的事物进行描述，通过类的形式来体现

类是具有共同属性和行为的对象的抽象，具有相同特性（数据元素）和行为（功能）的对象的抽象就是类
对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象
类实际上就是一种数据类型
- 类是用于组合各个对象所共有操作和属性的一种机制
- 类是具有相同属性和行为的一组对象的集合
- 类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性
- 类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述
类可以定义为数据和方法的集合，类也称为模板，因为它们提供了对象的基本框架
一旦定义类后，就可以用这种新类来创建该类型的对象
类就是对象的模板（template ）

而对象就是类的一个实例（instance）

消息和方法
- 对象之间进行通信的结构叫做消息。发送一条消息至少要包括说明接受消息的对象名、发送给该对象的消息名（即对象名、方法名）
- 类中操作的实现过程叫做方法，一个方法有方法名、返回值、参数、方法体
类和对象之间的关系

类是事物的描述
类是Java程序的核心，它定义了对象的形状和本质，可以用类来创建对象。当使用一个类创建了一个对象时，通常说给出了这个类的一个实例
类由类声明和类体构成，一般命名方法为：首字母大写，大写字母分词，例如XueSheng

class className {
      类体；
}

类包含数据成员(数据、属性)和成员方法（函数）。一般建议数据成员应该是通过函数(方法)访问的
对象是类的实例，就是应用中定义的某个类的变量，例如Person p=new Person(); p就是对象
类是和问题域相关的具有相同属性和行为的对象的抽象；对象是该类事物的实例，在Java中通过new来创建的

基本规则

1、了解业务需求，查找具体的研究目标：对象

2、使用抽象的方法将具体的研究目标转换为新的数据类型定义：类

//一个文件中可以定义无数个类，但是只能有一个public class，而且公共类的名称必须和文件名称
一致
public class Student {
//数据成员
private Long id; //学生编号
private String name;//姓名
private double high;
//成员方法
public void 吃饭(){
high+=0.1;
}
}
class Teach{} //非公共类
public class Test1{
public static void main(String[] args){
Student s1=new Student();
s1.吃饭();
}
}

封装

在面向对象程式设计方法中，封装Encapsulation是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问
——反射机制
要访问该类的代码和数据，必须通过严格的接口控制。
封装最主要的功能在于能修改自己的实现代码，而不用修改那些调用代码的程序片段
适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

//第一步是确定研究的目标对象---可以区分的独立个体
// 需要方法和属性
class Student {
//成员属性---静态特征的描述
private boolean sex; //一般使用私有属性，共有的get/set方法
//成员方法---提供的功能描述
public boolean getSex(){
return this.sex;
}
//不允许修改sex，所以不提供set方法
protected void setSex(Boolean sex){ //如果在特殊情况下允许修改,可以使用范围限
定词进行表示
this.sex=sex;
}
}
//构建对象
Student s1=new Student();
s1.setSex(true);
s1.setSex(false); //是否允许取绝于限制

封装有三大好处

良好的封装能够减少耦合
类内部的结构可以自由修改
可以对成员进行更精确的控制
隐藏信息，实现细节

4个关键字
用于进行访问控制

//一个文件种可以定义无数个类，但是只能有一个public class公共类
public class Student { //类的范围限定词分为2种情况。外部类的范围限定词可以使用无范围
限定词和public两种；而内部类上可以使用4种范围限定
//成员属性,类种包含哪些静态特征取决于问题本身
private Long id; //private只能在当前类中直接访问
protected String name; //protected可以在同包或者子类中直接访问
int age;//没有范围限定词，默认或者package限定词，只能在同包中直接访问
public double salary;//public到处可见
//一般规则是私有属性，共有的get/set方法