面向对象

面向对象

面向过程：线性思维，第一步做什么，第二步做什么。适合处理一些简单问题。

面向对象：分类的思维模式，适合处理复杂的问题，适合处理多人协作的问题！

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

面向对象编程（Object-Oriented Programming,OOP）：以类的方式组织代码，以对象的组织（封装）数据

抽象

三大特性： 封装、继承、多态

回顾：方法

方法定义

• 修饰符：后续逐渐补充

• 返回类型：void 基本数据类型/引用数据类型（数组、类）

• break&return：

  • break 跳出switch,结束循环.
  • reurn:结束方法，返回结果.

• 方法名：注意规范 见名知意

• 参数列表：（参数类型，参数名）…

• 异常抛出：后续补充

方法调用

• 静态方法 ：有static修饰，在类创建时，与类一起加载，从属于类 调用方式：类名.方法名

• 非静态方法：无static修饰，在类被实例化时（创建对象），和对象一起加载，从属于对象 调用方式：对象名.方法名

• 形参&实参：

• 值传递&引用传递：

• this关键字：

  • 调用类内的属性&方法（相当于本类的类名 this.属性名 this.方法名

  • this修饰的变量用于指代成员变量（区分局部变量和成员变量的重名问题）

一、类与对象

• 类是对象的抽象：模板Class
• 对象是类的具体(实例)

1、类 = 属性+方法

​ 静态的属性 属性

​ 动态的行为 方法

属性（成员变量）：字段Field

• 默认初始化：
  • 数字：0 0.0
  • char :u0000
  • boolean:false
  • 引用：null

修饰符 属性类型 属性名 =属性值！

2、对象的创建和使用

• 必须使用 new 关键字创造对象

  Person yongkang = new Person();

• 使用new创建时，除了会分配内存空间，还会给创建好的对象进行默认的初始化,以及对类中构造器（构造方法）的调用

• 对象的属性&方法 对象名.属性名 对象名.方法

• 简单的内存分析：（为了方便理解，简单解释）
  • 栈:存放引用（变量名——存放具体值的地址）、方法区、静态方法区
  • 堆:存放具体的对象（具体值）
  • 对象是通过引用来操作的：栈—>堆
• 方法区： 常量池
• 静态方法区：static :和类一起加载

3、构造方法

​ 构造器（构造方法）:

• 使用new关键字（new本质在调用构造方法），必须有构造器（默认的有无参构造）

• 如果定义有参构造，无参构造就必须显式定义

构造器：

• 名字与类名相同。

• 没有返回值，但不能用 void 声明构造函数。

• 生成类的对象时自动执行，无需调用。

• 初始化对象的值

Constructor(构造器) 不能被 override（重写）,但是可以 overload（重载）。

快捷键：Alt+Insert —— 快速生成构造器&Getter/Setter

二、OOP三大特性

面向对象编程（Object-Oriented Programming,OOP）:封装、继承、多态

1、封装

• 属性私有（private关键字）——对象无法直接调用和修改类内私有属性，并提供公共访问方法get/set

• “高内聚，低耦合”
  • 高内聚：就是内部数据操作细节自己完成，不允许外部干涉；
  • 低耦合：仅暴露少量方法给外部使用。

记住这句话*(封装关键)*：属性私有，get/set

快捷键：Alt+Insert —— 快速生成构造器&Getter/Setter

2、继承

• extends :“扩展”

  • 子类是父类的拓展
  • 子类拥有父类的全部方法&属性(私有不继承)

• Java中类只有单继承，没有多继承

• implements 关键字可以多继承接口(类可以实现多个接口)

• Object：在java中，所有类，都默认直接或间接继承Object类

• super:在子类的内部调用父类的方法和属性是通过super来实现的

super注意点：

• super调用父类的构造方法，必须在构造方法的第一个(子类默认调用父类无参构造)

• super必须只能出现在子类的方法或构造方法中！

• super和this不能同时调用构造方法

