面向对象和封装

一、面向对象思想

1. 面向对象思想概述

概述：这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中的事物，将事物的属性、行为特征抽象出来，描述成计算机事件的。强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现
与面向过程思想比较：
- 面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲历亲为，详细处理每一步
- 面向对象：当需要实现一个功能的时候，不关心具体步骤，而是通过调用对象的行为实现功能
- 如打印一段文字，格式为[1,2,3,4,5]

//用面向过程思想：
	System.out.print("[");
        for (i = 0;i < array.length;i++){
            if(i == array.length-1){//若是最后一个元素
                System.out.println(array[i]+"]");
            }else{
                System.out.println(array[i]+",");
            }
}

//面向对象思想：找一个JDK给我们提供很多Arrays类，其中有一个toString方法可以直接打印成我们需要的
	 System.out.println(Arrays.toString(array));

特点：面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，将我们从执行者变成了指挥者。
面向对象的三大基本特征：封装、继承和多态

2. 类和对象

什么是类：类是一组相关属性和行为的集合。可以看成是一类事物的模板，可以使用事物的属性特征和行为特征来描述该
类事物
- 属性：该事物的状态信息
- 行为：该事物能够做什么
什么是对象 ：对象是一类事物的具体体现。对象是类的一个实例，必定具备该类事物的属性和行为
类与对象的关系
- 类是对一类事物的描述，是抽象的。
- 对象是一类事物的实例，是具体的。
- 类是对象的模板，对象是类的实体

3. 类的定义

定义类：就是定义类的成员，包括成员变量和成员方法
- 成员变量：对应事物的属性，格式与以前定义变量基本是一样。只是位置发生了改变，**是直接定义在类中，在方法外面 **
- 成员方法：对应事物的行为，格式与以前定义变量基本是一样。只不过把static去掉了
格式:
- ```
public class ClassName {
	//成员变量
	//成员方法
}
```
- ```
//举一个例子
public class MyCat{
    //成员变量
    String name;//猫名
    int age;//猫年龄
    
    //成员方法
    public void sleep(){
        System.out.println("猫在睡觉");
    }
    public void eat(String food){
        System.out.println("猫在吃"+food);
    }
}
```
4. 对象的创建与使用

通常情况下，一个类不能直接使用，而是要根据类创建一个对象才能使用。创建对象通常有三个步骤：
- 导包：指出需要使用的类在什么位置
  - import 包名称类名称;
  - 对于和当前类属于同一个包的情况下，可以省略导包语句
- 创建
  - 类名称对象名 = new 类名称
- 使用，分为两种情况
  - 使用成员变量：对象名.成员变量名，用上面的例子说明情况：
    - ```
    //在main方法里
    //1. 导包
    //例子中是和当前类属于同一个包的情况，省略导包语句
    //2. 创建
    	MyCar cat = new MyCat();
    //3. 使用成员变量
    	Systum.out.println(cat.name);//未赋值，为null
```
- 如果成员变量没有赋值，则将会有一个默认值，规则同数组
- 使用成员方法：对象名.成员方法名(参数)
  - ```
  cat.eat("鱼");//输出：猫在吃鱼
```
  - 成员方法保存到是地址值
- 使用对象类型可以作为方法的参数
  - 当一个对象作为参数，传递到方法当中时，实际传递进去的是对象的地址值
- 使用对象类型可以作为方法的返回值
  - 当一个对象作为方法的返回值时，返回的是对象的地址值

5. 成员变量和局部变量的区别

定义的位置不一样【注意】
- 成员变量：在方法的外部，直接写在类当中
- 局部变量：在方法的内部
作用范围不一样【注意】
- 成员变量：在整个类中通用
- 局部变量：只有在方法当中才能使用，方法外不能使用
默认值不一样【注意】
- 成员变量：若没有赋值，则会有默认值，规则同数组
- 局部变量：没有默认值，要想使用必须手动赋值
在内存中的位置不同
- 成员变量：堆内存
- 局部变量：栈内存
生命周期不同
- 成员变量：随着对象的创建而存在，随着对象的消失而消失
- 局部变量：随着方法的调用(进栈)而存在，随着方法的调用完毕(出栈)而消失

public class VirableDifference{
	String name;//成员变量
	
	public void method(){
		int num = 20;//局部变量
	}
}

注意：参数在方法调用到时候必然会被赋值

二、封装性

1. 封装的概述

