二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如 抽象、分类、继承、聚合、多态等。 面向对象的三大特征：封装 (Encapsulation) 、继承 (Inheritance) 、多态 (Polymorphism)。
我们举个小栗子来体会一下面向过程与面向对象的区别
例子：“人把大象装进冰箱”
1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做
①把冰箱门打开
②抬起大象，塞进冰箱
③把冰箱门关闭
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做
人{
打开(冰箱){
冰箱，开开();
}
抬起(大象){
大象，进入(冰箱);
}
关闭(冰箱){
冰箱，闭合()；
}
}
冰箱{
开开(){}
闭合(){}
}
大象{
进入(冰箱){
}
}
类：对一类事物的描述，是抽象的，概念上的定义
对象：是实际存在的该类事物的每个个体，因而也成为实例(instance)
>面向对象程序设计的重点是‘类的设计’
>设计类，就是设计类的成员
①类的设计
设计类，其实就是设计类的成员
属性 = 成员变量 = field = 域，字段
方法 = 成员方法 = 函数 = method
②创建Java自定义类
步骤： 1. 定义类（考虑修饰符、类名） 2. 编写类的属性（考虑修饰符、属性类型、属性名、初始化值） 3. 编写类的方法（考虑修饰符、返回值类型、方法名、形参等）
三、对象的创建与使用创建对象语法： 类名 对象名 = new 类名(); 使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）
例子：
public class Zoo{
public static void main(String args[]){
//创建对象
Animal xb=new Animal();
xb.legs=4;//访问属性
System.out.println(xb.legs);
xb.eat();//访问方法
xb.move();//访问方法
}
}
对象的内存解析
匿名对象
四、类的成员之一(属性)成员变量(属性) vs 局部变量
1.相同点：
* 1.1定义变量的格式：数据类型 变量名 = 变量值
* 1.2先声明：后使用
* 1.3变量都有其对应的作用域
*
*
* 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）
* 局部变量：加载到栈空间
成员变量与局部变量的内存位置
五、类的成员之二(方法)方法的声明
说明： 还可以使用static,final,abstract等关键字修饰方法
方法的重载
方法参数的值传递机制
六、面向对象特征之一：封装和隐藏封装性的设计思想：把该隐藏的隐藏起来，该暴露 的暴露出来。
一.问题的引入
* 当我们创建一个类的对象以后，我们可以通过“对象.属性”的方式
* 对对象的属性进行赋值。这里的赋值操作要受到属性的数据类型和
* 存储范围的制约。除此之外没有其他制约条件。但在实际问题中
* 我们往往需要给属性赋值加入额外的限制条件，这个条件不能在
* 属性声明时体系，我们只能通过方法精选限制条件的添加，同时
* 我们需要避免用户在使用“对象.属性”的方式对属性进行赋值，则需要
* 声明为私有的(private)
* ->>此时，针对与属性就体现了封装性
*
* 二.封装性的体现，我们将类的属性私有化(private),同时，提供公共的方法来获取(getXxx)和设置(setXxx)
*
*
* 三.封装性的体现，需要权限修饰符来配合
* 1.Java规定的4种权限(从小到大排序)：private，缺省，protected，public
* 2.4种权限可以用来修饰类及类的内部结构：属性，方法，构造器，内部类
* 3.修饰类的话，只能使用：缺省，public
*
* 总结：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及
* 类的结构在被调用时是可见性的
构造器的声明
注意：
八、关键字—thisthis关键字的使用
* 1.this可以用来修饰或调用：属性，方法，构造器
*
* 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.(形参列表)”，用来调用其他构造器
* 一.package关键字的使用
* 1.为了更好的实现项目中类的管理，提供包的概念
* 2.使用package声明类或接口所属的包，声明在源文件的首行
* 3.包，属于标识符，遵循标识符的命名规则，规范(xxxxyyyzzz),“见名知意”
* 4.每"."一次，就代表一层文件目录
*
* 补充:同一个包下，不能命名同名的接口，类
* 不同的包下，可以命名同名的接口，类
*
* 二.import关键字的使用
* `
* import:导入
* 1.在源文件中显示的使用import结构导入指定包下的类，接口
* 2.声明在包的声明和类的声明之间
* 3.如果需要导入多个结构，则并列写出即可
* 4.可以使用“xxx.*”的方式表示可以导入xxx包下的所有结构
* 5.如果使用的类或接口是java.lang包下的，则可以省略import结构
* 6.如果使用的类或接口是本包下定义的，则可以省略import结构
* 7.如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示
* 8.使用“xxx.*”可以调用“xxx”包下的所有结构，如果使用的是“xxx”子包下的结构，则仍需要用显示导入
*
* 9.import static:导入导入指定类或接口中的静态结构：属性或方法
* 一.继承性的好处：
* ① 减少代码的冗余，提高了代码的复用性
* ② 便于功能的扩展
* ③ 为之后多态性的使用，提供了前提
*
* 二.继承性的格式： class A extends B{}
* A：子类,派生类,subclass
* B：父类,超类,基类,superclass
*
* 2.1体现：一旦子类A继承父类B以后,子类A中就获取了父类B中声明的结构中所有的属性和方法
* 特别的：父类中声明为private的属性和方法，子类继承父类以后，仍然认为获取了父类中私有的结构。因为有封装性的影响，使子类不能直接调用父类的结构而已
* 2.2子类继承父类以后,还可以声明自己特有的属性或方法：实现功能的拓展
* 子类合父类发关系，不同于子集和集合的关系
*
* 三.Java中关于继承性的规定：
* 1.一个类可以被多个子类继承
* 2.Java中类的单继承性：一个类只能有一个父类
* 3.子父类是相对的概念
* 4.子类直接继承的父类叫做直接父类，间接继承的父类为间接父类
* 5.子类继承父类以后，就获取了直接父类以及所有简介父类中声明的属性与方法
* 四.1.如果我们没有显示的声明一个类的父类，则此类就继承于java.lang.Object类
* 2.所有的Java类(除java.lang.Object类之外)都直接或间接的继承于Java.lang.Object类
* 3.意味着：所有的java类具有java.lang.Object类声明的功能
*
* 方法的重写(override / overwrite)
*
* 1.重写：子类继承父类以后要对从父类中继承来的方法进行改造，也称 为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。
*
* 2.应用：重写以后，当创建子类对象以后，通过子类对象调用字符类中的同名同参数的方法时，实际执行的是子类重写父类的方法
*
* 3.重写的要求与规定：
1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
* 方法的声明：权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
* //方法体
* }
* 约定俗称：子类中的叫重写方法，父类中的叫被重写的方法
* ① 子类重写的方法的方法名和形参列表与父类被重写的方法名和形参列表相同
* ② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
* >>特殊情况：子类中不能重写父类中private权限的方法(具体查看异常处理)
* ③ 返回值类型：
* >如果父类被重写的方法的返回值是是void，则子类重写的方法的返回值类型只能是void
* >父类被重写的方法的返回值类型是A类，则子类重写的方法的返回值类型可以是A类或A类的子类
* >父类被重写的方法的返回值是基本数据类型(比如：double)，则子类重写的方法的返回值必须是相同的基本数据类型(double)
* ④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
* **************************************
* 子类和父类中同名同参数的方法要么都声明为非static的(非static的)，要么都声明为static的(不是重写)
*
① super关键字的使用
* 1.super理解为：父类的
* 2.super可以用来调用：属性、方法、构造器
*
* 3.super的使用：
*
* 3.1 我们可以在子类的方法或构造器中通过使用“super.属性”或“super.方法”的方式显示调用父类中声明的属性或方法
* 但通常情况下，我们习惯省略“super.”
* 3.2 特殊情况下：当子类和父类当中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显示的使用
* “super.属性”，表明调用的是父类中调用的属性
* 3.3 特殊情况下：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显示的
* 使用“super.方法”的方式，表明调用的是父类中被重写的方法
*
* 4.super来调用构造器
* 4.1 我们可以在子类的构造器中显示的使用“super(形参列表)”的方式，调用父类中声明的指定构造器
* 4.2 “super(形参列表)”的使用，必须声明在子类构造器的首行！
* 4.3 我们在类的构造器中，针对于“this(形参列表)”或“super(形参列表)”只能二选一，不能同时出现
* 4.4 在构造器的首行，没有显示的声明“this(形参列表)”或“super(形参列表)”则默认调用的是父类在空参的构造器super();
* 4.5 在类的多个构造器中至少有一个类的构造器中，至少有一个类的构造器中使用了“super(形参列表)”，调用父类中的构造器
②this与super的区别
五、面向对象特征之三：多态性对象的多态性：父类的引用指向子类的对象
注意：
重载 vs 重写：
instanceof操作符
六、包装类(Wrapper)的使用面向对象(下) 一、关键字：static
使用范围： 在Java类中，可用static修饰属性、方法、代码块、内部类
被修饰后的成员具备以下特点：
1.随着类的加载而加载
2.优先于对象存在
3.修饰的成员，被所有对象所共享
4.访问权限允许时，可不创建对象，直接被类调用
static关键字的使用
*
* 1.static：静态的
* 2.static可以用来修饰：属性、方法、代码块、内部类
*
* 3.使用statci修饰属性：静态变量(类变量)
* 3.1属性：按是否使用static修饰，又分为：静态变量 vs 非静态变量(实例变量)
* 实例变量：当我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性
* 当修改其中一个对象中的非静态属性时，不会导致其他对象中同意的属性值修改
* 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量，当通过每一个对象修改静态变量时，会导致
* 其他对象调用此静态变量时，是修改过了的
* 3.2 static修饰属性的其他说明：
* ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
* ② 静态变量的加载要早于对象的创建
* ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中
*
* ④ 静态变量 实例变量
* 类 yes no
* 对象 yes yes
* 3.3 静态属性举例：System.out;Math.PI
*
* 4.使用static修饰方法：
* ① 随着类的加载而加载，可以通过“类.方法”的方式进行调用
* ② 静态方法 非静态方法
* 类 yes no
* 对象 yes yes
* ③ 静态方法中：只能调用静态的方法或属性
* 非静态方法中：既可以调用非静态的方法或属性，也可以调用静态的方法或属性
*
* 5.static注意点：
* 5.1静态的方法内，不能使用this、super关键字
* 5.2关于静态属性和静态方法的使用，大家都从生命周期的角度去理解
*
* 6.开发中，如何确定一个属性是否声明为static的？
* >属性是可以被多个对象共享的，不会随着对象的不同而不同的
* >类中的常量也常常声明为static
*
* 开发中，如何确定一个方法是是否声明为static的
*
* >操作静态属性的方法，通常设置为静态的
* >工具类中的方法，习惯上声明static的。比如：Math、Arrays、Collections
* 单例设计模式
* 1. 所谓类的单例模式，就是采取一定的方法保证在整个软件系统中，对某个类只存在一个对象实例
*
* 2. 如何实现？
* 饿汉式 vs 懒汉式
*
* 3. 区分饿汉式 和 懒汉式
* 饿汉式：
* 坏处：对象加载时间过长
* 好处：饿汉式是线程安全的
*
* 懒汉式：好处：延迟对象的创建
* 目前的写法坏处：线程不安全--->到多线程内容时再修改
*
①饿汉式
//饿汉式
class Bank{
//1.私有化类的构造器
private Bank() {
}
//2.内部创建类的对象
//4.要求此对象也必须为静态的
private static Bank instance = new Bank();
//3.提供公共的静态方法，返回类的对象
public static Bank getInstance() {
return instance;
}
}
②懒汉式
class Order{
//1. 私有化类的构造器
private Order() {
}
//2. 声明当前类对象，没有初始化
//4. 此对象也必须声明为static的
private static Order instance = null;
//3. 声明public、static的返回当前类对象的方法
public static Order getInstance() {
if(instance == null) {
instance = new Order();
}
return instance;
}
}
单例模式的优点： 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的 产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。
* main()方法的使用说明
* 1. main()方法作为程序的入口
* 2. main()方法也是一个普通的静态方法
* 3. main()方法也可以作为我们与控制台交互的方式。(之前，使用Scanner)
*
* 1. 代码块的作用：用来初始化类、对象
* 2. 代码块如果有修饰的话,只能使用static
* 3. 分类： 静态代码块 vs 非静态代码块
*
* 4. 静态代码块
* >内部可以有输出语句
* >随着类的加载而执行,而且只执行一次
* >作用：初始化类的信息
* >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
* >静态代码块的执行要优先于非静态的代码块
* >静态代码块内只能调用静态的属性、静态的方法、不能调用非静态的结构
*
* 5. 非静态代码块
* >内部可以用输出语句
* >随着对象的创建而执行
* >每创建一个对象，就执行一次非静态代码块
* >作用：可以在创建对象时，对对象的属性等进行初始化
* >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
* >非静态的代码块可以调用静态的属性、方法，或非静态的属性、方法
* final:最终的
*
* 1. final可以修饰的结构：类、方法、变量
*
* 2. final用来修饰一个类:此类不能被其他类继承
* 比如：String类、Systenm类、StringBuffer类
*
* 3. final用来修饰方法：表面此方法不可以被重写
* 比如：Object类中getClass()；
*
* 4. final用来修饰变量：此时的“变量”称为是一个常量
* 4.1 final修饰属性：可以考虑赋值的位置有：显示初始化、代码块中初始化、构造器中初始化
* 4.2 final修饰局部变量：
* 尤其是用final修饰形参时，表明此形参是一个常量，当我们调用此方法是，给常量形参赋一个实参，一旦赋值以后
* 就只能在方法体内使用此形参，但不能进行重新赋值
*
* static final:用来修饰属性：全局常量
* abstract关键字的使用
* 1. abstract：抽象的
* 2. abstract可以用来修饰的结构：类、方法
*
* 3. abstract修饰类：抽象类
* >此类不可实例化
* >抽象类中一定有构造器，便于子类实例化调用(涉及：子类对象实例化的全过程)
* >开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
*
* 4. abstract修饰方法：抽象方法
* >抽象方法只有方法的声明，没有方法体
* >包含抽象方法的类，一定是个抽象类，反之抽象类中是可以没有抽象方法的
* >若子类重写了父类中所有的抽象方法后，此子类可实例化
* 若子类没有重写父类中所有的抽象方法，则此子类也是一个抽象类
* 接口的使用
* 1.接口使用interface来定义
* 2.在Java中，接口和类是并列的两个结构
* 3.如何定义接口：定义结构中的成员
*
* 3.1 JDK7及以前：只能定义全局常量和抽象方法
* >全局常量：public static final的:但是书写时可以省略不写
* >抽象方法：public abstract
*
* 3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)
*
* 4.接口中不能定义构造器的！意味着结构不可实例化
*
* 5.Java开发中，接口都通过让类去实现的方式去实现(implements)的方式来使用
* 如果实现类覆盖了接口中的所有的抽象方法，则此实现类可以实例化
* 如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
*
* 6.Java类可以实现多个接口 --->弥补了Java单继承性的局限性
* 格式：class AA extends BB implements CC,DD,EE
*
* 7.接口与接口之间可以继承，而且可以多继承
*
* *******************************************
*
* 8.接口具体的使用，体现多态性
* 9.接口，实际上可以看做是一种规范
* 接口的使用
* 1.接口使用interface来定义
* 2.在Java中，接口和类是并列的两个结构
* 3.如何定义接口：定义结构中的成员
*
* 3.1 JDK7及以前：只能定义全局常量和抽象方法
* >全局常量：public static final的:但是书写时可以省略不写
* >抽象方法：public abstract
*
* 3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)
*
* 4.接口中不能定义构造器的！意味着结构不可实例化
*
* 5.Java开发中，接口都通过让类去实现的方式去实现(implements)的方式来使用
* 如果实现类覆盖了接口中的所有的抽象方法，则此实现类可以实例化
* 如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
*
* 6.Java类可以实现多个接口 --->弥补了Java单继承性的局限性
* 格式：class AA extends BB implements CC,DD,EE
*
* 7.接口与接口之间可以继承，而且可以多继承
*
* *******************************************
*
* 8.接口具体的使用，体现多态性
* 9.接口，实际上可以看做是一种规范
【注意】 1. 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员 内部类中才可声明static成员。 2. 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式 3. 成员内部类可以直接使用外部类的所有成员，包括私有的数据 4. 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的
