面向对象复习

最新推荐文章于 2022-05-12 11:44:14 发布

xiaoyangzlqqq

最新推荐文章于 2022-05-12 11:44:14 发布

阅读量114

点赞数

文章标签：设计模式 java 编程语言多态

本文链接：https://blog.csdn.net/xiaoyangzlqqq/article/details/111083515

版权

1.面向对象(OOP)

所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者，面向对象是基于面向过程而言的。
面向对象可以理解为把任何事物抽象成一个对象来对待，之后再对这个对象进行相关的操作。
面向过程是具体化的，流程化的，解决一个问题，需要一步一步的分析，一步一步的实现。
优点：性能比面向对象好，因为类调用时需要实例化，开销比较大，比较消耗资源。
缺点：不易维护、不易复用、不易扩展.
面向对象是模型化的，只需抽象出一个类，它是一个封闭的盒子，在这里面拥有数据也拥有解决问题的方法。需要什么功能直接使用就可以了。
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护 .
缺点：性能比面向过程差

2.类和对象

类：
类是封装对象的属性和行为的载体
1.Java语言最基本单位就是类，类似于类型。
2.类是一类事物的抽象。
3.可以理解为模板或者设计图纸。
对象：
对象是由类抽象出来的，所有的问题都是通过对象来处理，对象可以操作类的基本属性和方法解决相应的问题。

联系：类是对象的抽象，而对象是类的具体实例。
3.对象在内存中的存储

1.一般来讲局部变量存在栈中，方法执行完毕内存就被释放
2.对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
3.每个堆内存的元素都有地址值
4.对象中的属性都是有默认值的

3.队列和栈的区别
队列和栈是两种不同的数据结构。它们有以下区别：

操作的名称不同。队列的插入称为入队，队列的删除称为出队。栈的插入称为进栈，栈的删除称为出栈。
可操作的方式不同。队列是在队尾入队，队头出队，即两边都可操作。而栈的进栈和出栈都是在栈顶进行的，无法对栈底直接进行操作。
操作的方法不同。队列是先进先出（FIFO），即队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾（不能从中间插入），每次离开的成员总是队列头上（不允许中途离队）。而栈为后进先出（LIFO）,即每次删除（出栈）的总是当前栈中最新的元素，即最后插入（进栈）的元素，而最先插入的被放在栈的底部，要到最后才能删除。

4.栈和堆的区别：
堆和栈都是一种数据项按序排列的数据结构。

栈就像装数据的桶或箱子，是一种具有后进先出性质的数据结构。
堆像一棵倒过来的树，是一种经过排序的树形数据结构，每个结点都有一个值。堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。由于堆的这个特性，常用来实现优先队列，堆的存取是随意的，这就如同我们在图书馆的书架上取书，虽然书的摆放是有顺序的，但是我们想取任意一本时不必像栈一样，先取出前面所有的书，书架这种机制不同于箱子，我们可以直接取出我们想要的书。

5.封装
是指隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式。
好处：
1.提高安全性
2.提高重用性
通过private关键字实现封装，来提高代码的安全性。用于修饰成员变量和成员方法，被私有化的成员只能在本类中访问。想要修改只能，对外提供公共的，get和set方法。

6.构造方法
构造方法是一种特殊的方法，特殊在方法名就是类名，没有返回值位置。它是一个与类同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的创建或者对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。

修饰符  类名(【参数】){
       代码……
}

7.构造代码块和局部代码块

{          }

构造代码块：
1.在类里方法外；
2.通常用于抽取构造方法中的共性代码；
3.每次调用构造方法前都会调用构造代码块；
4.优先于构造方法加载。
局部代码块：
1.在方法里的代码块；
2.通常用于控制变量的作用范围，出了括号就失效；
3.变量的范围越小越好，成员变量会有线程安全问题；
4.总结：执行顺序：构造代码块是最优先的，局部代码块顺序执行。

8.this关键字
this代表本类对象的一个引用对象。构造函数中，this()必须放在第一行。
局部变量优先，想要使用成员变量，必须通过this调用。

9.继承
是面向对象最显著的一个特性。
继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。
提高复用性：只要继承父类，就能有一样的功能。
实现：使用extends关键字
1.相当于子类把父类的功能复制了一份
2.java只支持单继承
3.继承可以传递（爷爷，儿子，孙子的关系）
4.不能继承父类的私有成员
5.继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
6.像是is a 的关系

10.super关键字

1.通过super关键字可以使用父类的内容
2.super代表父类的一个引用对象
3.如果用，必须出现在调用位置的第一行

11.方法的重写

1.继承后，子类就拥有了父类的功能
2.那么在子类中，可以添加子类特有的功能也可以修改父类的原有功能
3.子类中方法签名与父类完全一样(包括方法的返回值，方法名和参数列表，完全一致)时，会发生覆盖/复写操作，相当于修改功能
注意：
1.父类中的私有方法不能被重写
2.子类重写父类方法时，修饰符要大于等于父类修饰符的权限

12.this和super的区别

1.this代表本类对象的引用，super代表父类对象的引用。
2.this用于区分局部变量和成员变量
3.super用于区分本类变量和父类变量
4.this.成员变量 this.成员方法() this(【参数】)代表调用本类内容
5.super.成员变量 super.成员方法() super(【参数】)，代表调用父类内容
6.this和super不可以同时出现在同一个构造方法里，他们两个只要出现都得放在第一行，同时出现的话，到底第一行放谁呢。。

13.重写与重载的区别（Overload和Override的区别）

