面向过程中，执行者
面向对象中，指挥者
一、类:
1.1定义类的格式
public class 类名 {
//可编写0至n个属性
数据类型 变量名1；
数据类型 变量名2；
//可编写0至n个方法
修饰符 返回值类型 方法名(参数){
执行语句;
}
}
1.2创建对象的格式：
类名 对象名 = new 类名();
1.3内存对象创建过程
1.4类的概念：类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。类用于描述多个对象的共同特征，它是对象的模板。对象用于描述现实中的个体，它是类的实例。
基本类型和引用类型作为参数传递
面向对象共有三个特征：封装，继承，多态
二、封装
2.1封装表现：
1、方法就是一个最基本封装体。面向过程的语言 面向函数编程
2、类其实也是一个封装体
从以上两点得出结论，封装的好处：
1、提高了代码的复用性
2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。
3、提高了安全性
例如： Arrays.sort(arr);//完成排序 sort方法封装了排序的算法
三、继承
3.1关键字 extends
格式：
class 子类 extends 父类 {}
3.2继承：是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有
3.3继承的好处：可继承的属性和方法。
提高了代表的可维护性
提高了代码的复用性
让类与类之间产生了继承关系
3.4继承的弊端：
类与类之间的耦合度过高
3.5继承特点：
java中类只能够单继承，不能多继承，可以多层继承
所有的类都直接或者间接的继承了 Object类，Object类称为祖宗类
3.6继承的注意事项：
1，使用关键字 extends 让类与类之间 产生继承关系
2, 父类私有的成员，子类不能继承，因为根本看不到
3，不能为了继承某个功能而随意进行继承操作， 必须要符合 is a 的关系
苹果 is a 水果
男人 is a 人
狗 is a 人 ， 这种情况就不能继承了
3.7方法重写的注意事项：
1，子类方法覆盖父类方法，必须要保证权限大于等于父类权限
2，写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样
3.8继承中的成员变量关系：
不同名的变量：子类直接继承使用
同名的变量：默认访问的是子类自己的成员变量, 想访问父类中的同名变量，使用 super.成员变量;
3.9继承中的成员方法关系：
不同名的方法：子类直接继承使用
同名的方法：默认访问的是子类自己的成员方法，想访问父类中的同名方法，使用 super.成员方法();
四、抽象
4.1抽象方法： 方法只有声明部分，没有方法体
4.2抽象类： 包含抽象方法的类，一定是抽象类；使用 abstract 修饰的类，是抽象类
4.3抽象类的特点：
1，抽象类与抽象方法都必须使用 abstract来修饰
2，抽象类不能直接创建对象
3，抽象类中可以有抽象方法，也可以没有抽象方法
4，抽象类的子类
a，实现了抽象方法的具体类
b，抽象类
4.4抽象关键字abstract不可以和哪些关键字共存？
1、private：私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。
2、final
3、static
4.5抽象类中是否可以没有抽象方法？如果可以，那么，该类还定义成抽象类有意义吗？为什么？
答：可以没有抽象方法，有意义，不会让其他人直接创建该类对象
4.6抽象类一定是个父类？
答：是的，因为不断抽取而来的
五、接口
5.1接口：理解为是一个特殊的抽象类，但它不是类，是一个接口
定义格式：
public interface 接口名 {
抽象方法1;
抽象方法2;
抽象方法3;
}
5.2接口的特点：
1，定义一个接口用interface关键字
interface Inter{}
2，一个类实现一个接口，实现implements关键字
class Demo implements Inter{}
3, 接口不能直接创建对象
通过多态的方式，由子类来创建对象，接口多态
5.3接口中的成员特点：
成员变量：只能是final 修饰的常量；默认修饰符： public static final
构造方法：无
成员方法：只能是抽象方法；默认修饰符: public abstract
5.4类与类，类与接口，接口与接口之间的关系
类与类之间：继承关系，单继承，可以是多层继承
类与接口之间: 实现关系，单实现，也可以多实现
接口与接口之间：继承关系，单继承，也可以是多继承
Java中的类可以继承一个父类的同时，实现多个接口
六、接口和抽象的区别
6.1通过上面的例子总结接口和抽象类的区别：
相同点:
都位于继承的顶端,用于被其他类实现或继承;
都不能直接实例化对象;
都包含抽象方法,其子类都必须覆写这些抽象方法;
区别:
抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;接口只能包含抽象方法;
一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)
抽象类是这个事物中应该具备的你内容, 继承体系是一种 is..a关系
接口是这个事物中的额外内容,继承体系是一种 like..a关系
二者的选用:
优先选用接口,尽量少用抽象类;
需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;
七、多态
7.1多态：理解为同一种物质的多种形态
7.2多态使用的前提：
1，有继承或者实现关系
2，要方法重写
3，父类引用指向子类对象
7.3多态的成员访问特点：
成员变量 编译运行看左边
成员方法 编译看左，运行看右边
7.4多态的好处：
提高了程序的扩展性
7.5多态的弊端：
不能访问子类的特有功能
7.6多态的分类
类的多态
abstract class Fu {
public abstract void method();
}
class Zi extends Fu {
public void method(){
System.out.println(“重写父类抽象方法”);
}
}
//类的多态使用
Fu fu= new Zi();
接口的多态
interface Fu {
public abstract void method();
}
class Zi implements Fu {
public void method(){
System.out.println(“重写接口抽象方法”);
}
}
//接口的多态使用
Fu fu = new Zi()
八、instanceof 关键字
格式： 对象名 instanceof 类名
返回值： true, false
作用： 判断指定的对象 是否为 给定类创建的对象
public class Test {
public static void main(String[] args) {
Animal a = new Dog(); //多态形式，创建一个狗对象
a.eat(); // 调用对象中的方法，会执行狗类中的eat方法
// a.lookHome();//使用Dog类特有的方法，需要向下转型，不能直接使用
// 为了使用狗类的lookHome方法，需要向下转型
// 向下转型过程中，可能会发生类型转换的错误，即ClassCastException异常
// 那么，在转之前需要做健壮性判断
if( !a instanceof Dog){ // 判断当前对象是否是Dog类型
System.out.println(“类型不匹配，不能转换”);
return;
}
Dog d = (Dog) a; //向下转型
d.lookHome();//调用狗类的lookHome方法
}
}
九、Final
final：关键字，最终的意思
final修饰的类：最终的类，不能被继承
final修饰的变量： 相当于是一个常量, 在编译生产.class文件后，该变量变为常量值
final修饰的方法： 最终的方法，子类不能重写，可以继承过来使用
十、static
10.1 static : 关键字， 静态的意思
可以用来修饰类中的成员(成员变量，成员方法)
注意： 也可以用来修饰成员内部类
10.2特点：
被静态所修饰的成员，会被所有的对象所共享
被静态所修饰的成员，可以通过类名直接调用，方便
Person.country = “中国”;
Person.method();
10.3注意事项：
静态的成员，随着类的加载而加载，优先于对象存在
在静态方法中，没有this关键字
静态方法中，只能调用静态的成员(静态成员变量，静态成员方法
十一、权限修饰符
public : 公共的
private : 私有的
public protected 默认的 private
在当前类中 Y Y Y Y
同一包中的其他类 Y Y Y
不同包中的子类 Y Y
不同包中的其他类 Y
Private (私有，权限修饰符)
总结：
类中不需要对外提供的内容都私有化，包括属性和方法。
以后再描述事物，属性都私有化，并提供setXxx getXxx方法对其进行访问。
注意：私有仅仅是封装的体现形式而已。
十二、this 、super
12.1 this关键字，本类对象的引用
1,this是在方法中使用的，哪个对象调用了该方法，那么，this就代表调用该方法的对象引用
2,this什么时候存在的？当创建对象的时候，this存在的
3,this的作用：用来区别同名的成员变量与局部变量（this.成员变量）
12.2 super: 指的是父类的存储空间(理解为父类的引用)
调用父类的成员变量：
super.成员变量;
调用父类的构造方法:
super(参数);
调用方法的成员方法:
super.成员方法();
在创建子类对象时，父类的构造方法会先执行，因为子类中所有构造方法的第一行有默认的隐式super();语句。
格式：
调用本类中的构造方法
this(实参列表);
调用父类中的空参数构造方法
super();
调用父类中的有参数构造方法
super(实参列表);
12.3当在方法中出现了局部变量和成员变量同名的时候，可以在成员变量名前面加上this.来区别成员变量和局部变量
class Person {
private int age;
public void setAge(int age) {
this.age = age;
}
12.4当子父类中出现了同名成员变量时，在子类中若要访问父类中的成员变量，必须使用关键字super来完成。super用来表示当前对象中包含的父类对象空间的引用
在子类中，访问父类中的成员变量格式：
super.父类中的成员变量
System.out.println(“Fu num=”+super.num);
//访问子类中的num2
System.out.println(“Zi num2=”+this.num);
在子类中，访问父类中的成员方法格式：
super.父类中的成员方法();
十三、构造方法
13.1构造方法： 用来给类的成员进行初始化操作
格式：
修饰符 类名 (参数列表) {
…
}
构造方法的特点：
1, 方法名与类名相同
2，没有返回值，也没有返回值类型，连void也没有
构造方法什么时候会被调用执行？
只有在创建对象的时候才可以被调用
13.2在方法之间调用时，可以通过方法名进行调用。可是针对构造方法，无法通过构造方法名来相互调用。
构造方法之间的调用，可以通过this关键字来完成
构造方法调用格式：
this(参数列表);
class Person {
// Person的成员属性
private int age;
private String name;
// 无参数的构造方法
Person() {
}
// 给姓名初始化的构造方法
Person(String nm) {
name = nm;
}
// 给姓名和年龄初始化的构造方法
Person(String nm, int a) {
// 由于已经存在给姓名进行初始化的构造方法 name = nm;因此只需要调用即可
// 调用其他构造方法，需要通过this关键字来调用
this(nm);
// 给年龄初始化
age = a;
}
}
构建创造时用的方法，即就是对象创建时要执行的方法。既然是对象创建时要执行的方法，那么只要在new对象时，知道其执行的构造方法是什么，就可以在执行这个方法的时候给对象进行属性赋值。
继承中的构造方法注意事项：
1，如果我们手动给出了构造方法，编译器不会在给我们提供默认的空参数构造方法
如果我们没写任何的构造方法，编译器提供给我们一个空参数构造方法
2, 在构造方法中，默认的第一条语句为 super();
它是用来访问父类中的空参数构造方法，进行父类成员的初始化操作
3, 当父类中没有空参数构造方法的时候，怎么办？
a: 通过 super(参数) 访问父类有参数的构造方法
b: 通过 this(参数) 访问本类中其他构造方法
注意:[本类中的其他构造方法已经能够正常访问父类构造方法]
4, super(参数) 与 this(参数) 不能同时在构造方法中存在