Java面对对象和封装【带你快速走进面对对象编程和异常处理】

一、面向对象的思想概述

面想过程： 当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。
面向过程： 当需要试想一个功能的时候，不关系具体的步骤，而是找一个已经具有该功能的人，来帮助我做事。

二、类与对象的关系

类： 是一组线管属性和行为的集合。可以看成一类事物的模板，食用食物的属性特征和行为特征还描述该类事物。
对象： 是一类事物的具体体现，对象是类的一个实例，必然是具备该来事物的属性和行为。

类的定义：

成员变量（属性）：
String name； //姓名
int age;  //年龄

成员方法（用于创建对象等）：
构造方法  ----可以没有，没有的话java默认赠送一个无参构造方法

成员方法（行为）：
public void eat() {} //吃饭，学习等

对象的创建：

1.导包：也就是支出需要使用的类，在什么位置。
import 包名称.类名称；
对于和当前属于同一个报的情况，可以省略导包语句不写。
2.创建格式：
类名 对象名 = new 类名称（）;
3.使用（分两种情况）：
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名（参数）
	（想用谁，就用相应的对象名.谁）

对象调用的内存图：

使用对象作为方法的参数：

自定义的类做方法的返回值：
其结果是在占中的方法中进行返回地址。

成员变量与局部变量的区别：

1. 定义的位置不一样【重点】
   局部变量：在方法的内部；
   成员变量：在方法的外部，直接写在类当中。
2. 作用范围不一样【重点】
   局部变量：只有方法当中才可以使用，除了方法就不能再使用了。
   成员变量：整个类全都可以通用。
3. 默认值不一样【重点】
   局部变量：没有默认值，如果想要使用，必须手动进行复制。
   成员变量：如果没有赋值，会有默认值，规则和数组一样。
4. 内存当中位置不一样（了解）
   局部变量：位于栈内存
   成员变量：位于堆内存
5. 生命周期不一样（了解）
   局部变量：随着方法进栈而诞生，随着方法出战而消失
   成员变量：随着对象的创建而诞生，随着对象被垃圾回收而消失。

三、面对对象的三大特征：封装，继承，多态

1）封装性在java当中的体现：

• 方法就是一种封装
• 关键字private也是一种封装。

封装就是将一些细节信息隐藏蕲艾，对外界不可见

private关键字的作用即使用：

• private一旦修饰了一旦修饰了成员变量，那么本类当中任然可以访问，但是超出本类范围之外就不能再直接访问了。
• 使用private解决的问题是，放置一些不合理的变量被设定。用get/set方法进行限定以及用于其他类可以调用达到访问此类成员变量的效果。

this关键字的作用：

1. 当成员变量与参数变量重名时，优先使用局部变量（就近原则）。
2. 如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名。
3. “通过谁调用的谁，谁就是this”

构造方法：
是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是嗲用构造方法。
注意事项：
4. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样。
5. 构造方法不要写返回值类型，连void都不写
6. 构造方法不能return一个具体的返回值。
7. 如果没有编写任何构造方法，那么编译器将会默认赠送一个无参构造。
8. 一旦编写了只好一个构造方法，那么编译器将不会再赠送构造方法。
9. 构造方法可以进行重载，但是不能进行重写。

构造方法与普通方法的区别：
10. 构造方法是用来创建对象的，普通方法是用来实现功能的。
11. 构造方法中如果要使用this或者super调用必须放在第一位，并且只能用一个。
12. 构造方法可以调用普通方法，普通方法不可以调用构造方法。
13. 不能被static、final、synchronized、abstract和native修饰。

2） 继承与多态
继承： 继承是多态的前提，如果没有继承就没有多态。

父类：也叫作基类、超类；
子类：也可以叫做派生类；

继承关系当中的特点：

1. 子类可以拥有父类的“内容”；
2. 子类还可以拥有自己专有的内容。

继承的格式：

定义父类的格式：（一个普通的类定义）
public calss 父类名称{
//...
}
定义子类的格式：
public class 子类名称 extends 父类名称{
  //。。。
}

在父子类的继承当中，如果成员变量重名，则创建子类对象是，访问有两种方式：

1.直接通过子类对象访问成员变量：
等号左边是谁，就优先用谁，没有则向上找。

2.简介通过成员方法访问成员变量:
该方法属于谁，就先用谁，没有则向上找。

在父子类的继承关系当中，创建子类对象，访问成员方法的规则。
创建的对象是谁，就优先用谁，如果没有则向上找。
注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会像吓着子类的。

区分子类方法中重名的三种变量：

局部变量：			直接写成员变量名；
本类的成员变量：	this.成员变量名；
父类的成员变量名：	super.成员变量名；

重写与重载的区别：
重写（Override）
概念：在继承关系中，方法的名称一样，参数列表也一样。
重载（Overload）
概念：方法名称一样，参数列表不一样。

方法覆盖重写的注意事项：（规则）

1. 必须保证父子类之间方法名称相同，参数列表也相同。
   @Override：写在方法前面，用来检测是不是有效的正确的覆盖重写。
   这个注释就算不写，只要满足条件，也是正确的方法覆盖重写。

2. 子类方法的返回值必须【小于等于】弗雷方法的返回值范围。
   小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类）

3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
   小扩展提示：public>protected>(defualt)>private
   备注：（default）不是关键字default，而是什么都不写，留空。

4. 父类的私有方法不能被子类覆盖。

5. 如果父类方法有static关键字，重写不能去掉static关键字。

6. 如果重写父类静态方法，则该父类静态方法不再生效。

