java基础之面向对象上

我不是女神ヾ 2022-10-11 12:11 247阅读 0赞

### java基础之 面向对象 上 ###

*  一、类与对象
 *   *  1、面向对象学习的三条主线
     *  2、面向对象与面向过程（理解）
     *  3、完成一个项目（或功能）的思路
     *  4、面向对象中两个重要的概念
     *  5、面向对象思想落地实现的规则一
     *  6、对象的创建与对象的内存解析
     *   *  1、对象的内存解析
         *  2、对象数组的内存解析、
     *  7、匿名对象
     *  8、理解"万事万物皆对象"
 *  二、类的结构之一：属性
 *   *  1、相同点
     *  2、不同点
     *  3、补充（回顾变量的分类）
     *   *  方式一：按照数据类型
         *  方式二：按照在类中声明的位置
 *  三、类的结构之二：方法
 *   *  1、方法：描述类应该具的功能
     *  2、举例
     *  3、方法的声明
     *  4、说明
 *  四、面向对象的特征一：封装性
 *   *  1、为什么要引入封装性？
     *  2、问题引入
     *  3、封装性思想具体的代码体现
     *  4、Java规定的四种权限修饰符
     *   *  4.1 权限从小到大顺序为：
         *  4.2 具体的修饰范围：
         *  4.3 权限修饰符可用来修饰的结构说明：
 *  五、类的结构之三：构造器
 *   *  1、构造器：
     *  2、构造器的作用：
     *  3、使用说明
     *  4、代码展示
     *  5、属性赋值顺序
     *  6、JavaBean的概念
 *  六、关键字：this
 *   *  1、可以调用的结构
     *  2、this调用属性、方法
     *  3、this调用构造器
 *  7、package的使用
 *   *  1、使用说明
     *  2、举例
     *  3、JDK中的主要包介绍
     *  4、import的使用

# 一、类与对象 #

## 1、面向对象学习的三条主线 ##

*  1.Java类及类的成员：属性、方法、构造器；代码块、内部类
 *  2.面向对象的大特征：封装性、继承性、多态性、(抽象性)
 *  3.其它关键字：this、super、static、final、abstract、interface、package、import等
 *  “大处着眼，小处着手”

## 2、面向对象与面向过程（理解） ##

1、面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。  
2、面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

举例对比：人把大象装进冰箱。

## 3、完成一个项目（或功能）的思路 ##

![在这里插入图片描述][20210630144746885.png]

## 4、面向对象中两个重要的概念 ##

类：对一类事物的描述，是抽象的、概念上的定义  
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

> 面向对象程序设计的重点是类的设计  
> 设计类，就是设计类的成员。

二者的关系

对象，是由类new出来的，派生出来的。

## 5、面向对象思想落地实现的规则一 ##

*  1.创建类，设计类的成员
 *  2.创建类的对象
 *  3.通过“对象.属性”或“对象.方法”调用对象的结构

补充：几个概念的使用说明

*  属性 = 成员变量 = field = 域、字段
 *  方法 = 成员方法 = 函数 = method
 *  创建类的对象 = 类的实例化 = 实例化类

## 6、对象的创建与对象的内存解析 ##

典型代码：
    Person p1 = new Person();
    Person p2 = new Person();
    Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。
    说明：
    如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
    意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

### 1、对象的内存解析 ###

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

### 2、对象数组的内存解析、 ###

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

## 7、匿名对象 ##

我们创建的对象，没显式的赋给一个变量名。即为匿名对象

特点：匿名对象只能调用一次。

举例：

new Phone().sendEmail();
    	new Phone().playGame();
    	new Phone().price = 1999;
    	new Phone().showPrice();//0.0

应用场景：
    PhoneMall mall = new PhoneMall();
    
    //匿名对象的使用
    mall.show(new Phone());
    其中，
    class PhoneMall{ 
    	public void show(Phone phone){ 
    		phone.sendEmail();
    		phone.playGame();
    	}
    	
    }

## 8、理解"万事万物皆对象" ##

1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构

> Scanner,String等  
> 文件：File  
> 网络资源：URL

2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

# 二、类的结构之一：属性 #

> 类的设计中，两个重要结构之一：属性

> 对比：属性 vs 局部变量

## 1、相同点 ##

1.相同点：

*  定义变量的格式：数据类型 变量名 = 变量值
 *  先声明，后使用
 *  变量都其对应的作用域

## 2、不同点 ##

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、补充（回顾变量的分类） ##

### 方式一：按照数据类型 ###

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

### 方式二：按照在类中声明的位置 ###

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

# 三、类的结构之二：方法 #

## 1、方法：描述类应该具的功能 ##

比如：Math类：sqrt()\random() \...
          Scanner类：nextXxx() ...
          Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...

## 2、举例 ##

public void eat(){ }
      public void sleep(int hour){ }
      public String getName(){ }
      public String getNation(String nation){ }

## 3、方法的声明 ##

权限修饰符  返回值类型  方法名(形参列表){ 
      					方法体
      			  }
        注意：static、final、abstract 来修饰的方法，后面再讲。

## 4、说明 ##

