面向对象基础

Xc_.xC

已于 2022-09-16 19:21:25 修改

阅读量291

点赞数

文章标签： java

于 2022-09-14 10:58:24 首次发布

本文链接：https://blog.csdn.net/qq_52215881/article/details/126845456

版权

了解面向对象首先要知道什么是面向过程。

“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。这些都是以什么正在发生为主要目标进行编程，不同于面向对象的是谁在受影响。

面向过程其实是最为实际的一种思考方式，就算是面向对象的方法也是含有面向过程的思想。可以说面向过程是一种基础的方法。它考虑的是实际地实现。一般的面向过程是从上往下步步求精，所以面向过程最重要的是模块化的思想方法。对比面向过程，面向对象的方法主要是把事物给对象化，对象包括属性与行为。当程序规模不是很大时，面向过程的方法还会体现出一种优势。因为程序的流程很清楚，按着模块与函数的方法可以很好的组织

C语言就是面向过程的语言（是一种完全面向过程语言）

C++是一种半面向过程，半面向对象的语言

Java是一种完全面向对象的语言（不是说没有面向过程中的影子，在Java中的前置语法中也是面向过程的）

有面向过程为什么还要去发展面向对象呢？

面向过程的缺点：

面向过程最主要是每一步每一步的因果关系，其中A步骤因果关系到B步骤，A和B联合起来形成一个子模块，子模块和子模块之间又因为因果关系结合在一起，假设其中任何一个因果关系出现问题（错误），此时整个系统的运转都会出现问题。（代码和代码之间的耦合度太高，扩展力太差）

当然它还有优点：

对于小型项目（功能），采用面向过程的方式进行开发，效率较高，不需要前期进行对象的提取，模型的建立，采用面向过程方式可以直接开始干活。一上来直接写代码，编写因果关系。从而实现功能。

面向对象：

《Java编程思想》中提到“万物皆为对象”的概念。它将对象视为一种奇特的变量，它除了可以存储数据之外还可以对它自身进行操作。它能够直接反映现实生活中的事物，例如人、车、小鸟等，将其表示为程序中的对象。每个对象都具有各自的状态特征（也可以称为属性）及行为特征（方法），java就是通过对象之间行为的交互来解决问题的。

面向对象就是把构成问题的事物分解成一个个对象，建立对象不是为了实现一个步骤，而是为了描述某个事物在解决问题中的行为。

什么是面向对象的开发方式？

采用面向对象的方式进行开发，更符合人类的思维方式。

（在我们认识事物开始时，都是把抽象事物在思维中形成对象的，然后我们才对世界开始有认知，（这只是一种理解方式））

人类就是以“对象”的方式去认识世界的。

所以面向对象更容易让我们接受。

面向对象就是把现实世界分割成不同的单元，然后每一个单元都实现成对象，然后驱动一个下，让每一个对象直接协作起来形成一个系统。

对象“张三”

对象“香烟”

对象“打火机”

对象“吸烟的场所”

然后把以上四个对象组合在一起，

其中“张三”对象可以更换为“李四”

其中 “香烟”对象可以更换品牌

当我们采用面向对象的方式贯穿整个系统的话，涉及到三个术语：

OOA：面向对象分析

OOD：面向对象设计

OOP：面向对象编程（一般以OOP来代指面向对象，面向过程POP或PO）

整个软件开发的过程，都是采用OO进行贯穿的。

是实现一个软件的过程：

分析（A）-->设计（D）-->编程（P）

类

在Java语言中，要想得到“对象”，必须先定义类，“对象”是通过“类”这个模板创造出来的。

类就是一个模板：类中描述的是对象的“共同特征信息”，对象就是通过类创建出的个体

类是面向对象中的一个很重要的概念，因为类是很多个具有相同属性和行为特征的对象所抽象出来的，对象是类的一个实例。

类和对象：在面向对象中，类和对象是最基本、最重要的组成单元。类实际上是表示一个客观世界某类群体的一些基本特征抽象。对象就是表示一个个具体的东西。所以说类是对象的抽象，对象是类的具体。

类是概念上的，它的作用则是赋予对象特性，从而形成一个实体，即对象是一个真实的模型，所以综上所述：类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。

怎么定义一个类，语法格式是什么？

[修饰符列表] class 类名{
类体
//类体=属性+方法（不是必须的，看情况）
//属性在代码上是以“变量”的形式存在（描述状态）
//方法描述动作/行为
}

关于类的修饰符列表：

修饰外部class的词有public，abstract和final，， 其中abstract和final不能同时修饰class。内部类还可以用private或protected来修饰class。

注意：

如果什么都不写，默认权限（外包无法访问）（这里的默认权限不是default，可以理解为friendly，但是java没有这个关键字，但权限上可以理解为default）

为什么属性是以“变量”的形式存在的？

假设我们要描述一个学生：

学生包括以下属性：

学号：110

姓名：“张三”

性别：‘男’

答案：属性对应的是“数据”，数据在程序中只能放在变量中。所以属性以变量的形式存在

类具有三个特性：

封装：核心思想就是“隐藏细节”、“数据安全”，将对象不需要让外界访问的成员变量和方法私有化，只提供符合开发者意愿的公有方法来访问这些数据和逻辑，保证了数据的安全和程序的稳定。

继承：子类可以继承父类的属性和方法，并对其进行拓展。

多态：同一种类型的对象执行同一个方法时可以表现出不同的行为特征。通过继承的上下转型、接口的回调以及方法的重写和重载可以实现多态。

对象之间的关系

1、依赖可以简单的理解，就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是B类的变化会影响到A；比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖；表现在代码层面，为类B作为参数被类A在某个method方法中使用；

