个人笔记整理——JAVA面向对象

1.面向对象3大特征

1. 封装: 把相关的数据封装成一个“类”组件
2. 继承: 是子类自动共享父类属性和方法，这是类之间的一种关系
3. 多态: 增强软件的灵活性和重用性

2.类和对象

2.1 类
1.Java语言最基本单位就是类，相当于类型。
2.类是一类事物抽取共同属性与功能形成的。
3.可以理解为模板或者设计图纸。
   注意:类在现实世界并不存在,它只是一种对象的数据类型

2.2 对象
每个对象具有三个特点：对象的属性，对象的功能和对象的标识。

1.对象的属性用来描述对象的基本特征。
2.对象的功能用来描述对象的可以完成的操作。
3.对象的标识是指每个对象在内存中都有一个唯一的地址值用于与其他对象进行区分，类似于我们的身份证号。

2.3 类和对象的关系
1.我们先创建类，再通过类创建出对象
2.我们可以通过一个类创建出多个对象
3.类是抽象的，对象是具体的
 

3.封装

(默认)default是表示不写修饰符,默认,如果写default单词来修饰会报错

4.构造方法

4.1 概念

构造方法是一种特殊的方法,它是一个与类同名且没有返回值类型的方法
构造方法的主要功能就是完成对象创建或者初始化
当类创建对象(实例化)时,就会自动调用构造方法
构造方法与普通方法一样也可以重载.

4.2 形式

构造方法分三种

第一种：构造方法不含有参数，这种称无参构造

默认存在，但如果，添加了其他构造函数，默认的构造函数就会被覆盖

第二种：构造方法含有参数，这种称含参构造

对于参数没有任何要求，有参数就行

第三种：构造方法含有对象的全部参数，这种称全参构造

全参构造必须与本类属性一致，全参构造不仅可以创建对象，还可以给对象的所有属性赋值
 

5.this和super

6.继承 

6.1特点

1. 使用extends关键字来表示继承关系
2. 相当于子类把父类的功能复制了一份
3. Java只支持单继承
4. 继承可以传递(爷爷/儿子/孙子这样的关系)
5. 父类的私有成员由于私有限制访问，所以子类不能使用父类的私有资源
6. 继承多用于功能的修改,子类可以在拥有父类功能的同时,进行功能拓展
7. 像是is a的关系

6.2 重写Override

继承以后,子类就拥有了父类的功能
在子类中,可以添加子类特有的功能,也可以修改父类的原有功能
子类中方法的签名与父类完全一样时,会发生覆盖/复写的现象
注意: 父类的私有方法不能被重写

重写的要求:两同两小一大
两同:方法名 参数列表 要完全一致
两小:
子类返回值类型小于等于父类的返回值类型(注意此处说的是继承关系,不是值大小)
子类抛出异常小于等于父类方法抛出异常
一大:子类方法的修饰符权限要大于等于父类被重写方法的修饰符权限
 

6.3 继承的好处和坏处

继承的好处
提高了代码的复用性（多个类相同的成员可以放在同一个类中）
提高了代码的维护性（如果方法的代码需要修改，只修改一处即可）
继承的坏处
继承让类与类建立了关系，类的耦合性增强
当父类发生变化时，子类实现也不得不跟着变化，削弱了子类的独立性

6.4 重写Override  和  重载Overload  的区别

重载：在一个类中的现象：同一个类中，存在方法名相同，参数列表不同的方法 

重载的意义：是为了外界调用方法时方便，不管传入什么样的参数，都可以匹配到对应的同名方法

重写：是指建立了继承关系以后，子类对父类的方法不满意，可以重写，遵循两同两小一大原则
重写的意义：在不修改源码的情况下，进行功能的修改与拓展（OCP原则：面向修改关闭，面向拓展开放）

7.static，final和三种代码块的区别

7.1 static(静态类)

        1.static可以修饰成员变量和方法
        2.被static修饰的资源称为静态资源
        3.静态资源随着类的加载而加载，最先加载，优先于对象进行加载
        4.静态资源可以通过类名直接调用，也被称作类资源
        5.静态被全局所有对象共享，值只有一份
        6.静态资源只能调用静态资源
        7.静态区域内不允许使用this与super关键字

7.2 final(最终类)

1. 被final修饰的类，不能被继承
2. 被final修饰的方法，不能被重写
3. 被final修饰的字段是个常量，值不能被修改
4. 常量的定义形式：final 数据类型 常量名 = 值

7.3 三种代码块的区别

1. 静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
2. 构造代码块：在创建对象时会自动调用，每次创建对象都会被调用,提取构造共性
3. 局部代码块：方法里的代码块,限制局部变量的范围

执行顺序：静态代码块 --> 构造代码块 --> 构造方法 --> 局部代码块

8.多态

8.1 概念

多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

8.2 特点

1. 多态的前提1：是继承
2. 多态的前提2：要有方法的重写
3. 父类引用指向子类对象,如：Animal a = new Cat();
4. 多态中，编译看左边，运行看右边

8.3 好处

1. 多态可以让我们不用关心某个对象到底具体是什么类型,就可以使用该对象的某些方法
2. 提高了程序的可扩展性和可维护性

8.4 使用

前提:多态对象把自己看做是父类类型

1. 成员变量: 使用的是父类的
2. 成员方法: 由于存在重写现象,所以使用的是子类的
3. 静态成员: 随着类的加载而加载,谁调用就返回谁的

8.5 向上转型和向下转型

在JAVA中，继承是一个重要的特征，通过extends关键字，子类可以复用父类的功能，如果父类不能满足当前子类的需求，则子类可以重写父类中的方法来加以扩展。
那么在这个过程中就存在着多态的应用。存在着两种转型方式，分别是：向上转型和向下转型。

