Java面向对象笔记（一）

梦里梦外; 2022-08-31 12:25 196阅读 0赞

### 文章目录 ###

*  一、面向对象的概述
 *  二、java类与对象
 *   *  1、类
     *  2、属性
     *  3、方法
     *  4、构造器
 *  三、三大特征
 *   *  1、封装
     *  2、继承
     *   *  一、继承性的好处:
         *  二、继承性的格式: class A extends B\{\}
         *  三、Java中关于继承性的规定:
         *  四、1.如果我们没有显式的声明一个类的父类的话，则此类继承于java . lang . object类
         *  super关键字的使用
         *   *  super的使用
             *  super调用构造器

--------------------

# 一、面向对象的概述 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dpc2hfeW91X2x1Y2s_size_16_color_FFFFFF_t_70]

面向对象与面向过程不同，面向过程关注的是怎么做，即我要怎么做才能实现这个东西，一步一步来做，而面向对象则是把这个这个动作进行一个抽象化，把一个一个的动作行为封装在类中，让一个一个的类去做这个事情。提高了代码的复用性

# 二、java类与对象 #

## 1、类 ##

设计类，其实就是设计类的成员

属性 = 成员变量 = field = 域、字段  
方法 = 成员方法 = 函数 = method

创建类的对象 = 类的实例化 = 实例化类

2、类和对象的使用（面向对象思想落地的实现）  
1.创建类，设计类的成员  
2.创建类的对象  
3.通过对象，属性或方法调用对象的结构

3、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static的）  
意味着，如果我们修改了一个对象的属性a，则不影响另外一个对象属性a的值。

## 2、属性 ##

类中属性的使用

属性（成员变量） VS 局部变量  
1.相同点：  
1.1 定义变量的格式：数据类型 变量名 = 变量值  
1.2 先声明，后使用  
1.3 变量都有其对应的作用域

1.  不同点：  
    2.1 在类中声明的位置的不同  
    属性：直接定义在类的一对\{\}内  
    局部变量：声明在方法内，方法形参，代码块内，构造器形参，构造器内部的变量
    
    2.2 关于权限修饰符的不同  
    属性：可以在声明属性时，指明其权限，使用权限修饰符  
    常用权限修饰符：private,public ,缺省，protected  
    局部变量：不可以使用权限修饰符
    
    2.3 默认初始化值的情况  
    属性:类的属性，根据其类型，都有默认初始化值  
    整型:(byte,short,int,long):0  
    浮点型:(float,double):0.0  
    字符型：(char):0(或’\\u0000’)  
    布尔型:(boolean),false
    
        引用数据类型(类，接口，数组):null
    
    局部变量：没有初始化值。  
    意味者，我们在调用局部变量之前，一定要显式赋值。  
    特别地，形参在调用时，我们赋值即可。
    
    2.4 在内存中加载的位置不同  
    属性:加载在堆空间中(非static)  
    局部变量:加载在栈空间中

## 3、方法 ##

类中方法的声明和使用

方法:描述应该具有的功能。  
比如:Math类：sqrt()\\random()…  
Scanner类：nextXxx() …  
Arrays类：sort() \\ binarySearch() \\ toString() \\ equals() \\ …

1.举例  
public void eat() \{\}  
public void sleep(int hour) \{\}  
public String getName() \{\}  
public String getNation(String nation) \{\}  
2.方法的声明:权限修饰符 返回值类型 方法名(形参列表)\{  
方法体  
\}  
注意：static 、final、abstract 来修饰的方法，后面再讲

1.  说明：  
    3.1 关于权限修饰符：默认方法的权限修饰符先都使用public  
    java规定的4种权限修饰符：private、public、缺省、protectd --> 封装性再细讲
    
    3.2 返回值类型：有返回值 VS 没有返回值  
    3.2.1 如果方法有返回值，则必须再方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字  
    来返回指定类型的变量会常量:“return 数据”
    
    如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不使用return，  
    但是，如果使用的话，只能使用"return;"表示结束此方法的意思。
    
    3.2.2 我们定义方法该不该有返回值？  
    ① 题目要求  
    ② 凭经验：具体问题具体分析
    
    3.3 方法名: 属于标识符，遵循标识符的规则和规范，要有“顾名思义”
    
    3.4 形参列表: 方法可以声明0个，1个，或多个形参  
    3.4.1 格式: 数据类型1 形参1,数据类型2 形参2,…
    
    3.4.1 我们定义方法时，该不该定义形参？  
    ① 题目要求  
    ② 凭经验：具体问题具体分析
    
    4.return 关键字的使用：  
    1. 使用范围：使用在方法体中  
    2. 作用: ① 结束方法  
    ② 针对于有返回值类型的方法，使用"return 数据" 方法返回所要的数据  
    3. 注意点: return 关键字后面不可以声明执行语句  
    5. 方法的使用中，可以调用当前类的属性或方法  
    特殊的:方法A中又调用了方法A：递归方法  
    方法中，不可以定义方法