3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
      			Java规定的4种权限修饰符：private、public、缺省、protected  -->封装性再细说
      
    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.2 我们定义方法时，该不该定义形参？
              	① 题目要求
              	② 凭经验：具体问题具体分析
           
    3.5 方法体：方法功能的体现。 	
    
    4. 方法的使用中，可以调用当前类的属性或方法
       		特殊的：方法A中又调用了方法A:递归方法。
          方法中，不可以定义方法。

# 四、面向对象的特征一：封装性 #

面向对象的特征一：封装与隐藏

## 1、为什么要引入封装性？ ##

我们程序设计追求“高内聚，低耦合”。

高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；  
低耦合 ：仅对外暴露少量的方法用于使用。

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

## 2、问题引入 ##

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

## 3、封装性思想具体的代码体现 ##

体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

private double radius;
    public void setRadius(double radius){ 
    	this.radius = radius;
    }
    public double getRadius(){ 
    	return radius;
    }

体现二：不对外暴露的私有的方法

体现三：单例模式（将构造器私有化）

体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

## 4、Java规定的四种权限修饰符 ##

### 4.1 权限从小到大顺序为： ###

> private < 缺省 < protected < public

### 4.2 具体的修饰范围： ###

![在这里插入图片描述][20210630165501406.png]

### 4.3 权限修饰符可用来修饰的结构说明： ###

4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类  
修饰类的话，只能使用：缺省、public

# 五、类的结构之三：构造器 #

## 1、构造器： ##

构造器（或构造方法） Constructor

## 2、构造器的作用： ##

*  1.创建对象
 *  2.初始化对象的信息

## 3、使用说明 ##

*  1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
 *  2.定义构造器的格式：权限修饰符 类名(形参列表)\{\}
 *  3.一个类中定义的多个构造器，彼此构成重载
 *  4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
 *  5.一个类中，至少会有一个构造器。

## 4、代码展示 ##

//构造器
    	public Person(){ 
    		System.out.println("Person().....");
    	}
    	
    	public Person(String n){ 
    		name = n;
    		
    	}
    	
    	public Person(String n,int a){ 
    		name = n;
    		age = a;
    	}

## 5、属性赋值顺序 ##

*  总结：属性赋值的先后顺序
 *  ① 默认初始化
 *  ② 显式初始化
 *  ③ 构造器中初始化

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

*  ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
 *  以上操作的先后顺序：① - ② - ③ - ④

## 6、JavaBean的概念 ##

所谓JavaBean，是指符合如下标准的Java类：
    	>类是公共的
    	>一个无参的公共的构造器
    	>属性，且对应的get、set方法

# 六、关键字：this #

## 1、可以调用的结构 ##

属性、方法；构造器

## 2、this调用属性、方法 ##

this理解为：当前对象 或 当前正在创建的对象

2.1  在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，
        通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式
        的使用"this.变量"的方式，表明此变量是属性，而非形参。
      
    2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

## 3、this调用构造器 ##

① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器  
② 构造器中不能通过"this(形参列表)“方式调用自己  
③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)”  
④ 规定："this(形参列表)“必须声明在当前构造器的首行  
⑤ 构造器内部，最多只能声明一个"this(形参列表)”，用来调用其他的构造器

# 7、package的使用 #

## 1、使用说明 ##

*  1.为了更好的实现项目中类的管理，提供包的概念
 *  2.使用package声明类或接口所属的包，声明在源文件的首行
 *  3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
 *  4.每"."一次，就代表一层文件目录。

## 2、举例 ##

举例一  
某航运软件系统包括：一组域对象、GUI和reports子系统

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

举例二：MVC设计模式

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

## 3、JDK中的主要包介绍 ##

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

## 4、import的使用 ##

import:导入

1.  在源文件中显式的使用import结构导入指定包下的类、接口
2.  声明在包的声明和类的声明之间
3.  如果需要导入多个结构，则并列写出即可
4.  可以使用"xxx.\*"的方式，表示可以导入xxx包下的所结构
5.  如果使用的类或接口是java.lang包下定义的，则可以省略import结构
6.  如果使用的类或接口是本包下定义的，则可以省略import结构
7.  如果在源文件中，使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示。
8.  使用"xxx.\*"方式表明可以调用xxx包下的所结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
9.  import static:导入指定类或接口中的静态结构:属性或方法。

[20210630144746885.png]: /images/20221005/a9e2561000824cb0957630db40aeb970.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70]: /images/20221005/b5a832b30cee4503b6e920a08abb85ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 1]: /images/20221005/723ec07446524a85ad30f7367ee7cc51.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 2]: /images/20221005/510dbe5c1702467f9f35c932920aaafc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 3]: /images/20221005/975cc7cce901457e85c4cbb99bfb9534.png
[20210630165501406.png]: /images/20221005/3ae73a8580a6440dabf9b61f925b6ee8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 4]: /images/20221005/4070e2012e7c4b62bf255911248f5f73.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 5]: /images/20221005/721504243887417eb89a0fad3c6bd6e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 6]: /images/20221005/1e38053d43ab4e4492d96d7c04b27d52.png