Java面向对象

甘雨金
101 阅读9分钟

一、初始面向对象

1、面向过程&面向对象

面向过程：一步接一步的做，适合简单的问题

面向对象：分类的思维模式，思考问题首先会解决问题需要哪些分类，再对这些分类单独思考。最后对某个分类下的细节进行面向过程的思索。适合复杂的问题以及需要多人协作的问题。

总结：

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是具体到微观上的操作，仍然需要面向过程的思路去处理。

2、面向对象

面向对象编程（Object-Oriented Programming,OOP）

本质是：以类的方式组织代码，以对象的方式组织（封装）数据。

三大特性：

  • 封装
  • 继承
  • 多态

从认识论的角度考虑是先有对象后有类。对象是具体的事物。类，是抽象的，是对对象的抽象。

例如：有很多人，他们就是一个个对象，是具体的；他们的职业可能有教师、学生，这就是类，是抽象的。

从代码运行角度考虑是先有后有对象类。类是对象的模板。

例如：有Person这个类，通过new 就能产生一个个对象。

二、方法回顾和加深

1、方法的定义

修饰符

返回类型

break：跳出switch，结束循环。
return：结束方法，返回一个结果

方法名：驼峰命名 见名知意

参数列表：（参数类型 参数名）...

异常抛出

示例：

image.png

2、方法的调用

静态方法：有static修饰 直接类名.方法名();

非静态方法：没有static 需要实例化一个对象后（即 new 后），对象名.方法名();

示例：

image.png

形参和实参

image.png

值传递和引用传递

值传递：

image.png

引用传递：对象，本质还是值传递

image.png

this关键字

三、对象的创建分析

类是一种抽象的数据类型，是对某一事物整体描述/定义。如：动物、植物...

对象是抽象概念的具体实例，能够体现出特点，展现出功能。如：张三就是人的一个具体实例

使用new关键字创建对象。除了① 分配内存空间外，还会给创建好的② 对象进行默认的初始化以及③ 对类中构造器的调用。

image.png

类中的构造器也称为构造方法，是在进行创建对象时必须要调用的。有两个特点：

  1. 必须和类名相同
  2. 必须没有返回类型，也不能写void

作用：

  1. new 本质在调用构造方法
  2. 初始化对象的值

注意： 定义有参构造后，如果想使用无参构造，显式的定义一个无参的构造

ctrl + D ： 复制当前行到下一行

alt + enter : 补充完整创建的对象语句

alt + insert ：快捷键生成构造器、重写方法

ctrl + H ：查看类结构

image.png

创建对象内存分析！！！

image.png

流程：

① 首先加载Application这个类，这个类里有main()、一些常量，如pet.name

② 把main()方法放到栈里面

③ 加载Pet()类，把name、age 、shout（）加载进来

④ 生成dog对象；dog它只是一个引用变量名，在栈里面。真正的dog对象在堆里面

⑤ 对于cat对象，同理④

image.png

小结：

  1. 类和对象。类是一个模板：抽象，对象是一个具体的实例。
  2. 方法。定义、调用！
  3. 对象的引用。引用类型：基本类型（8种），而对象是通过引用来操作的：栈————>堆。
  4. 属性。字段Field、成员变量。默认初始值：（数字：0 0.0），（char：u0000 ），（boolean：false），（引用：null）
  5. 对象的创建和使用。
  • 必须使用new关键字创建，以及构造器 Person gan = new Person();
  • 对象的属性 gan.name
  • 对象的方法 gan.sleep()
  1. 类。静态的属性——>属性 ；动态的行为——>方法。

四、面向对象三大特性

1、封装

该露的露，该藏的藏。程序设计追求“高内聚，低耦合”。高内聚，就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合，仅暴露少量的方法给外部使用。

封装（数据的隐藏），属性私有：get/set

image.png

封装的意义：

  1. 提供程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口，set/get
  4. 系统的可维护性增加了

2、继承

一、继承

继承的本质是对某一批类的抽象，从而对现实世界更好的建模。使用extends关键字，子类是父类的扩展！

Java只有单继承，没有多继承！只有一个父类，可以有多个子类。

继承是类和类间的一种关系。除此之外，还有依赖、组合、聚合等。

ctrl + H ：查看类结构

image.png

image.png

二、super详解

super注意点：

  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现在子类的方法或者构造方法中
  3. super和this不能同时调用构造方法

VS this：

  1. 代表对象不同：

    • this：本身调用者这个对象
    • super：代表父类的应用

  2. 前提：

    • this：没有继承也可以使用
    • super：只能在继承条件才可以使用

  3. 构造方法：

    • this()：本类的构造
    • super()：父类的构造

