进击的百晓生：Java从0到1第7天_面向对象OOP之封装
封装
一、面向对象
对象：真实存在，并且唯一的食物（比如我前面的桌子）
类：对某种类型事物的共同属性与行为的抽取，是种事物种类的总览（是抽象的概念）
类跟对象的关系：
类是抽象的概念，对象是类的实例，比如现实生活中，车的概念是有四个轮子，排气管，方向盘等等的一些标准，这些标准存在我们的脑子里，这个就是车的类，对象是对类的实例，就是我们用这些标准制造出了真的某某类型的车。
通过自定义类创建对象的格式：
类名 变量名 = new 类名（）；
调用对象的功能：
对象.方法
在类中，成员变量都是有默认值，默认值列表如下：
| 成员变量类型 | 默认值 |
|---|---|
| int | 0 |
| float | 0.0F |
| double | 0.0 |
| String | null |
| Boolean | false |
| char | ’ ’ 空字符 |
在成员变量中，所有的引用类型默认初始值都是null，一旦new出一个对象，
1.1面向对象的思想
面向对象编程（OOP - Object Oriented Programing）
面向对象不是一门编程语言，也不是一种语法，而是一种编程思想。
面向过程：关注的是过程。遇到一个问题时候，“我该怎么做”，一步一步实现最终的功能即可。
面向对象：关注的是对象。遇到一个问题时候，“我该让谁来做”，这个谁就是我们要关注的对象。
我要去新疆：
面向过程：
step1：
step2：
step3：
。。。
面向对象：
订票的事，谁来做；
订酒店的事，谁类做；
行程的规划，谁来做；
…
问题域：
如何采用面向对象的思考方式：
A：在问题域中涉及到了哪些对象。
B：何为这些对象？对象的属性和行为
人：
属性(就是一些事物的特诊)：姓名，性别，年龄
行为（就是一些动作）：吃饭()，睡觉()，开车()…
C：对象和对象之间的关系。类和类的关系
1.2 类和对象
类，对象：
类：同一类事务的统称。
理解为类别。人类，猫类，车，手机。。。。。。
对象：类中的一个具体的实例。
定义人类：
姓名，年龄，性别，家庭住址
吃饭(),睡觉(),打水()…
对象：
王二狗，张三，李小花。。。。。。
王二狗：作为一个人
定义猫：
1.3 语法结构
构建一个类：
[修饰符] class 类名{
//1.属性字段：Field
成员变量
//2.成员方法：Method
行为功能
//3.构造方法：Constructor
}
//step1:创建一个类
public class Person {
//1.属性字段：Field，也叫成员变量
String name;//姓名
int age;//年龄
String sex;//性别；
//2.成员方法：Method 行为
public void eat(){
System.out.println("吃东西。。。。。");
}
public void sleep(){
System.out.println("睡觉。。。。");
}
}
/*
类名 对象名 = new 构造函数(); //创建对象
//对象访问属性和方法
赋值：对象.属性 = 数值
取值：对象.属性
调用方法：对象.方法名()
*/
Person person = new Person();//创建一个对象
/*
类名 对象名 = new 构造函数();
=左边是声明一个对象，
=右边是 ，创建一个对象，
*/
// person.name = "小A";
//
// System.out.println("对象的名字："+person.name);
//
// person.eat();
// person.sleep();
//
//
// Person p2 = new Person();
// p2.name = "小强";
// p2.age = 23;
// p2.sex = "男";
// System.out.println("p2的姓名："+p2.name+",p2的年龄是："+p2.age+",p2的性别是："+p2.sex);
类中成员变量，和局部变量不同，有默认值。
基本类型：int，byte，short，long，float，double,，默认值都是0。char 的默认值"空字符”，也就是‘\u0000’，数值为0,boolean默认值false,
引用类型：默认值都是null。空。
String，Math：JDK提供的
charAt()
equals()
Person：我们自己写的
/*
类名 对象名 = new 构造函数(); //创建对象
//对象访问属性和方法
赋值：对象.属性 = 数值
取值：对象.属性
调用方法：对象.方法名()
*/
Person person = new Person();//创建一个对象
/*
类名 对象名 = new 构造函数();
=左边是声明一个对象，
=右边是 ，创建一个对象，
如果没有=右边创建的对象这个过程，那么这个对象其实是不存的，就是null
访问类中的属性和方法，会报错，空指针异常
*/
//成员变量的默认值
System.out.println(person.name);
System.out.println(person.age);
System.out.println(person.sex);
System.out.println(person.sex2);
Person person2 = null;
System.out.println(person2);
//System.out.println(person2.name);//java.lang.NullPointerException空指针异常
//
person2.sleep();//空指针异常
画图分析一下类的结构
实例化对象：
再创建一个测试类，包含主函数，主函数中，创建对象
类名 对象名 = new 构造函数(); //创建对象
//对象访问属性和方法
赋值：对象.属性 = 数值
取值：对象.属性
调用方法：对象.方法名()
1.4 构造方法Constructor
构造方法是一种特殊的方法：
1. 定义的语法结构不同：
[访问权限修饰符] 方法名(参数列表){
}
修饰符：访问权限修饰符
没有返回值类型，也不写void
方法名：必须和类名一致
参数：
没有参数：无参构造
有参数列表：有参构造
//默认的无参的构造方法
public Person(){
System.out.println("这是默认的构造方法");
}
public Person(String n,int a,String s){
System.out.println("这是有参的构造方法");
System.out.println(name);
System.out.println(age);
System.out.println(sex);
name = n;
age =a;
sex = s;
}
2. 调用不同：
通过new关键字调用：
new 构造方法();
3. 作用不同：专门用于创建对象的。
注意点：如果一个类中，没有写构造方法，那么当创建对象的时候，编译器会自动添加一个无参的构造方法。但是如果类中写了构造方法，那么编译器不再自动添加无参了。
对比普通方法：
public static 返回值类型/void 方法名(形式参数){…}
画图分析一下Person类,Demo_Person类的结构
1.5 this关键字
this关键字：每个类中都隐含了一个this关键字。
- 指代本类的对象，可以访问本类的属性和方法。
用途一：指代本类对象，可以访问本类的方法。当局部变量和成员变量命名冲突的时候，通过this来区分：this.成员变量。
public Person(String name,int age,String sex){
this.name = name;
this.age =age;
this.sex = sex;
}
this.属性
this.方法();
习惯上省略this，直接用属性和方法。
public void print(){
System.out.println("名字："+this.name+",性别："+sex+",年龄："+age);
}
public void eat(){
this.print();
}
- 指代构造方法：this();
如果存在多个构造方法，那么this指代的构造方法要靠参数来区分：顺序，个数，类型。
注意：this指向构造函数的时候，只能放在第一句
//默认的无参的构造方法
public Person(){
System.out.println("这是默认的构造方法");
}
//有参的构造方法
public Person(String name,int age){
this();//可以调用无参的构造方法
this.name = name;
this.age = age;
}
// public Person(String sex,int age){
//
// }
public Person(String name,int age,String sex){
this(name,age);//有参的构造方法
System.out.println("这是有参的构造方法");
// System.out.println(name);
// System.out.println(age);
// System.out.println(sex);
// this.name = name;
// this.age =age;
this.sex = sex;
}
再次画图分析一下Test类的结构，加深对类的结构的理解
String name;//成员变量
public Test(){}//构造方法
public void test1(){//成员方法
System.out.println(name+"test1.....");
}
public void test2(){//成员方法
this.test1();
System.out.println(name+"test2......");
}
//静态方法
public static void test3(){
System.out.println("test3........");
}
1.6封装性
面向有三大特性：封装，继承，多态
封装性：
方法就是一种封装，类也是一种封装。。。
优点：
1，隐藏了实现的细节；
2，提高了代码的复用性
3，提高了安全性
保护细节。
保护数据的安全。
封装的步骤：
- 使用private修饰需要被封装的属性
- 提供一个方法设置或获取被private 修饰的属性
set属性名（）； //只是规范命名
get属性名（）；
封装一定要提供get/set方法？不一定，根据需求而定，可以写一个或者一个都不写，在现实开发中，一般所有的成员变量都要封装起来
在类中，属性的数值不安全。所以要将属性进行封装。
step1：使用private修饰符来修饰属性。限于本类中访问
step2：因为对象对属性的操作：赋值和取值
对象.属性 = 数值------>赋值
对象.属性------->取值
我们在类中提供两个方法，分别用于给属性进行赋值和取值。
赋值方法：setAge()，setName()
setXXX()
取值方法：getAge()，getName()
getXXX()
示例：
package com.qf.part3;
/**
*
* 属性的封装：
* step1:用private修饰属性，让属性只能在本类中访问
* step2:提供setXXX方法，设置成员变量的值
* step3:提供getXXX方法，获取成员变量的值
*/
public class Person {
private String name;
//private修饰符，就只能在本类中访问
private int age;
/*
赋值，是setXXX
*/
public void setAge(int age){
if(age<0){
System.out.println("年龄不能为负数");
return;
}
this.age = age;
}
/*
取值：getXXX
*/
public int getAge(){
return this.age;
}
public void setName(String name){
if(name.length()>6||name.length()<2){
System.out.println("姓名太长或者太短");
return ;
}
this.name = name;
}
public String getName(){
return this.name;
}
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("吃东西。。。。");
}
}
测试：
package com.qf.part3;
public class Demo3 {
public static void main(String[] args) {
Person p1 = new Person();
//p1.name = "成龙";
p1.setName("成龙");
//p1.age = -30;
p1.setAge(90);
System.out.println("p1姓名："+p1.getName()+",p1的年龄："+p1.getAge());
}
}
访问权限修饰符：4个
public：公共的
private：私有的，属性，方法。。只能在本类中使用。
类：
对象：
成员属性：
字段：Field
成员方法：
构造方法：
this关键字：
局部变量：