一、类和对象
1.类是什么？对象又是什么？类和对象的关系又是什么？
类就是一类事物的抽象概念，它不指代某一个具体的事物，而是将这一类事物所具有的特点进行抽取，然后形成一个带有范围指向性的概念。
对象就是某一类中的具体的指代，表示的是一个实实在在的具体的事物。由类生成对象的过程叫做实例化。
类是具有相同属性和行为的对象的集合或者说统称。
对象是由类创建出来的一个实体。这个实体所具备的属性和行为已经被类所规定好了。没有类，就无法创建对象。
实体类：现实世界中存在的
功能测试类：描述逻辑关系的，世界是由类和对象组成的。
类的创建：属性（名词）、方法（动词）。
线上模拟线下业务的步骤：
1.先分类 ：实体类
2.用变量表示他们的详细信息
3.处理数据（赋值，取值）
2.单元测试：
@Test(可以像主方法一样点击执行)
1.方法必须是公共的public
2.不能有返回值，不能有参数
3.不能和主方法相互调用。
要想使用单元测试需要做一下几点：
需要在IDEA文件夹中的lib中把hamcrest-core-1.3.jar和junit-4.12.jar
放入项目与src并列创建的lib的文件夹中，然后选中Add as Library…
单元测试中要使用Scanner方法需要：
help》Edit Custom VM Options…
里面最后一行加上：-Deditable.java.console=true
3.输出简洁方式
%s表示字符串 %d表示整数 %f表示小数
System.out.printf(“大家好，我是%s,我是个%s的，我今年%d岁，我的颜值%.2f,乖巧值是%.3f,”name,sex,age,yanzhi,cute);
.2表示小数后保留两位小数
.3表示小数后保留三位小数
4.类：
实参就是给形参赋值的
返回值：方法的产出物
参数：进入方法所需的原材料
main方法中调用其它方法：
1.实例化对象，通过构造方法（虚拟机开辟内存行为），得到一个类的对象。
2.对象调用方法。
凡是被static修饰的方法或属性都是属于类的势力（可使用）范围
没有static修饰的就是对象的可使用范围
二、方法
1.方法的组成：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){
执行语句
1.方法的调用
2.变量的操作：声明 赋值 修改
3.程序结构：选择结构 循环结构………
return 返回值;
}
2.修饰符：
1.访问（调用）权限修饰符 public 公共的，这个项目都可以用。Private 私有的，仅限当前类可用。
2.静态修饰符：static
3.返回值类型：
1.void没有返回值
2.有返回值：返回一个基本类型数据或引用类型数据（类、数组）
4.方法名：
第一个单词小写，第二个以及后续单词首字母大写，字母、下划线、数字组成。
5.参数：
可以没有，也可以有，参数的声明同变量的声明，仅仅只是定义类型，取名字，不赋值。
1.参数的分类：形参，实参。
2.形参和实参的关系：实参是给形参赋值的
3.形参和实参保持个数一致类型一致。
4.形参的使用范围：相当于方法体中声明的局部变量
扩展：可变形参数组：
1.声明方式 类型…参数名
2.如果还需要其他参数，将可变形参数组放在最后面
3.可以用length属性获取可变参数的个数
4.可变参数可以不传值
Static属于类的，所有对象公共的，共有一份。
实例的，每个对象单独拥有一份。
6.调用：
Static静态的，属于类的，通过类名调用。
实例的，属于对象的，通过对象来调用。
注意：类名只能调用静态的，对象即可调用实例的，也可以调用静态的。
Public class Person{
int a=0;//实例 有多个变量
static int b=0; //静态 只有一份。
psvm {
sout (Person.b);
sout(Person.a)错
Person p1=new Person();
p1.b=6; p1.a=6;
Person p2=new Person();
sout(p2.b)//6 so
ut(p2.a);//10
}
}
实例方法：public void fun1(){}
静态方法：public static void fun2(){}
同类中：
1.静态方法调用静态方法 类名.静态方法（）,可以省略类名。
2.静态方法调用实例方法 对象名.实例方法（）;
3.实例方法调用实例方法
一.this.实例方法() 可以省略this(当前对象) 二.实例对象.实例方法（）
4.实例方法调用静态方法 类名.静态方法（） 可以省略类名
不同类中：
1.静态方法中调用另一个类的静态方法 类名.静态方法（）
2.静态方法中调用另一个类的实例方法 对象名.实例方法（）
3.实例方法中调用另一个类的实例方法 对象名.实例方法（）
4.实例方法中调用另一个类的静态方法 类名.静态方法（）
7.构造方法：
1.每一个类都自带一个无参构造方法
2.构造方法返回值和方法重复的，因此省略了
3.有参构造：参数就是用来给成员属性赋值的
4.无参构造
引用数据类型的成员属性，默认值是null
无参构造创建的对象，属性都是没有赋值的，只有默认值。
有参构造创建的对象，同时也需要赋值。
8.重载：
同一类，方法同名不同参
不同类，参数个数不同，类型不同，顺序不同。
对象数组：User[] users={u1,u2,u3};
//增强for输出：for(User u:users){
sout(u.name+”–”+u.age)
}
对象数组作为方法的参数 addAge(users);
对象可以创建变量来接收值：Goods g=init();
三、封装和继承
1.封装：
为什么要封装：隐蔽性、安全性。
封装步骤：
1.成员属性私有（前面加个private）
2.提供公共的get（getter）和 set(setter)方法
//setter赋值
public void setSex(char sex){
this.sex=sex;
}
//getter获取
public char getSex(){
Return this.sex;
}
2.包：
导包：导入自己的包和系统的包
java.lang包是java语言的核心它提供了java中的基础类。（java.lang这个包属于系统包，该包中的类不用导入，例如System,String）
3.访问修饰符：
下图中：受保护的情况（protected） :子类必须在同一个包中。
类的访问修饰符：
Public：对外公开
默认：所在包有效，包以外不能访问 --体现在构造方法上
成员访问修饰符（成员属性和成员方法）
Public：对外公开
Protected：受保护的，同一个包的子类可以访问。
默认：同一个包中可以访问
Private：只在当前类有效
4.static和this关键字
所有被static修饰的，都会随着类的加载而加载。
所有的实例，都会因为对象的创建而加载
Static修饰的，属于类范围的，this代表当前对象。
Static修饰成员属性和方法和代码块
this的含义：
1.表示当前对象–出现在实例方法中
2.表示其他构造方法–出现在构造方法中，必须在第一行
注意：this不能出现在静态方法中
5.继承：
1.在多个子类中抽取出相同的属性和方法，形成父类的属性和方法
2.对父类成员的继承使用（包含成员属性和成员方法）
抽取出共有的重复的代码，使用继承，提高代码的复用性，
让类与类之间产生关系：extends
继承是两个类之间产生关联关系的唯一的方式
子类构造方法会默认调用父类构造方法。
为多态提供了前提
Java中支持单继承：一个子类只能有一个直接父类
Java中不支持多继承
6.this和super的区别：
this:
1.本类成员方法中，访问本类成员变量，访问本类另一个成员方法
2.本类构造方法中，访问本类另一个构造方法
super:
1.在子类成员方法中，访问父类成员变量和成员方法
2.在子类构造方法中，访问父类构造方法
本类的成员变量和局部变量重名，用this区分，
本类的成员变量和父类的变量重名，用super区分
7.重写（覆盖）和重载：
重载：同一个类中，方法名相同方法参数不同，典型应用：无参构造和有参构造
重写：子类和父类同名的方法。
子类方法和父类方法同名，子类方法会覆盖父类方法，称为重写（覆盖），前提，子类方法访问权限必须大于或等于父类方法的访问权限
8.Final：
修饰的变量称为常量，值不能被修改
修饰的方法不能被重写，保证安全性和稳定性
修饰的类不能被继承，避免功能被覆盖。
9.要想让一个类不被其它类继承：
1.用final修饰
构造方法私有化
10.继承总结：
访问修饰符：
Public:整个项目
默认的：同一个包
Protected:同一个包，子类中可以用
Private:当前类
Static:静态的，仅有一份，属于类的，所有对象公共的
This:实例方法–当前对象this.属性/方法，构造方法–其他构造方法this();
Super:实例方法中–父类对象super.父类属性/父类方法，构造方法–父类构造方法this();
继承：
1.类和类的关系：包含、附属。
2.抽取相同的属性和方法放在父类中，让子类去继承使用。
方法的重写：覆盖
子类和父类中同名的方法
子类功能比父类功能强大
四、多态
1.重写object类的equals方法
1.Object类的equals()方法：
比较两个对象是否是同一个对象，是则返回true
Object类是所有类的父类，它的equals方法自然会被所有类继承，有一个子 类String对equals方法进行了覆盖（重写），使其具有了新功能
2.操作符==
简单数据类型或常量值，直接比较值。
引用类型，比较是否为同一个对象。
（1）Object类的equals()方法和两个 = 没区别
（2）Java.lang.String重写了equals()方法，把equals()方法的判断变为了判断其值
（3）当有特殊需求，如认为属性相同即为同一对象时，需要重写equals()
案例：
1.分析String类时如何重写equals方法的。
2.在Pet类中重写equals方法
总结：
1.基本数据类型数据值只能用两个=
2.对于引用数据类型，两个 = 和Object的equals方法是一样的。
3.由于String类对父类Object的equals方法的重写，导致==与equals唯一的区别在于：
2.instanceof
java中的instanceof运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例
使用格式： 对象 instanceof 类
使用解析：
形参 和实参 和 右边的类型
主要是看实参对象是否属于右边的类型
3.多态
封装以后，我们可以使用两种方式为对象属性赋值，set方法和有参构造。
什么时候使用set，什么时候使用有参构造。
Set可以在创建对象以后，反复的对属性值进行修改。而有参构造是在产生对象的同时就为属性赋值，且同一个对象只能使用一次。
1.什么是多态？
//把子类的实例化对象赋值给父类的引用类型
继承 Fu f=new Zi(); Pet p=new Dog(); Pet p=new Penguin();
重写 f.a();
多种状态 多态=继承+重写
2.案例理解：
1.使用多态实现宠物看病
2.使用多态实现宠物喂食。
3.捐献宠物系统
应用：
1.父类作为方法的形参 （多态最常用的使用方式）
案例：狗狗和企鹅都有看病的方法，如果健康值<50,主人就带它们去看病。
2.父类作为方法的返回值
例：捐献动物
Fu f=new Zi();
父类—静态方法 子类—实例方法
多态中：
调用子类的实例方法，子类覆盖父类同名实例方法
调用子类静态方法，永远也掉不到
每个方法都有一个常量池
向上转型和向下转型
多态的接地气的理解：父类作为形参，子类类型作为实参。
向上转型：----子类给父类
Pet a =new Dog()；
父类 子类
Object aa=a;
向下转型：—先向上，后才能向下，而且不能降到比之前还低。
Dog b=(Dog)a;
Dog e=(Dog)aa;
重写equals
重写比较规则，判断两名学员（Student）是否为同一对象
Student相关属性
Id（学号）、name（姓名）、age（年龄）
如果两名学员的学号以及姓名相同，则为同一对象
先要修改equals方法然后再进行比较。
五、抽象类和接口
1.抽象方法衍生背景
“用进废退”：多态的领域， 父类中被子类重写的实例方法，功能逐渐淡化，索性去掉方法体 退化为抽象方法。
2.抽象方法使用规则
1.抽象方法没有方法体
2.含有抽象方法的类必须是抽象类
3.抽象类中可以暂时没有抽象方法
4.抽象类中的抽象方法跟子类有什么联系？
(1)如果子类完全实现了父类的抽象方法，那么子类可以不用声明为抽象类
(2)如果子类没有完全实现父类的抽象方法，那么子类必须声明为抽象类
3.抽象类的语法规则：
1.被abstract修饰的类是抽象类
2.抽象类中可以有抽象方法，也就是被abstract修饰的方法，也可以没有。
3.抽象方法没有方法体，只有方法声明。
4.子类继承抽象类需要重写父类所有的抽象方法，否则，子类也必须声明为抽象类
5.抽象类有构造方法，但是不能被显示调用，也就是不能实例化，或者说抽象类没有对象。–防止直接调用抽象方法
6.抽象类的构造方法只在子类实例化时隐式调用。
7.抽象类的使用一般是作为引用类型，指向非抽象的引用实例，体现出多态。
8.构造方法和静态方法都不能（abstract）抽象修饰
静态方法不能被子类覆盖（重写），一旦声明为抽象方法 将永远没有具体的实现
4.接口：
定义一个接口：
public interface 接口名{
}
接口的成员：
成员属性：public static final （公共的静态常量）类型
成员方法：public abstract （公共的抽象方法） 或静态方法
接口的应用理解：
接口可以理解为定义的一组通用的组件，或者是对外提供服务的功能模块，具体可替换，可拆卸的特点。接口比抽象类更抽象，已经完全抽象得没边没影。
接口通常作为实体类的成员属性，和实体类是附属关系，而不是包含关系。
为什么接口中的属性是静态的常量？
(1)首先接口由于少了方法的实现，所以不能实例化，这个与抽象类一致，
(2)由于不能实例化，所以对于成员变量只能是static
(3)由于是static所以所有实现了接口的类共享一份
(4)由于所有人共享一份，同时接口的定义是“所有实现该接口的人都共同拥有这些属性/功能”
(5)由于所有的实现类都共同拥有，若是变量则实现类A的改变会导致实现B的改变
(6)会由于实现类的操作而改变的东西违反了接口的定义
(7)所以为了确保每个实现的接口都共同遵守这个“属性”，属性必须是final
(8)由于接口本身的定义是public，最后就是 public static final xxx
(9)若以上说明不够清楚，那就理解为：甲鱼的臀部–龟腚
5.关于default：
1.Jdk8开始，允许接口中有实例方法，但是必须被default修饰
2.出现背景：
对已有的接口，如果想对接口增加一个新方法，那么需要对实现该接口的所有类进行修改，如果接口实的现类很多，就会带来很大的工作量，而且还很容易破坏以前的代码，带来一些问题。如果把新的方法定义为default方法，就可以避免对其他实现类的修改。
3.语法规则：
1.实现类不需要重写default修饰的方法 但是也会继承接口中的default方法
2.如果一个类同时实现接口A和B，接口A和B中有相同的default方法，这时，该类必须重写接口中的default方法。为什么要重写呢？是因为，类在继承接口中的default方法时，不知道应该继承哪一个接口中的default方法。
3.如果子类继承父类，父类中有b方法，该子类同时实现的接口中也有b方法（被default修饰），那么子类需要同时重写父类和接口中的b方法。
4.如果一个接口A被标记成函数式接口，那么他所继承的父接口中的抽象方法 必须要用default方法重写，因为函数式接口的规定是：接口中只能有一个抽象方法。接口A中的抽象方法加上继承的父接口中的抽象方法个数之和只能是1
6.总结
1.抽象度：接口>抽象类>类>对象
2.抽象类不能显示调用构造方法，不能直接创建对象，但可以在子类调用构造方法时隐式被调用。
3.接口中只有抽象方法和静态方法，default方法，没有构造方法。
4.接口：提供连接外部组件的口子，理解为一个插口，插槽。所以属性和方法都必须是public
5.抽象类抽掉了对象的概念，接口进一步抽掉了类的概念。
6.接口中的属性没有set/get，也就是不能封装，是static final类型，因为接口已经不再可以理解成类，而是一个组件。组件的属性在出厂时就已经定型了。
7.多态的使用演变：
- Fu f=new Zi(); Fu是一个普通类
2.Fu f=new Zi(); Fu是一个抽象类
3.Fu f=new Zi(); Fu是一个接口，(使用最多)