本文详细介绍了java面向对象的相关知识，包括但不限于以下知识：
- 类与对象
- 面向对象三大特征：封装、继承、多态
- 面向对象三大修饰符：（final、abstract、static）
面向对象（JAVA）详解
1.面向对象（类与对象）
1.编程思想
面向过程：
考虑事物的发展顺序
面向对象：
首先考虑事物中存在哪些对象，再建立对象与对象的关系
2.对象
（1）概念
生活中:真实存在的事物就是对象
代码中:使用代码模拟生活中存在的对象
/*万事万物皆对象*/
（2）如何创建一个对象
语法:
数据类型（类名） 对象名 = new 类名(实参列表);
本质:
调用类中的构造函数,
要求:
调用构造函数时,传入的实参列表要与构造函数定义时的形参列表,长度一致,顺序一致,数据类型一致
（3）对象的创建过程
语法:
类名 对象名 = new 类名(实参列表);
创建过程:
1,在堆内存开辟一片运行内存
2,给对象的属性赋初始值(基本数据类型默认为0(值存储在堆中),引用数据类型默认为null(存储的是引用数值所在的地址))
3,执行构造函数中的代码
4,将栈中的引用指向堆中开辟的内存地址
3.类
（1）概念
多个对象抽取其共同点形成的概念,就称为类
（2）如何创建一个类
语法:
访问权限修饰符 class 类名{
}
类名:符合大驼峰命名法,做到见名知意
定义的位置:
因为内部类还没有学习,所有将自定义类定义在 类 以外
（3）类中有什么
属性概念：用于描述对象的静态特征
别名:成员变量
本质:就是在方法外，类中定义的变量
定义的格式:
访问权限修饰符 数据类型 变量名;
注意:只能使用该类对象调用
构造函数概念:用于创建该类对象,因为构造函数的方法名必须与类名一致,所以new调用的就是构造函数
别名:构造方法
本质:一个特殊的方法
定义的格式:
访问权限修饰符 类名(形参列表){
方法体
}
定义位置:
类中,方法以外
注意:1.只能使用new关键字调用
2.如果一个类中没有构造函数,系统会为其提供一个无参的构造函数
方法概念:用于描述对象的动态特征(行为)
别名:函数
本质:包装一段代码的容器
定义的格式:
访问权限修饰符 修饰符 返回值类型 方法名(形参列表){
方法体
return xxx;
}
返回值类型:如果方法有返回值,那么返回值类型就是返回值的数据类型,如果没有就写void
方法名:自定义,符合小驼峰命名法
定义位置:
类中,方法以外
属性的作用:描述对象 静态特征
构造函数的作用:创建该类对象
方法的作用:描述对象的 动态特征
（4）类与对象的关系
生活中:
先有对象后有类
代码中:
现有类后有对象
（5）局部变量与成员变量
1.在类中的位置不同
成员变量：在类中定义
局部变量：在方法中定义或方法的参数
2.在内存中的位置不同
成员变量：在堆内存（成员变量属于对象，对象进堆内存）
局部变量：在栈内存（局部变量属于方法，方法进栈内存）
3.声明周期不同
成员变量：随着对象的创建而存在，随着对象的销毁而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
4.初始化值不同
成员变量：有默认初始化值，引用数据类型默认为null
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用
5.权限修饰符不同
局部变量：无权限修饰符
成员变量：存在权限修饰符
注意：局部变量名称可以和成员变量名称一样，在方法中使用时，采用就近原则（若其为对象可以采用this区分）
（6）静态变量与成员变量的区别
静态变量：
1. 调用方式：类名.属性名或对象名.属性名
2.属于 该类 所有的对象
成员变量：
1.调用方式：对象名.属性名
2.属于 具体 的某一对象
（7）构造函数与方法的区别
1、格式区别
构造方法和类名相同，并且没有返回类型，也没有返回值；不可被重写、不可被继承（可以被调用）；可用this、super调用本类和父类的构造函数。
普通成员方法可以任意起名，必须有返回类型，可以没有返回值；可被重写、可被继承；不可用this、super调用本类和父类的构造函数。
2、作用区别
构造方法用于创建对象，并进行初始化值。
普通成员方法是用于完成特定功能的。
3、调用区别
构造方法是在创建对象时被调用的，一个对象建立，只调用一次相应构造函数
普通成员方法是由创建好的对象调用，可以调用多次
4.this的使用
（1）概念
哪一个对象调用this所在的方法，this就代指这个对象
（2）使用
1,当局部变量与成员变量重名时,用于区分成员变量与局部变量,this.属性名表示成员变量(属性)
2,在本类构造函数中,调用其他构造函数
this(实参列表);
注意:
1,必须在构造函数第一行
2,不要形成死循环
3,在本类中调用本类其他属性或方法,此时可以忽略this不写
2.面向对象（封装、继承、多态）
1.封装
（1）优点
思想:包装
优点:
1,美化
2,降低耦合度
3,保护内部
4,方便使用
（2）Java代码中的封装
变量:封装一个可以改变的数据
数组:封装一组数据
方法:封装一段代码
类:封装多个属性与多个方法
java文件:封装一个或多个类
包:封装多个java文件
项目:封装多个包
...
（3）包
本质:一个文件夹
创建包:
选择src文件夹,点击鼠标右键,选择new,选择package
填写包名
注意:
包名使用全小写,不要用数字开头,不要出现特殊符号
包名的命名潜规则:
com.公司名称缩写.作用
注意:.表示下一层文件夹
关键字:package
导包:
关键字:import
为什么要导包:
所需使用的类与当前类不在同一个包中
（4）访问权限修饰符
意思:限制属性,方法,构造函数,类等的使用范围
分类:
关键字 意义 使用范围
public 公共的 当前项目中
protected 受保护的 当前包中或继承关系中
不写 默认的 当前包中
private 私有的 当前类中
总结:
一般情况下:
属性用private修饰,方法与类用public修饰
属性用private修饰后需提供get与set方法
2.继承
（1）优点
概念:
生活中的继承:晚辈获取长辈留下的财产与精神
代码中的继承:
多个类(B1,B2)抽取其共同点形成了一个类(A)
注意：
判断类A是否与类B有继承关系
如果类B与类A存在继承关系,可以让类B继承与类A,此时类B将拥有类A的所有属性与方法,构造函数除外
类B:称为子类
类A:称为父类
优点:
1,减少代码
2,使代码结构清晰
3,降低代码冗余度
总结:
子类将拥有父类的所有属性与方法,构造函数除外（父类构造函数只能使用，不是拥有关系）
（2）继承的语法
语法:
访问权限修饰符 class 子类名 extends 父类名{
属性
构造函数
方法
}
注意:
1,Java只能单继承
2,如果一个类没有写继承,默认继承于Object
3,如果父类中的方法与子类方法名相同,形参列表相同,返回值类型相同,访问权限修饰符子类大于或等于父类该方法,这种方法称为重写
（3）super的使用
作用:子类中使用父类的内容
使用:
属性
特殊情况:子类的属性名与父类属性名相同,如何区分
子类:this.属性名
父类:super.属性名
方法
特殊情况:子类重写父类方法,在子类中使用该方法,如何区分是父类方法还是子类方法
子类:this.方法名(实参列表);
父类:super.方法名(实参列表);
构造函数
情况:创建子类对象时,需要给父类构造函数传值
语法:
super(实参列表);
注意:
1,要在子类构造函数第一行
2,子类构造函数中如果没有调用父类构造函数,那么默认在其第一行有super();调用父类无参构造函数
3,重写父类方法时，若访问权限修饰符比父类小，则会报错
总结:
子类将拥有父类的所有属性与方法,构造函数除外
3.多态(事物 —— 事和物)
（1）概念
一个 事物 的多种形态
（2）代码中的多态（事 —— 方法的重写与重载）
重写:
要求:
发生在继承关系中,子类访问权限修饰符大于或等于父类访问权限修饰符,返回值类型相同,方法名相同,形参列表相同,方法体不同
注意：
当某个对象重写了父类的方法，对象在调用方法名时，遵循就近原则，会调用子类重写后的方法；当子类未重写方法时，对象调用方法，其会调用父类的方法
重载:
要求:
发生在同一个类中,方法名相同,形参列表不同
注意：
当对象重写方法时，除了形参列表不同其余方法变量全部相同时，可以实现方法重载的效果，但此种方法的改变既不叫重写也不叫重载（不在同一个类中）
（3）代码中的多态（物 —— 对象）
物(对象)
如类A继承与类B
类A:子类
类B:父类
(父类对象可以看作是大数据类型，子类对象可以看作是小数据类型，其转换情况符合基本数据类型转换原则)
类名A 对象名A = new 类名A();
//子类对象转父类对象,可以自动转换
类名B 对象名B = 对象名A;
//父类对象转换子类对象,需要强制转换,有风险
类名A 对象名A2 = (类名A) 对象名B;
注意：1，类的所有对象属于引用数据类型，其转换的实质是改变引用的指向
2，子类对象转换为父类对象会丢失自己特有的属性和方法
3.若一个类的本质不是父类，则此父类无法转化为其子类（编写程序不会报错，运行程序会报错）
4.重点：主要看一个类的本质是什么，使用 instanceof 可以某个对象是否的归属某个类的类型（父类或其他子类的类型）
eg:if (animal instanceof Dog)//对象animal是否属于Dog类
3.面向对象（三大修饰符）
1.抽象的
概念:无法描述的,无法实例的
关键字:abstract
可以修饰:
方法
语法格式:
访问权限修饰符 abstract 返回值类型 方法名(形参列表);
注意:
1,抽象方法没有方法体
2,有抽象方法的类一定是抽象类
类
语法格式:
访问权限修饰 abstract class 类名{
属性
方法
构造函数
}
注意:
1,子类继承于抽象类,要么重写所有抽象方法,要么自己也是抽象类
2,抽象类无法直接创建对象
3,抽象类中不一定有抽象方法
4,抽象方法一定在抽象类中
2.最终的
概念:不可修改的,最后的
关键字:final
修饰:
类
意义:最终类,不能被别的类继承
语法:
访问权限修饰符 final class 类名 extends 父类名{
属性
方法
构造函数
}
方法
意思:不可被重写
语法:
访问权限修饰符 final 返回值类型 方法名(形参列表){
方法体
return xxx;
}
属性
意思:不可被修改,称为常量,常量命名全大写
语法:
访问权限修饰符 final 数据类型 属性名;
final修饰的变量就是常量
局部变量
意思:不可被修改,称为常量,常量命名全大写
语法:
finl 数据类型 属性名;
final修饰的变量就是常量
3.静态的
（1）基本概念语法
概念:该类所有对象共有的,属于类
关键字:static
修饰:
属性:
语法:访问权限修饰符 static 数据类型 属性名;
static修饰的属性称为静态成员变量
注意:
1,static修饰的属性属于该类的所有对象,一个对象对其进行修改,所有对象的该属性都将被修改
2,static修饰的属性多了一种调用方式
语法:
类名.属性名;
类名.属性名 = 值;
原来:
对象名.属性名
对象名.属性名 = 值;
方法:
语法:
访问权限修饰符 static 返回值类型 方法名(形参列表){
方法体
}
static修饰的方法称为静态方法
注意:
1,静态方法中只能 直接 使用静态成员(静态属性,静态方法)
2,static修饰的方法多了一种调用方式
语法:
类名.方法名(实参列表);
原来:
对象名.方法名(实参列表);
3,静态方法中不能使用this与super(因为静态变量的声明周期长，其在类加载时创建，在没有对象存在时静态变量就已经存在，故不能在静态方法中调用非静态变量或方法)
代码块:
静态代码块
（2）static 关键字补充
static 关键字
1，静态变量或方法不属于对象，但要依赖于类，即属于类
2，静态变量是全局变量（生命周期从类被加载后一直到程序结束）
3，静态变量只存一份，在静态方法区中存储
4，静态变量是本类所有对象共享的一份，建议不要使用对象名去调用静态数据，直接使用类名调用
5，不能在静态方法中调用非静态变量或方法的原因：因为静态变量的声明周期长，其在类加载时创建，在没有对象存在时静态变量就已经存在，故不能在静态方法中调用非静态变量或方法
4.代码块
概念:一块代码
普通代码块:
类中,方法以外
语法:
{
代码
}
调用:
每次调用该类构造函数创建对象时,由系统调用该类的普通代码块,在执行构造函数前调用
静态代码块：
与static结合使用
语法:
static{
}
调用:
类加载时调用,所以只会调用一次
类的加载时机:
1，第一次创建该类对象时
2，第一次创建子类对象时（先有父，后有子）
3，使用类名调用本类静态属性（只有当JVM加载此类之后，才可以使用该类的静态属性）
4，使用类名调用本类静态方法
5，使用第一次使用反射获取该类对象时
Class.forName("包名.类名");
注意:
1，类只加载一次
2，一个类有静态与非静态属性,先加载静态属性
在继承关系:
1，先加载父类静态,在加载子类静态,父类非静态,子类非静态
2，在 1 条件下，属性 > 方法 > 静态代码块 > 代码块 >构造函数（静态 > 非静态）
3，在使用new关键字调用构造函数创建对象时，先加载属性和方法，再执行构造函数的代码