向上转型：可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

向下转型(较少)：子类的引用的指向子类对象，过程中必须要采取到强制转型。这个是之前向上造型过的子类对象仍然想执行子类的特有功能，所以需要重新恢复成子类对象

9.异常

9.1 概述

异常是一些用来封装错误信息的对象
它由异常的类型、提示信息、报错的行号提示三部分组成

9.2 处理方式

第一种：捕获

第二种：抛出

在可能会会发生异常的方法上添加代码：
throws 异常类型 

9.3 throws 与 throw 的区别

throws
用在方法声明处，其后跟着的是异常类的名字
表示此方法会抛出异常，需要由本方法的调用者来处理这些异常
但是注意：这只是一种可能性，异常不一定会发生

throw
用在方法的内部，其后跟着的是异常对象的名字
表示此处抛出异常，由方法体内的语句处理
注意：执行throw一定抛出了某种异常

10.抽象

10.1 概念

Java中可以定义被abstract关键字修饰的方法,这种方法只有声明,没有方法体,叫做抽象方法.
Java中可以定义被abstract关键字修饰的类,被abstract关键字修饰的类叫做抽象类

1. 如果一个类含有抽象方法,那么它一定是抽象类
2. 抽象类中的方法实现交给子类来完成

10.2 格式

10.3 特点

1.abstract 可以修饰方法或者类
2.被abstarct修饰的类叫做抽象类,被abstract修饰的方法叫做抽象方法
3.抽象类中可以没有抽象方法
4.如果类中有抽象方法,那么该类必须定义为一个抽象类
5.子类继承了抽象类以后,要么还是一个抽象类,要么就把父类的所有抽象方法都重写
6.多用于多态中
7.抽象类不可以被实例化

10.4 注意事项

抽象方法要求子类继承后必须重写。
那么，abstract关键字不可以和哪些关键字一起使用呢？以下关键字，在抽象类中。用是可以用的，只是没有意义了。
1.private：被私有化后，子类无法重写，与abstract相违背。
2.static：静态优先于对象存在，存在加载顺序问题。
3.final：被final修饰后，无法重写，与abstract相违背。
 

11.接口

11.1 概念

与之前学习过的抽象类一样,接口( Interface )在Java中也是一种抽象类型，接口中的内容是抽象形成的需要实现的功能,接口更像是一种规则和一套标准.

11.2 格式

11.3 特点

1.通过interface关键字来定义接口
2.通过implements让子类来实现接口
3.接口中的方法全部都是抽象方法(JAVA8)
4.可以把接口理解成一个特殊的抽象类(但接口不是类!!!)
5.类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法
6.接口突破了java单继承的局限性
7.接口和类之间可以多实现,接口与接口之间可以多继承
8.接口是对外暴露的规则,是一套开发规范
9.接口提高了程序的功能拓展,降低了耦合性
 

 11.4 执行顺序

11.5 接口的总结

1.接口里是没有构造方法的，如果一个类没有明确指定它的父类，那么它默认继承顶级父类Object，调用的super()是Object的无参构造

2.接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：public static final

3.接口里的方法，默认都是抽象的，方法上会默认拼接public abstract。例如：public abstract void save();

12.内部类

12.1 概念

如果一个类存在的意义就是为指定的另一个类，可以把这个类放入另一个类的内部。
就是把类定义在类的内部的情况就可以形成内部类的形式。
A类中又定义了B类，B类就是内部类,B类可以当做A类的一个成员看待:

12.2 特点

1.内部类可以直接访问外部类中的成员，包括私有成员

2.外部类要访问内部类的成员，必须要建立内部类的对象

3.在成员位置的内部类是成员内部类

4.在局部位置的内部类是局部内部类

12.3 匿名内部类

匿名内部类没有名字,通常与匿名对象结合在一起使用
匿名对象只能使用一次，一次只能调用一个功能
匿名内部类充当了实现类的角色，去实现接口/抽象类中的抽象方法，只是没有名字而已

12.3 内部类的总结

1.成员内部类被Private修饰以后,无法被外界直接创建创建对象使用，所以可以创建外部类对象,通过外部类对象间接访问内部类的资源

2.静态资源访问时不需要创建对象,可以通过类名直接访问，访问静态类中的静态资源可以通过”. . . ”链式加载的方式访问

13.类，接口，抽象类的一些关系

1. 类与类的关系
继承关系,只支持单继承
比如,A是子类 B是父类,A具备B所有的功能(除了父类的私有资源和构造方法)
子类如果要修改原有功能,需要重写(方法签名与父类一致 + 权限修饰符>=父类修饰符)

2. 类和接口的关系
实现关系.可以单实现,也可以多实现
class A implements B,C{}
其中A是实现类,B和C是接口,A拥有BC接口的所有功能,只是需要进行方法的重写,否则A就是抽象类

3. 接口与接口的关系
是继承关系,可以单继承,也可以多继承
interface A extends B,C{}
其中ABC都是接口,A是子接口,具有BC接口的所有功能(抽象方法)
class X implements A{}
X实现类需要重写ABC接口的所有方法,否则就是抽象类
class A extends B implements C,D{}
其中A是实现类,也是B的子类,同时拥有CD接口的所有功能
这时A需要重写CD接口里的所有抽象方法

4.接口与抽象类的区别
1.接口是一种用interface定义的类型，抽象类是一种用class定义的类型
2.接口中的方法都是抽象方法,还有默认方法与静态方法，抽象类中的方法不做限制
3.接口中的都是静态常量，抽象类中可以写普通的成员变量
4.接口没有构造方法，不可实例化，抽象类有构造方法，但是也不可以实例化
5.接口是先天设计的结果，抽象是后天重构的结果
6.接口可以多继承，抽象类只能单继承