示例：

image.png

结果：

image.png

三、方法重写：

前提：需要继承的关系，子类重写父类的方法！和属性无关

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符：范围可以扩大，不能缩小。public > protected > default > private
  4. 抛出的异常：范围，可以被缩小，但不能扩大。ClassNotFoundException——> Exception(大)

重写：子类的方法和父类一致，方法体不同！

为什么需要重写？

  1. 父类的功能，子类不一定需要，或者不一定满足！

Alt　＋　Insert ：override

示例：

静态方法的重写：

image.png

非静态方法的重写：

image.png

3、多态

一、多态：

即同一方法，可以根据发送对象的不同，采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。（父类，有关系的类）

多态注意事项：

  1. 多态是方法的多态，属性没有多态
  2. 父类和子类，要有联系，不然类型转换异常！ClassCastException!
  3. 存在条件：
    • 继承关系，
    • 方法需要重写（在运行时，如果方法有被重写，虽然是父类的数据类型 但仍然调用子类的方法），
    • 父类引用指向子类对象！如：Father f1 = new Son();

不能被重写的方法：

  1. static 方法：属于类，它不属于实例
  2. final 常量修饰的方法。
  3. private 方法，私有的。

示例：

image.png

二、instanceof
判断前后两个对象是否存在关系（类型转换） 引用类型，判断一个对象是什么类型~

image.png

三、类型转换：

  1. 只能父类引用指向子类的对象。
  2. 把子类转换为父类，向上转型。可能丢失自己原有的方法。
  3. 把父类转为子类，向下转型，强制转换。
  4. 作用：方便方法的调用，减少重复的代码！简洁

image.png

抽象：封装，继承，多态、抽象类、接口！

抽象：是一种编程思想！要持续学习，细细理解。

四、static 关键字

  1. static——构成的静态方法、静态属性，直接类名.方法名/属性名调用。

image.png

  1. static——形成静态代码块

image.png

  1. static——形成静态导入包

image.png

五、抽象类和接口

1、抽象类

abstract 修饰符 修饰的方法，该方法就是抽象方法；修饰类，该类就是抽象类。

特点：

  1. 抽象类，不能使用new关键字来创建对象，只是让子类来继承的。
  2. 抽象类中可以没有抽象方法，但有抽象方法，一定要声明为抽象类。
  3. 抽象方法，只有方法的声明，没有方法的实现。
  4. 子类继承抽象类，必须实现抽象类没有实现的方法，否则该子类也要声明为抽象类。

思考：抽象类也有构造器。

作用：将一些方法抽象出来，提高开发的效率。

示例：

image.png

2、接口

普通类：只有具体实现，关键字是class。

抽象类：具体实现和规范（抽象方法）都有！，关键字是abstract class。

接口：只有规范！自己无法写方法，专业的规范！约束和实现分离：面向接口编程，关键字是interface。

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须...”的思想，如：如果你是汽车，就必须能跑。 接口的本质就是契约。

面向对象（OO）的精髓，就是对对象的抽象，最能体现的一点就是接口。

为什么讨论设计模式都只针对具备了抽象能力的语义（如c++、java、c#等），就是因为设计模式所研究的，就是如何合理的去抽象。

接口的作用：

  1. 约束。

  2. 定义一些方法，让不同的人实现。

  3. 接口中的方法：省略的前缀都是：public abstract。

  4. 接口中的常量：省略的前缀都是：public abstract final。

  5. 接口不能实例化，接口中没有构造方法，也不是类。

  6. implements可以实现多个接口。（多继承）

  7. 实现必须要重写接口中的方法。

示例：

① 定义第一个接口UserService，使用关键字 interface image.png

② 定义第二个接口TimeService

image.png

③ 使用implements关键字，实现多继承，必须重写接口里面的方法。

image.png

六、内部类和OOP实战

内部类 以及 OOP实战：

内部类就是在一个类的内部再定义一个类，比如，A类中定义了一个B类，那么B类相对于A类来说就称为内部类，而A类相对于B类来说就是一个外部类。

分为：

  1. 成员内部类：类里面包含类

image.png

  1. 静态内部类：包含的类使用static修饰。

  2. 局部内部类：在一个类中的方法中定义类。

image.png

  1. 匿名内部类：在实例化类的时候，没有初始化名字。（new 接口{}，必须同步实现接口中的方法。所以并不是单一的像类new对象）

image.png

avatar
文章
阅读
粉丝