标签：声明 相同 一致性 优先 protect 强一致 存储空间 特征 抽象
1.对象和类
1.1 对象和类的关系：对象是类的实例，类是对象的模板。
1.2 对象：拥有属性和方法
属性：静态特征，数据，变量
方法：动态特征，行为，功能
属性是数据，方法就是对数据的操作
1.3 面向对象：
对象：显示世界中的所有实体都是对象
类 ： 对具有共同属性和行为的对象进行抽象，得到的一个抽象的概念
在面向对象编程时要追求低内聚，高耦合（模块越独立越好，模块间的关系越松散越好）
面向对象编程的特点和好处：面向对象更方便代码的修改，维护，扩展；数据和功能是一个整体
2.封装
2.1 什么是封装：
将类的某些信息隐藏在类内部,不允许外部程序直接访问，通过调用方法来实现对隐藏信息的操作和访向。
隐藏对象的属性和实现细节，仅对外提供公共访问方式。
2.2.封装的好处：
将变化隔离；便于使用；提高重用性；安全性。
2.3 封装的格式：
1、使用访问修饰符修饰成员变量和成员方法
2、对外提供getter和setter方法
3.继承
3.1 什么是继承：
继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
3.2 继承的好处：
1、继承关系是传递的。可以在一些比较一般的类的基础上构造、建立和扩充新类的最有效的手段。
2、继承简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。
3、继承能减小代码和数据的冗余度，大大增加程序的重用性。
4、继承通过增强一致性来减少模块间的接口和界面，大大增加了程序的易维护性。
5、Java出于安全性和可靠性的考虑，仅支持单重继承，而通过使用接口机制来实现多重继承。
3.3 继承的格式：
子类名 extends 父类名{ }
3.4 继承关系下代码的执行顺序
父类的静态代码块
子类的静态代码块
父类的构造代码块
父类的无参构造方法
子类的构造代码块
子类的无参构造方法
=============================
父类的构造代码块
父类的无参构造方法
子类的构造代码块
子类的有参构造方法
总结：1、优先调用父类
2、静态代码优先加载，且只加载一次（作用：第一个对象创建时，执行一些操作(记录日志:)）
3、构造代码块每次调用构造方法时都会调用（作用：每一个该类创建时可以记录日志）
4、子类的构造方法不管有参无参都会先去调用父类的无参构造
1 //测试类 2 public class TestDemo{ 3 public static void main(String[] args) { 4 Son son =new Son(); 5 System.out.println("============================="); 6 Son son2 =new Son("name"); 7 } 8 } 9 //父类 10 class Father { 11 static { 12 System.out.println("父类的静态代码块"); 13 } 14 { 15 System.out.println("父类的构造代码块"); 16 } 17 public Father() { 18 System.out.println("父类的无参构造方法"); 19 } 20 public Father(String name) { 21 System.out.println("父类的有参构造方法"); 22 } 23 24 } 25 //子类 26 class Son extends Father { 27 static { 28 System.out.println("子类的静态代码块"); 29 } 30 { 31 System.out.println("子类的构造代码块"); 32 } 33 public Son() { 34 System.out.println("子类的无参构造方法"); 35 } 36 public Son(String name) { 37 System.out.println("子类的有参构造方法"); 38 } 39 40 } 41 //执行结果： 42 /*父类的静态代码块 43 子类的静态代码块 44 父类的构造代码块 45 父类的无参构造方法 46 子类的构造代码块 47 子类的无参构造方法 48 ============================= 49 父类的构造代码块 50 父类的无参构造方法 51 子类的构造代码块 52 子类的有参构造方法 53 */
4.构造方法
4.1 定义和作用
在Java中，任何变量在被使用前都必须先设置初值。Java提供的为类的成员变量赋初值的专门方法。（初始化变量）
4.2 常识：子类的所有构造方法都会去访问一次父类的无参构造方法
问题：为什么子类要去访问父类的构造方法？
解析：因为子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。
问题：如果父类中没有无参的构造方法该怎么办？
分析：父类中没有无参构造，那么子类在初始化的时候就会报错。
解决办法：1、在父类中加一个无参构造方法
2、通过使用super关键字去显示的调用父类的带参构造方法
3、子类通过this去调用本类的其它构造方法（比如用子类的有参去调用自己的无参构造方法，但无参构造里一定要有super（））
5.访问修饰符
5.1 访问修饰符使用范围
用来修饰成员变量和成员方法，不能用来修饰局部变量
5.2 访问修饰符权限
同类 同包 子类 其他包
private V X X X
默认 V V X X
protected V V V X
public V V V V
6.四个关键字
6.1 static（静态的）
使用范围：用来修饰成员变量、成员方法和代码块
作用 ：
1.想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
2.被静态修饰的成员，可以直接被类名所调用。
3.静态随着类的加载而加载。而且优先于对象存在。
命名方式：
属性（成员变量）：
有static修饰：静态成员（静态变量）
没有static修饰：实例成员（非静态变量）（非静态成员）
方法（成员方法）：
有static修饰：静态方法（静态方法）
没有static修饰：实例方法（非静态方法）（非静态方法）
代码块（{ }） ：
有static修饰：静态代码块
没有static修饰：非静态代码块（构造代码块）
总结 ：
a.不管是静态方法还是非静态方法，都需要调用后执行，其执行的次序和在类里声明的次序无关，区别是静态方法是“class.method"方式执行，非静态方法是"object.method"方式执行，即后者需要创建一个对象。
b.静态成员变量（也称类变量）先于非静态成员变量初始化，静态成员变量在类第一次加载时初始化，所有对象共享一份静态成员变量，非静态成员变量则在对象创建时初始化
6.2 final（最终的）
使用范围：修饰类、修饰方法、修饰变量
作用：1、修饰的类不可被继承
2、修饰的方法不能被重写
3、修饰的变量的值不能更改（即为常量，通常变量名全大写）
作用（详细）：
1、被final修饰的类不能被继承
2、被final修饰的成员变量
a. 必须初始化值。
b. 被fianl修饰的成员变量赋值，有两种方式：1、直接赋值 2、全部在构造方法中赋初值。
c. 如果修饰的成员变量是基本类型，则表示这个变量的值不能改变。
d. 如果修饰的成员变量是一个引用类型，则是说这个引用的地址的值不能修改，但是这个引用所指向的对象里面的内容还是可以改变的。
3、被final修饰的方法不能被重写
a. 一个类的private方法会隐式的被指定为final方法。
b. 如果父类中有final修饰的方法，那么子类不能去重写。
6.3 this和super
两者定义的区别：
this代表本类的引用
super代表父类存储空间的标识（可以理解为父类的引用，可以操作父类的成员）
两者使用的区别：
调用成员变量：
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
调用构造方法：
this（...） 调用本类的构造方法
super（...） 调用父类的构造方法
调用成员方法：
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法
7.方法的相互调用
7.1 同类 ：
静态调用静态
a.直接调
b.类名.方法名
c.对象名.方法名（不建议使用，因为这样不能分辨是静态调静态还是静态调非静态）
静态调用非静态
创建调用类的对象，再对象名.方法名
非静态调用静态
a.直接调用
b.类名.方法名
c.对象名.方法名（不建议使用）
非静态调用非静态
a.直接调用
b.对象名.方法名
7.2 不同类
静态调用静态
类名.方法名
静态调用非静态
创建调用类的对象，再对象名.方法名
非静态调用静态
类名.方法名
非静态调用非静态
对象名.方法名
8.方法的重载
同一个类中，方法名相同，参数的数量，类型，顺序不同即为重载（只与参数有关）
9.方法的重写
发生在继承关系下，子类对父类允许访问的方法的实现过程进行重新编写, 方法声明相同（即返回值和形参都不能改变。即外壳不变，核心重写）
标签：声明 相同 一致性 优先 protect 强一致 存储空间 特征 抽象
原文地址：https://www.cnblogs.com/19322li/p/10630859.html
