拨
1.量化：我们最终是要对一个事物进行量化。
连续型：一个连续的值，数不过来
离散型：一个可以数的过来的值
2.分类的过程
1）属性（特征）：状态信息
2）方法（行为）：无法量化的一个过程3.类：一个抽象的概念，是对事物的划分，不是具体的东西。
类是具有相同属性和方法的一组对象的集合。
类是对象的抽象，对象是类的具体。
4.对象：一个实实在在存在的东西，是一个你看得见摸得着的东西，是一个你能指名道姓的东西，是一个一说你就知道具体是什么的东西。
5.从编程角度来讲：
类：是一个文件
一个.java文件
用class来声明类
类的首字母必须大写
对象：程序中的一个数据
对象也是一种变量，叫引用类型变量
对象的声明过程，完全符合一般变量的声明过程。【new +构造（）：真正的对象】
程序中区分不同的个体，或者如何描述个体的特征：
属性：对象具有的各种特征，静态的。
方法：描述对象执行的操作。动态的。
--由一组属性和方法构成，描述客观存在的一个“实体”（对象）
--具有相同属性和方法的一组对象的集合，类是对象的抽象化描述，对象是类的具体实例。（类）
对象和类是面向对象编程的核心。
-所有的java程序都是以类class为组织单元，一个Java文件就是一个类。
真正执行程序时通过类的具体化对象来完成的。
方法调用注意：
基本数据类型传递变量的值
引用数据类型传递是地址
结构化开发：面向过程
面向功能划分的软件结构
从上到下，按步执行
最小的粒度是方法
步骤繁琐，制约了软件的可维护性和可扩展性
代码一次成型，后续修改非常麻烦
面向对象开发
把软件系统看成各种对象的集合
系统结构稳定
子系统相对独立
软件较好的可维护性，可扩展性强
面向过程编程：
关注点在于每一个细节，每一步的具体操作。
面向对象：
关注点在于整个事件的参与对象，将系统中的参与者全部看成模块化的对象。
面向对象程序设计：OOP
编程思想，思维模式：将程序中的所有参与者模块化为对象，然后通过各种对象之间的相互作用关系来完成程序的需求。
类：对象的模板，抽象化的对象 如：Scanner工具类
对象：类的具体实例化
方法：
void：关键字
有值：声明一个类型
如果返回值不是void，那么在方法当中，必须执行一次，也之恩那个执行一次return
return执行之后，后面的代码会报错！
1. 修饰符 返回值类型 方法名（形参列表）{方法体}
形参列表：形参是指，传递给方法的参数类型。
实参：调用的时候，具体传递值。
参数传递:
实参和形参的个数要对应
类型位置要一一对应
形参属于局部变量
***不定长参数：
形参的定义方式：类型 ... 变量名
实参的传递：类型统一，个数随意（0-n）
不定长参数处理，当成一个数组处理。
一个参数列表中，不定长参数只能有一个，而且只能放最后
一般来说：不定长参数用的不多。--Java中没有默认值！
2.地址传参******
什么是地址？
实例化对象后————new()，就是新的对象。
如果是对象之间的赋值，那么赋值的是堆内存的地址。
在使用引用数据类型之前，请务必做好空值判断。
引用传参
3.构造方法：
1.构造方法：描述一个对象的生成过程
2.虚拟机默认会添加无参构造；如果显示声明过，则会覆盖。
4.无论是构造方法，还是普通方法，都可以重载。
在方法当中，直接调用变量名，优先取局部变量！
This关键字：-->计算机组成等等底层的重要性！
这方面未来有希望！！！（突破基础理论+应用）
this:当前对象本身
--理解：this.wait()
this.notifyAll()
this()只能写在第一行————只能调用一次构造。
作用域：
1.代码块：写在一对花括号中间的。
2.Java的作用域，叫块级作用域
3.成员变量：直接卸载类当中，也叫：全局变量，处于犬奴作用域当中。
4.局部变量：在方法当中（包括构造函数，静态代码块中）
5.里面可以调用外面的，外面不可以调用里面的，平级之间按相互不干扰。
6.成员变量会有初值：参考数组
7.局部变量没有初值,必须初始化！！！
8.局部变量不可以有访问修饰符*****
9.局部变量的优先级是高于全局变量的
封装
封装：将类的某些信息隐藏在类的内部，不允许外部程序直接访问；
外部只能通过该类提供的特定方法来实现对隐藏信息的操作和访问。
如何实现封装：
1.修改属性的访问权限，设置为private（私有）
2.创建共有public的getter和setter方法
getter：让外部来获取属性的方法
setter：让外部来修改属性的方法
3.setter方法中加入属性控制语句，以确保属性的正确性和合理性。
static修饰符：静态修饰符
1.成员变量——静态变量，通过类名直接调用
2.成员方法——静态方法，通过类名直接调用
3.代码块：写在类中，方法之外，并且用{}包裹起来的一段代码。
当程序中访问该类时，自动执行代码块中的语句。
JVM加载该类时，执行该代码块，只执行一次。
--用static修饰的成员变量也叫做类变量，表示该变量不再属于某个对象，而是属于该类，所有的对象共享该属性。（内存中只有一份）
实例变量——不用static修饰
静态方法：
1.不能访问非静态方法、属性
2.不能使用this关键字（实例化对象）---静态关键字描述的是一种共有的信息，不属于任何一个实例对象，属于类，被所有的实例对象所共用。
类的构造函数：给成员变量赋值，初始化
类的静态代码块：给静态变量赋值
继承
protected：同包 和 子类可见
不写（默认的）：同包可见
private：同类可见-最终类，不可被继承
-最终方法，不可被重写
继承：子类对父类的继承
父类：
子类：使用extends继承父类，除了私有和父类构造以外的所有成员。单根继承原则：每个类，只能有一个直接的父类。
this：对象本身
super：代表父类对象（包含 继承链上的所有）对象
-super可以调用父类的构造、属性和方法。
1.默认情况下，子类构造将默认调用父类的空参构造 。
2.如果父类没有空参构造，则子类需指定（显示）调用某个构造。
-如果不在同一个包里，默认的成员则无法继承，但是可以继承protected的成员；
-如果在同一个包里，则除了私有以外，都可以继承。
3.使用this和super可以用来区分：父类和子类当中的成员。
如果该成员是继承来的，那么也可以使用this来调用。
4.为了防止父类和子类属性之间的相互污染。【属性】
5.如果说，在子类当中不满足父类的某个方法，需要对该方法进行修改或补充，那么可以通过方法重写来实现。
-当子类重写了父类的某个方法后，子类调用重写后的方法；父类调用原本的方法。
-当父类当中有某个成员方法被多次重写，那么子类优先调用最近的那个！
-构造方法不能被重写
-重写可以理解为“覆盖”
--访问权限不能严于父类。
--返回值和父类相同，或者是父类返回值的子类。
--参数列表相同
--方法名一样
--重写是父子之间。
**父类当中的静态方法不能被子类覆盖为非静态；父类中非静态不能被覆盖为静态。
---实际应用当中：重写就是子类重写父类当中同样的方法。
实例化对象问题！
--初始源头
-实例化一个子类对象时，一定会优先实例化其父类对象。
并且实例化父类对象的操作是系统自动完成的，不需要我们自己编写代码！
--super（）默认存在，不需要显示调用，跟无参构造相同。默认存在，不需要显示定义。
如果显示调用，super()必须写在第一行，否则语法报错。
-在子类中可以使用super调用方法，也可以访问属性，只能访问父类的公有的信息(包括间接父类)，私有是无法访问的。
子类的构造函数中可以通过super来访问父类的所有公有信息（属性、方法、构造方法）
子类的普通方法中通过super可以访问属性和方法，但是不能调用构造方法。Java中的每一个类，都是一个子类（Object除外），但 不是每一个类都是父类。
super 与 this的区别：
相同点：super和this都可以访问类中的属性、方法、构造方法
super、this访问构造方法时，必须写在第一行。
super、this访问构造方法时，必须写在构造方法中!
不同点：super时子类访问父类，维护两个类之间的关系。&& this是自己访问自己，维护一个类的关系。
super 不能访问私有属性和方法，this可以访问私有属性和方法。
通过无参构造创建子类对象时
-子类无参构造默认调用父类的无参构造。
-手动调用父类的有参构造，会将默认的无参构造覆盖
通过有参构造创建子类对象时
-子类有参构造默认调用父类的无参构造 ****
-手动调用父类的有参构造，会将默认的无参构造覆盖
多态：同一个引用类型，因为实例不同，表现的形式也不同。
向上转型：父类声明指向子类对象。
1.向上转型：父类声明
（1）只能调用子类重写的方法，
（2）或者本身实现，没有被子类覆盖的方法。
---子类特有的方法无法被调用，
？强转一下，应该可以?
(3)向上转型，属于自动类型转换。
**多个子类实现重写的方法，优先调用距离实现类最近的！
2.向下转型：强制将父类型变为子类型。
（1）前提：向上转型后，才能向下转型。
（2）向下转型之前，一定要判断实例的类型。// class cast exception
（3）向下转型属于强制类型转换！
多态——业务需求，频繁更改代码，可维护性、可扩展性比较差的问题
：一个事物，多种表现形式。
多态在实际使用中，需要建立继承关系，建立接口和实现类的关系。 *****
继承和方法重写是实现多态的基础。
1.定义方法形参（形式参数）的数据类型为父类；实际调用为传入子类的实参
2.定义方法时，返回值类型为父类，外部调用该方法时使用子类接收多态衍生：抽象类
抽象类不能在外部实例化！！！
--但是可以通过实例化继承子类，自动实现实例化抽象类。没有抽象的构造方法，也没有抽象的静态static 方法。
抽象类中可以包含非抽象的构造方法， 创建子类实例对象时可以调用。
面向对象编程
开发期间：类是构成Java程序的单位，Java程序通过类来组织其结构
运行期间：对象是Java程序在运行时的单位，运行期间的Java程序是通过多个对象之间的相互作用关系来完成需求，动态。
null:空指针，内存地址的一个值，指空，不存在。
垃圾回收机制GC：是一个独立的巡查线程，GC是一个定时任务，隔一段时间执行一次。基本数据类型在栈内存中开辟空间，同时直接将具体数值（而不是地址）保存在栈中
--int numb = null;报错
引用类型在栈中开辟空间，同时在堆中开辟空间，创建对象，将对象地址保存在栈中。
抽象类
在class前加关键字abstract,用于表示当前类为抽象类。
**在抽象类中，可以有普通方法，也可以有抽象方法。
-抽象方法之只能在抽象类当中声明。
-在修饰符和返回值之间，添加关键字 abstract,抽象方法没有方法体。
-不需要立即实现。
***没有抽象的属性
抽象类不可被实例化
抽象方法必须在子类当中被实现，除非子类也是抽象类。
——在抽象类的子类当中，只要有一个子类实现了抽象方法，其后代不必一定实现该抽象方法。
抽象类可以有构造?
-原理：
抽象类的构造函数用来初始化抽象类的一些字段，
而这一切都在抽象类的派生类实例化之前发生。
不仅如此，抽线类的构造函数还有一种巧妙应用：就是在其内部实现子类必须执行的代码。
综合应用——面向接口编程
面向接口编程是常见的一种开发方式。
-面向接口编程就是将程序的业务逻辑提取出来，以接口的形式去对接不同的业务模块，接口只串联不实现，真正的业务逻辑交给接口
的实现类来完成，当用户需求发生变更时，只需切换不同的实现类即可。
（连接松散，低耦合）
“低耦合---高内聚”
低耦合：降低模块之间的链接的紧密程度，模块之间是一种非常松散的状态，利于维护和扩展。
高内聚：将相关的业务逻辑尽量集中到一个模块中。
面向接口编程的优点：
1.能够最大限度地解耦，降低程序地耦合性
2.使程序易于扩展
3.有利于程序的后期维护如何使用接口:
默认都是抽象方法，abstract可省略；
接口中可以定义成员变量，但是有如下要求：
1.不能定义private、protected的权限修饰符，可以使用public 、默认修饰的成员变量
2.成员变量必须被初始化（final***)
3.接口中的成员变量必须是静态static，同时该成员变量还必须是一个常量！
（static final都可以省略）
成员变量：定义在类中，方法体外的变量，属性。
局部变量：定义在方法提中的变量
区别：
1.作用域不同：变量的使用范围
局部变量仅限于定义它的方法中，方法外无法访问。
成员变量的作用域在整个类中都是可见的。
2.初始值不同
属性、成员变量都有一个初始值，初始值根据属性的数据类型来决定。
基本数据类型：byteintshortlong :0
char:' '
boolean:false
String引用类型：null
方法重载：（方法允许重名）
1.同一个类 ***
2.方法名相同
3.参数列表不同，个数、数据类型不同
4.与返回值、访问权限无关。
== 和 equals()的区别？
==：栈内存中的值是否相等
如果数据是基本数据类型，比较的是数据的值是否相等，
如果是引用类型，比较的是引用地址(数据的内存地址是否相等)
equals():Object类中定义的一个方法，默认方法体是通过==进行判断的（只能使用引用数据类型进行调用）
默认是比较数据的内存地址
重写，按照实际。（equals（）方法经常会被Object的子类进行重写，比较典型，
String类中的重写--字符串的值是否相等进行判断，改为判断String的数组内容进行比较）
switch(num):num为除long型以外的整数+String（jdk>7）+char
--switch{}，为独立的作用域
--无需依次比较，一次找到目标
--default:当所有条件都不满足的时候，执行default
可以有，也可以没有；可放置在任意位置；
-习惯放在首位、末尾，如果不在末尾需要加break;循环：
四大要素：
初始化变量
判断条件
循环体
迭代:无限趋近目标