一、学习内容
1.面向对象
1.1 什么是对象
万物皆对象，客观存在的事物都是对象，大到名胜古迹，小到剪刀、钟表、信封等
1.2 什么是类
类是对现实生活中一类具有**共同属性**和**行为**的事物的抽象
类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
简单理解：类就是对现实事物的一种描述
手机---=>抽象的概念 分类 类的概念 抽象
手机 品牌名称 品牌价格 品牌规格
类的特点：
1.类是对象的数据类型；
2.类是具有相同属性和行为的一组对象的集合；
1.3
什么是对象行为
->行为 对象能够执行的操作(打电话，吃饭，这都是操作)
1.4
类和对象的关系
类：类是对现实生活中一类具有共同属性和行为的事物的抽象
对象：是能够看得到摸的着的真实存在的实体
简单理解：类是对事物的一种描述，对象则为具体存在的事物
类是对象的抽象，对象是类的实体。
手机类{----抽象的概念 小米手机 华为手机 oppo手机等。
属性：品牌的名称
属性:品牌的价格
属性：品牌的规格
行为：拨打电话
行为：发送短信
1.5
类的定义
1.类的重要性：类是java程序的基本组成单位
类是什么：是对现实生活中一类具有共同属性和行为的事物的抽象，确定对象将会拥有的属性和行为
2.类的组成：（属性和行为）
属性 在类中通过成员变量来体现（类中方法外的变量）
行为 在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
1.6
类的定义步骤：
1.定义类---手机 小米 华为 等
2.定义成员变量 手机属于什么品牌、价格... 参数
3.定义成员方法 手机发送短信、手机拨打电话 行为
1.7
1.创建对象
格式：类名 对象名 = new 类名();
范例：Phone phone1 =new Phone();
2.使用对象
#2.1使用成员变量
格式： 对象名称.变量
范例: phone1 .brand="xiaomi";
#2.2使用成员方法
格式： 对象名称.方法名
范例：phone1.call();
**学生 ----类 抽象的概念**
**名称 年龄---- 类中 成员属性**
1.8
this关键字
this修饰的变量用于指代成员变量
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
什么时候用this？ 解决局部变量隐藏成员变量
this：代表所在的类对象的引用
方法被哪个对象调用，this就代表哪个对象
this.使用细节
1.this关键字可以用来访问本类的属性、方法、构造器
2.this用于区分当前类的属性和局部变量
3.访问成员方法的语法：this.方法名（参数列表）
3.访问构造器语法：this（参数列表）；注意只能在构造器使用(即只能在构造器中访问另外一个构造器)
必须放在第一条语句
4.this不能在类定义的外部使用，只能在类定义的方法中使用
1.9
什么是封装
面向对象的三个基本特征（oop）之一：(封装、继承、多态 )
封装，也就是把客观事物封装成抽象的类，
并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
封装的规则：
1.将类的某些信息隐藏在类的内部，不允许外部的程序直接访问；
2.通过该类提供的方法来实现对隐藏信息的操作和访问；
封装的实现：
1.修改属性私有(设为private)
2.创建getter/setter方法(设为public用于属性的读写)
3.在getter/setter方法中加入属性控制语句(对属性的合法性进行判断)
2.0
什么是继承
继承是面向对象的三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义、追加属性和方法
继承的格式：
public class 子类名 extends 父类名{}
父类：也被称为基类、超类
子类：也被称为派生类
范例：public class Student extends Parent{
}
2.1
继承的优点
1.好处：
提高了代码的复用性（多个类相同的成员属性和方法可以放到一个类当中）
提高了代码的维护性（如果方法的代码需要修改，只需修改一处即可）
2.弊端：
继承让类与类之间产生了关系，类的耦合性也增加了，当父类发生变化时候，子类也不得不跟着变化，
削弱了子类的独立性。
什么是使用继承？
假设法：我有两个类A和B，如果满足A是B的一种，或者B是A的一种，就说明他们存在继承关系，
这个时候就可以考虑使用继承，否则不能滥用继承。
苹果和水果/ 猫和动物 狗和狮子
2.2
继承中构造方法的访问特点
1.子类中所有的构造方法默认都会访问父类中的无参的构造方法
2.因为子类会继承父类中的数据，可能还会使用父类中的数据，所以子类初始化之前，需要对父类进行初始化。
3.每个子类构造方法的第一句默认都是：super()
如果父类中没有无参构造方法，只有带参构造方法，怎么办？
1.通过super关键字显示调用父类的有参构造方法
2.父类中自己单独定义一个无参构造方法
2.3
方法的重写概述：
子类中出现了和父类一模一样的方法
当子类需要父类的功能，而功能主体中，子类有自己独特的内容，就可以通过重写父类中的方法，
这样即延续了父类的功能，又定义了自己的特有内容
@Override
是一个注解（注解后面会学习到）
可以帮我们检查重写方法声明的正确性
----------------------
因为父类的方法不能完全实现想要的功能，它只能实现部分我们需要的功能，
所以重写的方法是扩展了父类方法的功能。
如果父类方法能完全实现我们想用的功能，就不需重写该方法；
如果父类方法所实现的功能跟我们所需的功能完全不同，就要全部重写；
如果父类方法只是部分实现了我们所需的功能，就要在重写方法时调用父类方法，并在其上扩展功能。 q
2.4
Java有四种访问权限，
其中三种有访问权限修饰符，分别为private，public和protected，default
还有一种不带任何修饰符：
1.private: Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。
被其修饰的类、属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。
2.default：即不加任何访问修饰符，通常称为“默认访问模式“。该模式下，只允许在同一个包中进行访问。
3.protect: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护形”。
被其修饰的类、属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
4.public： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。
被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包（package）访问。
2.5
状态修饰符
1.final(最终态)
修饰我们的成员方法、成员变量、类
（1）特点:
修饰变量:该变量的值，不能被修改,必须初始化（手动赋值）被称为常量
修饰方法:该方法，不能被重写
修饰类:该类，不能被继承
final修饰的局部变量
基本数据类型：final修饰的基本数据类型的值不能够被修改的；
引用数据类型：final修饰的引用数据类型引用类型地址不能够发生变化的，但是引用类型的
地址里面的成员属性值是可以发生变化的。
****
2.static(静态)
static 翻译中文“静态”的意思，可以修饰成员方法、成员变量。
static 修饰的特点：被类的所有对象共享访问。
非静态成员方法
1.能够访问静态的成员变量；
2.能够访问非静态的成员变量;
3.能够访问静态的成员方法;
4.能够访问非静态的成员方法;
静态的成员方法
1.能够访问静态成员变量,但是不能够直接访问非静态成员变量
2.能够访问静态的成员方法，但是不能够直接访问非静态成员方法
一句话描述就是：方便在没有创建对象的情况下进行调用(方法/变量)。
显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，
只要类被加载了，就可以通过类名去进行访问。
static可以用来修饰类的成员方法、类的成员变量，另外也可以编写static代码块来优化程序性能
2.6
多态的概述:
同一个对象，在不同的时刻表现出来的不同形态
举例子： 狗
狗就是狗 狗 dog =new 狗();
我们也可以说 动物 animal =new 狗();
这里狗在不同的时刻表现出不同的形态，这就是多态。
多态的前提和体现
1.有继承/实现关系；
2.方法重写
3.有父类引用指向子类对象
(左) Animal animal =new Dog(); (右)
成员变量：编译看左边，执行看左边；
成员方法：编译看左边，执行看右边；
为什么成员变量和成员方法的访问不一样呢?
这是因为 成员方法有重写、而成员变量是没有的。
2.7
多态的优缺点
多态的好处：提高了程序的扩展性
具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作
多态的弊端：不能使用子类的特有功能
2.8
多态的转型
1.向上转型（多态机制）
从子到父
父类引用指向子类对象
Animal animal =new Dog()
2.向下转型（强转）
从父到子
父类引用转为子类对象
Dog animal1 = (Dog) animal;
2.9
抽象类概述：
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
抽象类和抽象方法用abstract关键字来修饰
抽象类： abstract class 类名{}
抽象方法： pubic abstract void eat();//抽象方法中没有方法体
3.0
抽象方法的特点:
1.抽象类中不一定有抽象方法，但是有抽象方法的类必须为抽象类；
2.抽象类不能实例化；
3.抽象类由具体的子类进行实例化；
4.子类必须对父类（抽象类）中的所有抽象方法进行重写
5.在抽象类中可以定义非抽象方法
6.子类如果不重写抽象类中的抽象方法，则该类还是为抽象类
7.抽象类中可以有构造方法，用于子类访问父类时的数据初始化；
3.1
abstract关键字不能和哪些关键字共存
private 冲突 abstract的方法必须被子类重写，而private不能被继承
final 冲突 final修饰的方法，变量都不能修改，而abstract修饰的方法必须被重写
static 不能共存 无意义 static 是静态的，abstract方法中无方法体，无法调用。
3.2
什么是接口：
接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
Java中的接口更多的体现在对行为的抽象！
1.接口 用关键字interface 修饰
public interface 接口名{}
2.类实现接口用 implements 表示
public class 类 implements 接口 {}
3.接口不能够实例化
接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。
多态的形式：具体类多态，抽象类多态，接口多态。
4.多态的前提：有继承或者实现关系；有方法重写;有父(类/接口引用)指向(子/实现)类对象
5.接口的实现类，要么重写接口中所有的抽象方法、要么是抽象类
3.3
1、成员变量只能是常量；（直接通过接口名称访问即可）
默认修饰符 public static final
2、成员方法只能是抽象方法；（JDK8开始 是可以在接口中定义非抽象方法 是需要加上default关键字修饰）
默认修饰符 public abstract
3、接口没有构造方法；
因为接口主要对行为进行抽象,没有具体存在，一个类如果没有父类,默认继承自Object类
3.4
类和接口的区别
1.类和类的继承关系 （一个类只能够单继承一个父类 不能够多继承n多个不同的父类 ）
继承关系,只能单继承,但是可以多层继承
2.类和接口的实现关系（一个类可以实现n多个不同的接口）
实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口
3.接口和接口继承的关系（一个接口是可以继承n多个不同的接口的）
继承关系,可以单继承,也可以多继承
3.5
抽象类和接口的区别
1.成员区别
1.1抽象类 变量.常量;有构造方法;有抽象方法,也有非抽象方法
1.2接口常量,抽象方法（JDK8 在接口中定义 非抽象方法）
2.关系区别
2.1类与类 继承单继承
2.2类与接口 实现,单实现和多实现
3.3接口与接口 继承,单继承和多继承
3.设计区别
抽象类 对类抽象,包括属性,行为(对事物的抽象)
接口 对行为抽象,主要是行为(对行为的抽象)
3.6
抽象类和接口的区别
抽象类:
举个列子，现在要定义一个猫类和一个狗类，你可以直接定义两个类
这样设计完全可以，但是当某一天又要设计一个猪类呢，是不是又要重复以上的代码，这样是不利于代码的重用的，
我们看到猫类和狗类都有名字和颜色属性，都有吃和叫这两个行为，那么是不是可以抽象出一个公共基类呢，
这个公共基类和这些动物类的关系明显是is-a（父子继承）关系。
由于猫和狗叫的方式不同，所以这个类不能是普通的类，只能是抽象类。
很明显这样实现了代码的重用，以后要设计一个猪类，只要继承BaseAnimal类并实现shout方法就可以了，
而不用写那么多重复的代码，那么能不能把BaseAnimal定义成接口呢，而不是抽象类？肯定是不行的，
先不说接口中不能定义color和name这两个域，即使这些动物只有行为没有属性，也是不能把BaseAnimal定义成接口的，
这些动物都有一个共同的行为，就是吃饭，每个实现类都去实现一遍相同的代码是没有意义的。
如果定义为接口，那么Cat类和Dog类是没办法扩展的，实现类要想扩展只能改变接口，但是接口和抽象类一旦定义好，
是不会轻易修改的，除非修改的内容对于实现类或者继承这个抽象类的类是有意义的，
因为接口和抽象类设计出来作为被公共使用的对象，
你不会知道有多少人在使用这个接口或者抽象类，一旦修改接口或抽象类，势必要惊动使用者，
而修改的内容，使用者也不一定能用到。抽象类就明显不同了，要想扩展猫类，直接修改猫类就行了，而狗类完全不受影响。
接口:
接口是一种约束和规则，一旦实现了某个接口，就必须实现这个接口中所有的方法，且这些方法对于这个类都是有意义的。
现在定义一个接口，接口中有两个方法，一个方法可以比较，一个方法显示动物的技能。
当需要设计一个既可以比较又有技能的动物类时，只要实现这个接口，那就必定要实现这两个方法。
没有接口，你可能设计出来的动物类只有技能，而忘了能比较这个功能。所以说，接口就是一份契约，由类实现契约。
契约中我编写了某些大的方针与前提，而签了约的类可以具体问题具体分析来实现自己的功能
3.7
内部类:
成员内部类
静态内部类
方法内部类
匿名内部类