1.重载：是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
2.重写：是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型
3.重写是父类与子类之间多态性的一种表现
4.重载是一类中多态性的一种表现

14.static
用于修饰成员成员变量和成员方法。
特点：

可以修饰成员变量，成员方法
随着类的加载而加载，优先于对象加载
只加载一次，就会一直存在，不再开辟新空间
全局唯一，全局共享
可以直接被类名调用
静态只能调用静态，非静态可以随意调用
static不能和this或者super共用，因为有static时可能还没有对象

15.静态代码块
位置：在类里方法外
随着类的加载而加载，并且只被加载一次，一般用于项目的初始化.

static{…}

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

16.final
是java提供的一个关键字,是最终的意思;
final可以修饰类，方法，成员变量。
特点：

被final修饰的类，不能被继承
被final修饰的方法，不能被重写
被final修饰的变量是个常量，值不能被更改
常量的定义形式： final 数据类型常量名 = 值

17.多态
前提：继承+方法的重写
口诀：父类引用指向子类对象，编译看左边，运行看右边。
如：Animal a = new Dog(); ——小到大，向上转型

好处：
- 多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。
- 提高了程序的扩展性和可维护性
特点：
- 成员变量：使用的是父类的
- 成员方法：由于存在重写现象所以使用的是子类的
- 静态成员：随着对象而存在，谁调用的就返回谁的

向上转型：父类的引用指向子类对象。Parent p=new Child();
向下转型(较少)：子类的引用的指向子类对象，过程中必须要采取到强制转型。Child c = (Child)p;

18.异常
用来封装错误信息的对象。
组成结构：类型，提示，行号。

Throwable - 顶级父类
-- Error：系统错误，无法修复
-- Exception：可修复的错误
	--RunTimeException
		--NullPointerException
		--IndexOutOfBoundsException
		--ClassCastException
		--ClassNotFoundException
	--IOException
		--FileNotFoundException
		.........

异常处理:
捕获或者向上抛出。

捕获方式：

try{
    需要捕获的代码
}catch(异常类型  异常名){
   处理方案
}

抛出方式：
在会发生异常的方法上添加代码：throws 异常类型

例如：  public static void main(String[] args)  throws Exception{

19.访问控制符

20.抽象类

没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。
通过java关键字abstract实现
可以修饰方法或者类
抽象类中可以没有抽象方法（由子类去实现）
如果类中有抽象方法，那该类必须定义为一个抽象类
子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写
多用于多态中
抽象类不可以被实例化

20.接口

interface 接口名{  代码…  }

特点：

接口中都是抽象方法
通过interface关键字创建接口
通过implements让子类来实现
可以理解成，接口是一个特殊的抽象类
接口突破了java的单继承的局限性
接口和类之间可以多实现，接口和接口之间可以多继承
接口是对外暴露的规则，是一套开发规范
接口提高了程序的功能扩展，降低了耦合性

接口和抽象类的区别：

-- 相同点：都是抽象层，都不能实例化                      
-- 不同点：
   -- 1、抽象类用abstract关键字描述，接口用interface
   -- 2、子类和抽象类之间是extends关系，实现类和接口之间是implements关系
   -- 3、抽象类中 可以  有构造方法 ，接口里 不能 出现 构造方法
   -- 4、抽象类里可以有 变量，接口里没有变量全都是静态的常量
   -- 5、接口里定义常量的语法：public static final String NAME="jack"，会为变量自动拼接public static final
   -- 6、抽象类里 可以有普通方法  也可以有 抽象方法，接口都是抽象方法
   -- 7、抽象类和子类之间是继承关系，而且java中，只支持单继承
   -- 8、接口突破了java单继承的局限性，因为接口可以多继承也可以多实现，甚至可以继承的同时多实现
   -- 9、接口的复杂用法
       -- 多继承： interface A  extends  B,C  其中A是子接口，同时拥有自己的和BC的功能
       -- 多实现： class AImpl implements M,N,O,P 其中AImpl是实现类，需要同时重写MNOP的所有抽象方法，否则就是一个抽象类
       -- 继承的同时多实现： class AImpl extends Object implements M,N 一定是先继承后实现

21.设计模式
1.单例设计模式（一共8种）：饿汉式（2）、懒汉式（3）、枚举、双重检查、静态内部类。确保对象只有一个。Spring默认创建的bean就是单例模式。

饿汉（线程安全）：创建一个私有的静态的对象，构造方法私有化，对外提供一个静态get对象的方法。
懒汉（线程不安全）：静态声明一个对象，构造方法私有化，提供静态- get方法，if（对象==null）就创建，if条件外边返回对象；
懒汉（线程安全）：在get方法上加上synchronized；
静态类内部加载（线程安全）：私有的静态内部类里创建方法，构造方法私有化，提供静态get方法并且在方法里返回对象。
枚举方法（线程安全）。

2.工厂模式：springIOC（Bean工厂）
3.装饰者模式：Buffer：StringBuffer、StringBuilder
4.代理模式：SpringAOP底层用的jdk动态代理跟cglib动态代理
5.观察者模式
6.享元模式

22.软件设计原则

开闭原则，开放功能扩展，关闭源码修改。具有很强的的扩展性、弹性和可维护性。扩展时只要添加一个ConcreteCreator，而无须修改原有的ConcreteCreator，因此维护性也好。解决了简单工厂对修改开放的问题。
使用了依赖倒置原则，依赖抽象而不是具体，使用（客户）和实现（具体类）松耦合。

23.GC是什么
GC是垃圾收集的意思，可以有效的防止内存泄露，有效的使用可以使用的内存。