帮初学者整理的Java面向对象重点笔记

【Java面向对象笔记】
【函数：function】
函数的称谓，只存在于 javaSE基础编程中，到了OOP面向对象中，称之为：方法。
四种类型的函数，是按照 返回类型 与 参数列表进行区分的。
语法格式：
访问修饰符 方法修饰符 返回类型 函数名称（参数列表…）
｛
// 代码片段
// 对应的 return;
｝
无参数，无返回：只执行自身的代码，然后结束。
这类函数，通常只执行自己的代码，无需外接的数据，也不提供回馈。
public static void aaa(){
//对应void，实际上有一个 return; 程序默认缺省不写
}
无参数，有返回：执行自身的代码，然后会返回出一个结果。
这类函数，通常都是一个具体操作的元素，无序参数，但是会吧一个结果回馈出来。
public static int bbb(){
//代码片段
return 表达式; //表达式最终的结果必须是 int
}
有参数，无返回：需要外接提供数据，然后由它负责处理，结束。
这类函数不多，通常只是一个记录日志的功能等。
public void ccc(String a){
}
有返回，有参数：这类函数是最常见的，都是一个具体操作过程的代表。
提供数据，有函数负责中间处理，最终返回结果。
使用者，只要知道函数怎么使用就可以了，无需关心函数是如何实现的。
函数的目的是提供 内部处理代码 重复被使用。
企业级应用开发中，它们都是 Service层的。
public static User user ddd(Integer a,String b){
return user;
}
[注意]
java源代码文件： .java 只能修改，不能运行。
一个类文件，文件名 和 类名必须相同。
规范： 一个文件，一个类。
特殊情况下：
一个文件可以定义N个类，
但是，必须有一个类的名字和文件名相同，
而且，所有的类中，只能有一个 允许写 public
//----------------------------------------------------------------------------------------------------------
【OOP面向对象】
Java语言是 纯 面向对象的 产物。
什么是面向对象（的编程）？
把 现实 世界中 对象的概念， 使用代码表现出来。我们只需要告诉对象要做什么，而不用关心他 是怎么实现的
三大特性（原则）？
封装：实现代码的 可维护性
利用class的方式，将 零散的 变量与函数，包装成一个独立的程序单元。
封装以后，变量成为：属性； 函数成为：行为/方法
继承：实现代码的 扩展性
一个类 通过关键字 extends 声明，沿用 另一个类中，非私有的 属性 和 行为。
多态：实现代码的 灵活性
一个对象，多种形态，建立在继承的基础上，
声明父类对象，实例化子类，子类重写父类方法，
实现，同一个方法，运行的时候，结果不同。
【封装】：
利用类class的形式进行定义。
一个文件，一个类，类名与文件名相同。
命名规则按照标识符，建议：驼峰式。
一个文件允许定义多个class，但是，只能有一个是public，必须有一个与文件同名。
【继承 extends】：
建立在 封装的基础上，实现代码的 可扩展性。
一个类，通过extends声明，沿用另一个类中，非 私有的 属性和行为。
java是面向对象的语言，因此，对于继承，指的是 子类，
它是单一继承，一个孩子，只能有一个爸爸；一个爸爸可以有N个孩子。
继承中，父类通常都是一个普通的类，它不能有 final修饰符。
父类通常都是定义 所有子类，大家共有的内容，
子类，通过extends 声明继承父类
沿用那些内容，在这个基础上，子类只要追加 属于自己的特有的内容就可以了
【注意】：
1、在继承中，子类只能沿用父类的 非private私有的 【属性】【行为】，
构造函数是每一个类对象，自己特有的内容，【不可继承】
构造函数不可继承，是调用的。
当前类中，使用：this关键字 或 this()方法
父类中，使用：super关键字 或 super()方法
2、子类中，如果有与父类同名的 属性，那么覆盖父类的。尽量避免。
【多态】:
一个对象，多种形态。（东西没有变，本质变了）
多态必须建立在 继承的基础上；
子类 必须 重写父类方法；
声明父类，去实例化子类；
调用方法的时候，执行的是子类的内容。
多态的实现，是：父类 上转型变量 = new 子类()；
【重点】：
使用多态实现需求的时候：
1、只能访问 父类中的内容
2、子类中重写的内容，会向上覆盖父类的
3、子类特有的内容【无法访问的】
//----------------------------------------------------------------------------------------------------------
【构造函数/析构函数】：
【构造函数：construct】
每一个类中，都有一个 没有参数，没有返回类型，没有代码的构造函数。
它在遇到 new的时候，进行运行的，目的是用于 在内存上构建当前对象的实例。
由于基本操作系统固定，函数本身就没有任何代码
语言中，默认会缺省不写出来。
【它是一个特殊的函数，只能在 new的后面调用，用于构建内存对象】
【★：它不能定义返回类型】
【★：必须和类名相同】
构造函数在类中有两种：
默认隐式：
每一个类必有一个，默认情况下，隐藏的。
它没有返回类型，没有参数列表，没有自定义代码
删除就表示隐藏。
在类中，只能写出一个。
参数化的：
有参数列表的，只要参数列表中，数据类型与个数不对应，
我们可以定义N个，
默认没有，必须手工编写
当一个类中，有N种构造函数的时候，
在new的时候，后面可以自动识别去调用。
【析构函数】：
当一个类对象，在内存上被销毁的时候，执行的。
Java虚拟机，最大的一个特点就是垃圾回收机制，
当机器空闲的时候，自动回收没有用的内存，销毁没有的内容。
构造函数是一个类，遇到实例化new的时候，自动执行的。
析构函数是一个类，在内存上被销毁的时候，自动执行的。
//----------------------------------------------------------------------------------------------------------
【访问修饰符】：
用于 修饰 一个对象的 访问权限。
public：公开公共的，适用于： 类，属性，行为方法 任何位置都可以访问
protected：受保护的，适用于：属性，行为方法 只有当前类和他的子类可以访问。
(缺省不写)：默认的default，适用于： 类，属性，行为方法 只允许在同一个包中使用
private：私有的，适用于：属性，行为方法 只能在当前类中使用
【方法修饰符】：
定义一个对象的 使用方式。
static： 静态的：表示程序在编译的时候，系统就会创建它的到内存。无需手工new创建
静态对象，内存上，只会存在一个。第一次创建，以后都是这个创建好的。
final： 最终的：
类：禁止继承；属性：类中的常量，只能获取，禁止操作；行为：禁止重写
**abstract：**抽象的 用于：class 和 行为方法，只有声明，没有本质方法体。
注意
1、 一个元素，只能定义一个访问修饰符，但是可以拥有多个 方法修饰符
2、static：声明的 属性，不管创建了对少对象静态变量的数据只占用一个内存。静态属性，第一次创建，以后都是这个
3、 static：声明的 行为方法，都会在编译的时候，就创建好，使用的时候，直接对象.调用，无需实例化new。
4、static{} ：静态块，只能声明在类中，当类被第一次使用的时候，代码自动执行一次，【只有一次