2、关联他体现的是两个类、或者类与接口之间语义级别的一种强依赖关系，比如我和我的朋友；这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的、关联可以是单向、双向的；表现在代码层面，为被关联类B以类属性的形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量；

3、聚合聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

4、组合组合也是关联关系的一种特例，他体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合；他同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束；比如你和你的大脑；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

对象实例和对象引用

没有“对象的实例”这一说法，只有类的实例，而类的实例，只的就是类的对象，简称对象。而对象引用，则是指该类实例化之后，在内存的地址（用变量名表示）

对象引用指向对象实例（对象引用存放在栈内存中）。

一个对象引用可以指向0个或1个对象;一个对象可以有n个引用指向它

//对象的创建和使用
public class Student {
    int age =10;
    char gender='男';
    String name="张三";

    //在这里可以访问Student类吗？
    //当然可以。
    /**
     创建对象的语法是什么？
     目前就是死记硬背，先记住。
        new 类名();
     类是模板，通过一个类，是可以创建N个对象的。（此例子是方便理解）
     new是一个运算符。专门负责创建对象。
     */
  Student s=new Student();
}

对象的引用意思是“定义一个变量，这个变量指向的是一个对象“。这时我们的”s“就是一个对象的引用，它指向的是一个对象(也就是类的实例，标题中所谓的对象实例) 而对象的引用实在栈内存中。

对象的引用指向了对象。所以说是栈内存是固定的，因为编译时就可以确定，而堆内存是不固定的在运行时才会确定。也就是说编译时可以确定对象的引用就是“s”(放在栈内存)，而由于多态机制，他并不确定指向的实例有可能是他的子类，在运行期间才会确定

而’‘一个对象引用可以指向0个或1个对象’'的意思：

Two t; //一个对象引用可以指向零个对象
t=new Two();//一个对象引用可以指向一个对象
t=new String();//一个对象引用不可以指向 >1个对象（会编译错误）

’‘一个对象可以有n个引用指向它’'的意思：

Demo demo1,demo2,demo3;//创建多个对象引用，都存储在栈中
demo1=new Demo();//创建一个Demo对象，存储在堆中，并将demo1指向这个对象，相当于加了一个链
demo2=demo1;//demo2与demo1一样，都指向堆中Demo对象
demo3=demo2;//demo3与demo2一样，都指向堆中Demo对象

注意：不是多次new，每一次new都是创建了一个新的对象

对象创建再JVM中的过程

Java 修饰符

Java语言提供了很多修饰符，主要分为以下两类：

访问修饰符
非访问修饰符

访问控制修饰符：

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。接口里一定得显示声明
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
`public`	Y	Y	Y	Y	Y
`protected`	Y	Y	Y	Y/N	N
`default`	Y	Y	Y	N	N
`private`	Y	N	N	N	N

修饰符推荐文章链接：

http://t.csdn.cn/Qs2xs

Java 方法

那么什么是方法呢？

Java方法是语句的集合，它们在一起执行一个功能。

方法是解决一类问题的步骤的有序组合
方法包含于类或对象中(没有的话会出现以下编译和运行错误错误)

方法在程序中被创建，在其他地方被引用

方法的优点

\1. 使程序变得更简短而清晰。
\2. 有利于程序维护。
\3. 可以提高程序开发的效率。
\4. 提高了代码的重用性。

方法的命名规则：

1.方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符（就是驼峰命名法）。例如：addPerson。
2.下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test_，例如 testPop_emptyStack。
3，都要是合法的标识符

方法的定义：

一般情况下，定义一个方法包含以下语法：

修饰符返回值类型方法名(参数类型参数名){
... 方法体 ...
return 返回值;
}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型：

关于返回值类型：

1，返回值类型可以是任何类型，只要是Java中合法的数据类型就可以。

2，什么是返回值？

返回值一般指的是一个方法执行后的结果。

结果通常是一个数据，所以被称为“值”，而且还叫“”返回值。

方法就是为了完成某个特定的功能，方法结束之后大部分情况下都是有一个结果的，而体现结果的一般都是数据。数据得有类型，就是返回值类型。

3，当一个方法执行结束不返回任何值得时候，返回值类型也不能为空，必须写上关键字“void”,所以关键字“void”表示方法执行结束后不返回任何结果，所以不需要“return 返回值”这样的语句。注意：可以有“return；”语句，这个语句的意思是终止当前方法。

方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。

当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

方法体：方法体包含具体的语句，定义该方法的功能。

形参和实参：

“形参：是定义函数时在括号里定义的变量，它只是申明用的，是没有值的；实参：是调用函数时传给形参的值，是有值的。实参是形参被具体赋值之后的值，参加实际的运算，有实际作用。”

在前面几个章节中我们经常使用到 System.out.println()，那么它是什么呢？

println() 是一个方法。

System 是系统类。

out 是标准输出对象。

这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。

方法的调用：

（下面介绍的是同一类下面，调用方法其实是用“类的引用.方法名（）“的方式，只不过同一类下可以省略，要注意静态方法直接用”类名.方法名（）“）

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30, 40);

如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是个语句：

System.out.println("欢迎访问菜鸟教程！");

注意：方法的调用也需要看访问的权限

public class TestMax {  
/** 主方法 */  
	public static void main(String[] args) {      			
        int i = 5;      
		int j = 2;      
		int k = max(i, j);     
        System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);  
        }
        /** 返回两个整数变量较大的值 */   
 public static int max(int num1, int num2) {      			
 int result;     
 if (num1 > num2)        
 result = num1;     
 else         
 result = num2;       
 return result;    
	 }
 }

方法实现在内存中的过程：