this Vs super:

• 代表对象不同

  • this:本事调用者最高对象

  • super:代表父类对象的引用

• 前提

  • this:没有继承也可以使用

  • super:只能在继承条件才可以使用

• 构造方法

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

• 重写（override）：重写都是方法重写,与属性无关

重写(override)：需要有继承关系，子类重写父类的方法

• 方法名必须相同

• 参数列表必须相同

• 修饰符：范围可以扩大但不能缩小： public>protected>deault>private

• 抛出的异常：范围可以被缩小，但不能被扩大： ClassNotFoundException–>Exception

• 子类的方法和父类必要一致；方法体不同！

为什么需要重写：

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

• 快捷键：Alt+Insert ；override

Vs:重载（overload）：同一类中方法名相同，参数不同的方法

3、多态

• 即同一个对象可以根据发送对象的不同而采用不同的行为方式
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

动态编译：类型：可扩展性更强

• 一个对象实际类型是确定的 ：

​ new Student();

​ new Person();

• 可以指向的的引用类型就不确定了：

​ Student s1 = new Student();

​ Person s2 = new Student();

​ Object s3 = new Student();

多态存在的条件：

• 继承关系、重写父类方法、父类引用子类对象

父类的引用指向了子类//向上转型

Person p =new Student(); Father f1 = new Son();

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大；

能够执行后，再根据左边判断//子类重写了父类的方法，执行子类方法

• Student 能调用的方法都是自己的或者继承父类的！

• Person 父类型，可以指向子类，但是不能调用子类独有方法

  • （除非强制类型转换-向下转型） ((Student)s2).eat();

注意：方法才有多态，属性没有。

部分相关修饰符(无法重写)：

• static 方法，属于类，它不属于实例
• final 常量；
• private 方法

• 静态方法和非静态方法有区别：
  • 优先级：类>对象
  • 因为静态方法是类的方法，而非静态方法是对象的方法。

• instanceof ：（类型转换） 引用类型,判断一个对象是什么类型.
  • 如果匹配(判断两个类之间是否有父子关系)，可以进行类型转换（向上转型）

Object > String

Object > Person > Teacher

Object > Person >Student

=====================================

Object object =new Student();

=====================================

object instanceof Student //true

object instanceof Person //true

object instanceof Object //true

object instanceof Teacher //false

object instanceof String //false

=====================================

子类 instanceof 父类 （父类的父类）

三、修饰符（关键字）

• public

• protected

• default

• private

• static

• final

• abstract

  • 抽象类

四、接口

Interface

• 约束，只能定义方法名
• 子类实现接口，必须重写其中的方法
• 只有一个方法的接口叫函数式接口，可以使用 lambda 简化
• 接口比抽象类更抽象
• 一个类可以实现多个接口: implement

五、内部类

• 局部内部类
• 静态内部类
• 匿名内部类（重点）

三、抽象类\方法

1、abstract 抽象类\方法

抽象类：抽象类的的所有方法，继承了他的子类都需必须要实现他的方法~ 除非~他的子类也是抽象类

PS:

1.不能new这个抽象类，只能靠子类去实现它；约束！

2.抽象类中可以写普通的方法~

3.抽象方法必须在抽象类中~

//抽象的抽象：约束

抽象方法：只有方法名字，没有方法实现

2、☆接口:可以多继承 interface //implements 关键字可以多继承接口

Vs:

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有！

接口：只有规范！自己无法写方法_{专业的约束！约束和实现分离：面向接口编程} 接口的本质是契约

接口中的定义其实都是抽象的:*public abstract*

接口实现类后缀 ~Impl

3、内部类

成员内部类：（类中类）获得外部类的私有属性~操作外部类的方法

静态内部类：类中类＋static

局部内部类：类中方法中的类

匿名内部类：没有名字初试化类————new Apple().eat();

23**种设计模式–面向对象精髓

捕获异常快捷键：Crtl+Alt+T

try{

}catch{

}finally{

}