## 4、构造器 ##

构造器的特征  
他具有与类相同的名称  
他不声明返回值类型(与声明为void不同)  
不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

构造器的作用：创建对象：给对象进行初始化  
如：Order o = new Order(); Person p = new Person(“Peter”,15);  
如同我们规定每个人一出生就必须先洗澡，我们就可以在”人“的构造器中加入完成洗澡的程序代码，  
于是每个人一出生就会自动完成洗澡，程序就不必再在每个人刚出生时一个一个地告诉他们要洗澡了

类的结构之三:构造器(或构造方法、constructor)的使用  
construct:建设、建造。construction:CCB constructor :建设者

一、构造器的作用:  
1.创建对象  
2.初始化对象的信息  
二、说明：  
1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器  
2.定义构造器的格式 权限修饰符 类名(形参列表)\{  
\}  
3.一个类中定义的多个构造器彼此之间构成重载  
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器  
5.一个类中，至少会有一个构造器

# 三、三大特征 #

## 1、封装 ##

为什么需要封装?封装的作用和含义?  
➢我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内  
部的结构吗?有必要碰电动机吗?  
➢我要开车，…

我们程序设计追求“高内聚，低耦合"  
➢高内聚:类的内部数据操作细节自己完成，不允许外部干涉;  
➢低耦合:仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提  
高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露  
的暴露出来。这就是封装性的设计思想。

面向对象的特征一-: 封装与隐藏  
一、问题的引入:  
当我们创建一个类的对象以后， 我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到  
属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值  
加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。(比如: setLegs())  
同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private)  
–>此时，针对于属性就体现了封装性。

二、封装性的体现:  
我们将类的属性xxx私有化(private)，同时，提供公共的(public )方法来获取(getXxx)和设置(setXxx)此属性的值  
拓展:封装性的体现:①  
如上②不对外暴露的私有的方法③单例模式

## 2、继承 ##

面向对象的特征之二:继承性

### 一、继承性的好处: ###

①减少了代码的冗余，提高了代码的复用性  
②便于功能的扩展  
③为之后多态性的使用，提供了前提

### 二、继承性的格式: class A extends B\{\} ###

A:子类、派生类、subclass  
B:父类、超类、基类、superclass

2.1体现: 一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。

特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。  
只有因为封装性的影响，使得子类不能直接调用父类的结构而已。

2.2子类继承父类以后，还可以声明自己特有的属性或方法:实现功能的拓展。  
子类和父类的关系，不同于子集和集合的关系。  
extends:延展、扩展

### 三、Java中关于继承性的规定: ###

1.一个类可以被多个子类继承。  
2.Java中类的单继承性: -个类只能有一个父类  
3.子父类是相对的概念。  
4.子类直接继承的父类，称为:直接父类。间接继承的父类称为:间接父类  
5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

### 四、1.如果我们没有显式的声明一个类的父类的话，则此类继承于java . lang . object类 ###

2.所有的java类 (除java. lang . Object类之外)都直接或间接的继承于java. lang . object类  
3.意味着，所有的java类具有java. lang . object类声明的功能。

### super关键字的使用 ###

1.  super理解为:父类的
2.  super可以用来调用:属性、方法、构造器

#### super的使用 ####

3.1我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用
    父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
    3.2特殊情况:当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的
    使用"super.属性"的方式，表明调用的是父类中声明的属性。
    3.3特殊情况:当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的
    使用"super.方法"的方式，表明调用的是父类中被重写的方法。

#### super调用构造器 ####

4.1 我们可以在子类的构造器中显式的使用"super (形参列表)"的方式，调用父类中声明的指定的构造器
    4.2 "super(形参列表 ) "的使用，必须声明在子类构造器的首行!
    4.3 我们在类的构造器中，针对于"this (形参列表) "或"super(形参列表)"只能二选一，不能同时出现
    4.4 在构造器的首行，没有显式的声明"this (形参列表) "或"super(形参列表)"，则默认调用的是父类中空参的构造器：super();
    4.5 在类的多个构造器中，至少有一一个类的构造器中使用了"super (形参列表)"，调用父类中的构造器

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dpc2hfeW91X2x1Y2s_size_16_color_FFFFFF_t_70]: /images/20220829/b10bfb8b096c4a63bb2c7e151af51d3b.png