7. 不能跑出比父类方法更多的异常。

继承中构造方法的访问特点：

1. 子类构造方法当中有一个默认隐含的“super（）”调用，所以一定是先调用的父类构造，后执行的子类构造。
2. 可以通过super关键字来子类构造调用父类重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
4. 子类必须调用构造方法，不写则赠送super();写了则用写的制定的super调用。

super关键字的用法：（用来访问父类内容）

1. 在子类的成员方法中，访问父类的成员变量。
2. 在子类的成员方法中，访问父类的成员方法。(可以不放在第一行)
3. 在子类的后早方法中，访问父类的构造方法。(必须在第一行)

this关键字的用法：（用来访问本类内容）

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。(this（…）调用也必须是构 造方法的第一个语句)
   super和this两种构造调用不能同属使用。
   this和super图解：
   
   Java语言继承的三个特点：
   
   抽象类：
   抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象
   抽象方法：
   如果父亲当中的方法不确定如何进行{}方法体实现，那么这就应该是一个抽象方法。
   抽象方法的定义：
   就是加上abstract关键字，然后去掉大括号，直接分号结束。
   抽象类定义：
   抽象方法所在的类，必须是抽象类才行（还可以是接口）。在class之前写上abstract即可。

抽象方法和抽象类的使用:

1. 不能直接创建抽象类对象。
2. 必须用一个子类来继承抽象父类。
3. 子类必须覆盖重写抽象父类中的所有抽象方法
   覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括 号。
4. 创建子类对象进行使用。

抽象类和抽象方法的注意事项：

1. 抽象类不能直接创建对象，如果创建，编译无法通过而直接报错。
2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
3. 抽象类中，不一定包含抽象方法，但是抽象方法的类一定是抽象类。
4. 抽象类的子类必须重写抽象类当中的所有抽象方法，除非子类也是抽象类。

接口：

1. 接口就是多个类的公共规范。
2. 接口是一种引用数据类型，最重要的内容就是其中的，抽象方法。
3. 如何定义一个接口的格式：
   public interface 接口名称{
   //接口内容
   }
   备注: 换成了关键字interface之后，编译生成的字节码文件仍然是：java–>.class（字节码文件）。

接口的使用：

1. 接口中的成员变量
   默认都是public static final的，必须显式初始化
2. 接口中的方法
   默认都是public abstract的
3. 接口没有构造方法，不能被实例化
4. 一个接口不能实现另一个接口，但可以继承多个其他接口
5. 一个类必须实现接口抽象方法（implements），除非这个类也是抽象类

Java版本不同对接口的要求不同：
如果是java7，那么接口中可以包含的内容有：

1. 常量
2. 抽象方法。

如果是java8还可以额外包含有（前面版本可以的8也都可以）：

1. 默认方法
2. 静态方法

如果是java9，还可以额外包含有（前面版本可以的9也都可以）:

1. 私有方法。

接口使用步骤：

1.接口不能直接使用，必须有一个“实现类”来“实现”该接口。
格式：
public class 实现类名称 implements 接口名称{
    //...
}
2.接口实现类必须覆盖重写接口中所有的抽象方法。
实现：去掉abstract关键字，加上方法体大括号。
3.创建实现类的对象，进行使用。

接口的注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。

接口总结：
1.Java中的接口：

1. 属性全都是全局静态常量
2. 方法都是全局抽象方法
3. 无构造方法

2.一个类可以实现多个接口，非抽象类实现接口时必须实现接口中的全部方法
3.抽象类利于代码复用，接口利于代码维护

继承与接口对比：
1.相同点

• 代表系统的抽象层

• 都不能被实例化

• 都能包含抽象方法

• 用于描述系统提供的服务，不必提供具体实现
  2.不同点

• 在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法
  抽象类便于复用，接口便于代码维护

• 一个类只能继承一个直接的父类，但可以实现多个接口

使用原则：

1. 接口做系统与外界交互的窗口
2. 接口提供服务
3. 接口本身一旦制定，就不允许随意修改
4. 抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点

面对对象的设计原则：

1. 多用组合，少用继承
2. 针对接口编程
3. 针对扩展开放，针对改变关闭。

三、 异常

异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。

异常的关键字： try、catch、finally、throw、throws

关键字的使用：
public void method(){
try {
// 代码段 1
// 产生异常的代码段 2
} catch (异常类型 ex) {
// 对异常进行处理的代码段3
return;
}finally{
// 代码段 4
}
}

常见异常类型：

异常类型	说明
Exception	异常层次结构的父类
ArithmeticException	算术错误情形，如以零作除数
ArrayIndexOutOfBoundsException	数组下标越界
NullPointerException	尝试访问 null 对象成员
ClassNotFoundException	不能加载所需的类
IllegalArgumentException	方法接收到非法参数
ClassCastException	对象强制类型转换出错
NumberFormatException	数字格式转换异常，如把"abc"转换成数字

注意事项：

1. 错误不是异常，而是脱离程序员控制的问题。
2. 所有的异常类是从 java.lang.Exception 类继承的子类。
3. 异常类有两个主要的子类：IOException 类和 RuntimeException 类。
4. Java有很多的内置异常类。
5. 多重catch块：
   引发多种类型的异常
   排列catch 语句的顺序：先子类后父类
   发生异常时按顺序逐个匹配
   只执行第一个与异常类型匹配的catch语句

异常大致分类：
异常分为Checked异常和运行时异常
Checked异常必须捕获或者声明抛出
运行时异常不要求必须捕获或者声明抛出