概述：封装可以防止该类的代码和数据被其他类随意访问，有着一定的保护作用。若要访问该类的数据，就必须通过指定的方式。适当的封装可以让代码更容易理解与维护，同时加强了代码的安全性。
- 方法是一种封装
- private 也是一种封装
原则：将属性和细节信息隐藏起来，若需要访问某个属性，提供公共方法对其访问

2. 封装的步骤

使用 private 关键字来修饰成员变量
对需要访问的成员变量，提供对应的一对 getXxx 方法、 setXxx 方法
- 方法必须叫getXxx 和setXxx
- 对于getXxx ，不能有参数，返回值类型与成员变量对应
- 对于setXxx ，不能有返回值，返参数类型与成员变量对应
- 对基本类型中的boolean值，getXxx 方法要写成isXxx

3. 封装的操作——private关键字

private的含义
- private是一个权限修饰符，代表最小权限
- 可以修饰成员变量和成员方法
- 被private修饰后的成员变量和成员方法，只在本类中才能访问
private的使用格式：private 数据类型变量名
- 使用 private 修饰成员变量，代码如下
  - ```
  public class Student {
  	private String name;
  	private int age;
  }
```
- 提供 getXxx 方法和 setXxx 方法间接访问
  - ```
  public class Student{
      private String name;
      private int age;
      
      public void setName(String n){
          name = n;
      }
      
      public String getName(){
          return name;
      }
      
  }
```
- 若形参变量名与成员变量名重名，会导致成员变量名被隐藏，使得方法中的变量名无法访问到成员变量，从而赋值失败。所以，此时我们只能使用this关键字，来解决这个**重名问题 **

4. 封装优化1——this关键字

采用 this 关键字是为了解决成员变量和局部变量之间发生的同名的冲突，this指当前对象。
- 当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。如果需要访问本类当中的成员变量，需要使用this
- this代表所在类的当前对象的引用（地址值），即对象自己的引用。使用的时候，谁调用方法，this就代表谁

this使用格式：this.成员变量名；

public class Student {
    private String name;
    private int age;
    public void setName(String name) {
        //name = name;
        this.name = name;
} 
    public String getName() {
        return name;
} 
    public void setAge(int age) {
//age = age;
this.age = age;
}
    public int getAge() {
        return age;
    }
}

5. 封装优化2——构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字 new 来创建对象时，其实就是在调用构造方法.

构造方法的格式：
- ```
修饰符 构造方法名(参数列表){
	// 方法体
}
```
- 构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。使用
  构造方法后，代码如下：

public class Student{
   private String name;
   private int age;
   //
   public Student(){}
   //
   public Student(String name,int age){
       this.name = name;
       this.age = age;
   }
}

注意事项：
- 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
- 构造方法不要写返回值类型，连 void 都不写
- 构造方法不能 return 一个具体的返回值
- 如果没有编写任何构造方法，那么编译器将会默认给出无参数构造方法。但方法体什么事情都不做。
- 若编写了构造方法，那么编译器不再提供无参数构造方法
- 构造方法也是可以进行重载的，既可以定义参数，也可以不定义参数

6. 标准的类（Java Bean）

一个标准的类通常有下面四个组成部分：
- 所有的变量都要使用private关键字修饰
- 没一个成员变量有一对getXxx 方法和setXxx 方法
- 编写一个无参数的构造方法
- 编写一个全参数的构造方法

下面给出一个标准和例子：

public class ClassName{
	//成员变量
	//构造方法
	//无参构造方法【必须】
	//有参构造方法【建议】
	//成员方法
	//getXxx()
	//setXxx()
}

public class Student {
    //成员变量
    private String name;
    private int age;
    //构造方法
    public Student() {}
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
}
    //成员方法
    public void setName(String name) {
        this.name = name;
        } 
    public String getName() {
        return name;
        } 
    public void setAge(int age) {
        this.age = age;
        } 
    publicint getAge() {
        return age;
        }
    }

posted @ 2020-05-16 23:14 弥漫s 阅读(159) 评论(0) 收藏举报

刷新页面返回顶部

弥漫s

面向对象和封装

一、面向对象思想

1. 面向对象思想概述

2. 类和对象

3. 类的定义

4. 对象的创建与使用

5. 成员变量和局部变量的区别

二、封装性

1. 封装的概述

2. 封装的步骤

3. 封装的操作——private关键字

4. 封装优化1——this关键字

5. 封装优化2——构造方法

6. 标准的类（Java Bean）

公告