//----------------------------------------------------------------------------------------------------------
【方法重写】
子类中，有与父类一样的方法，子类方法的代码将替换父类方法的代码，
访问的都是子类内容。
如果只是要在父类方法内容的基础上追加新内容，
可以利用 super.父类方法()，把代码沿用过来。
重写方法上面，必须添加 注解 @Override，这样就可以区分普通方法
【方法重载】
在一个类中，同名的方法，参数列表不同，就是 方法重载。
定义的时候，这个概念 和 参数化构造函数是一样的。
//----------------------------------------------------------------------------------------------------------
abstract：抽象的
用于项目的规划期，用于定义方法使用。
只有声明，没有本质代码（方法体）；
一个类中，只要有一个方法是抽象的，那么，类就必须是抽象的。
一个抽象类中，不一定只有抽象方法。
abstract修饰的方法，由于没有方法体大括号，程序无法创建内存，
因此，方法如果是abstract，那么类就必须也声明abstract。
语言为了解决开发中，new到当前对象，直接强制性定义：【凡是abstract类，禁止实例化。】
抽象类的使用，基于多态，
抽象类，必须有子类继承，
继承于抽象类的子类，必须实现里面所有的 抽象方法。
interface：接口
【接口不是类，是抽象方法的集合】
声明：
interface 关键字
实现：
implements 关键字，逗号隔开可以实现N个
接口的实现类，必须实现所有接口中的 所有的 抽象方法
★★★★★【抽象类是类，它是单一继承】
问：
抽象类的 子类 是否可以 还是一个 抽象类？
可以的，最后的那个实现类，必须实现所有父类中的所有抽象方法。
★★★★★
面试题： abstract 和 interface 有什么 异同？
【相同点】：
1、abstract 和 interface 都不可以 实例化new。
因为：abstract语言禁止new，interface不是类没有构造函数。
2、内部都有抽象方法
【不同】：
  1、abstract用于类，interface定义接口，本质不同。
  2、抽象类是单一继承，使用extends
        接口是多重继承，使用implements
  3、抽象类中可以定义 属性，实现方法，
        接口中，只有抽象方法 和 接口变量且是static，final