面向对象

面向对象

三大特征

封装性，把相关的数据封装成一个“类”组件

继承性，是子类自动共享父类属性和方法，这是类之间的一种关系

多态，增强软件的灵活性和重用性

类
-

java语言的最基本单位，是一类事物的抽象（可以理解为模板或者图纸）

1. 如果类里什么都没有写，最少会隐藏一个无参构造。
2. 无参构造不是时时刻刻都有，如果只提供含参构造，无参构造就没了
3. 当被实例化的时候构造方法就会被触发。
4. 类里可以提供多个构造方法，方便外界new。

对象

三个特点 状态 行为 标识

状态：描述对象基本特征

行为：描述对象的功能

标识：对象在内存中存在唯一一个地址用来与其他对象区分

成员位置类里方法外

一个.java文件中，可以包含很多个类，只不过只能有一个类能被public修饰，而且被public修饰的文件名就是.java的名

对象在内存中的存放

一般局部变量存在栈中

对象存在堆中

断点模式/debug

用来在开发调试阶段，跟踪代码执行过程

操作步骤

--设置断点

--开启断点模式

--单步执行f6 释放断点f8

封装

通过private的关键字封装后只能在本类中使用。

属性被封装后

 public void setName(String n) {
 ​
  name=n;}
 ​
 public String setName() {
 ​
  return name;}
 ​
 

构造方法

作用

用来完成对象的创建和初始化

当实例化一个对象时，会自动调用方法

--一个 特殊的方法 特殊在没有返回值+方法名就是类名

语法

修饰符 类名（参数列表）{方法体}

--默认隐藏一个无参的构造方法。

构造代码块和局部代码块

1.代码块

一段被{}包起来的代码

2.位置

成员位置：类里方法外--构造代码块

方法里--局部代码块

3.构造代码块

用来提取构造方法中的共性

执行顺序 构造代码块——————构造方法

作用：提取的代码的共性，提高了代码的复用性

触发的时间节点：new时。

4.局部代码块

--作用：用来控制代码块的作用范围

总结：

作用

构造代码块--提取方法中的共性，高聚合

局部代码块--控制变量的作用范围

位置

1. 构造代码块--在类里方法外。

局部代码块--在方法里。

触发时间点

构造代码块--new时。

局部代码块--方法被调用时。

执行顺序

构造代码块--构造方法--局部代码块

this关键字

this关键字

总结

this一般可以省略，但是当成员变量名和局部变量名相同时必须用this

如果不用this，会根据变量使用的就近原则一直使用局部变量

this可以完成构造方法见互相调用，只不过必须是构造方法里的第一条语句。

但是只支持单项调用（禁止套娃）

ps.如果是基本类型传递的是值，如果为引用类型传递的就是地址值。

继承

概述

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。

特点

使用extends关键字

相当于子类把父类的功能复制了一份

java只支持单继承

继承可以传递（爷爷，儿子，孙子的关系）

不能继承父类的私有成员

继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展

super关键字

1.super表示父类对象的引用

2.super在子类中，调用父类的功能。

3.super在构造方法里必须是第一条语句

方法的重写

作用

一般不会发生除非子类继承了父类功能后，想要修改时才发生

要求

--在子类中想要改时，子类的方法声明要求和父类一样。

--子类的权限修饰符>=父类

总结

--子类能总结父类除私有的所有功能，还能进行功能拓展。

--子类继承父类的方法后，如果要改，还能进行方法的重写。

--重写：子类的方法声明要求和父类一样。

--重写没有影响父类功能，改的只是子类功能，源码不允许修改。

--子类创建对象是会先调用父类的无参构造，然后在执行自己的，如果父类没有无参构造会调用父类的含参构造。

ps.OCP原则：开闭原则--对源码修改关闭，对功能扩展开放

static关键字

特点

--可以修饰成员变量和成员方法

--静态资源加载时机早于对象，是跟着类加载而加载的。（即使不new一个对象也可以使用）

--静态资源可以使用对象调用，也可以可以用类名调用。

--静态资源是共享资源，可以被多个对象共享（对象a更改静态资源后，对象b的调用静态资源也是更改过的）

--静态资源调用的资源必须也是静态的。普通资源里可以调用静态资源。

静态代码块

--拥有static的所有特点

static{

}

总结

--触发的时间节点

构造代码块：调用方法前--提取构造方法的共性

构造方法：在创建对象时--用来创建对象和对象初始化

静态代码块：类加载时--完成项目的初始化（加载的早且值执行一次）

局部代码块：方法调用时--控制变量范围

静态代码块>构造代码块>构造方法>局部代码块

final

1.final可以修饰类，方法，变量。

2.final修饰的方法是最终方法，final修饰的变量是最终变量（常量）。只能继承不能修改。

多态

概述

是指一个对象拥有多种形态

好处是: 提高程序的灵活和扩展性

目的: 写出通用的代码,做出通用的编程,统一调用的标准

特点

--前提：发生继承关系+方法重写

--口诀1.父类引用 指向 子类对象。（是指，父类引用--引用类型的变量a是父类类型，子类对象--是指要创建的对象是子类的对象）

--口诀2：编译看左边，运行看右边（编译看左边--是指能用调用的功能，一定是左边父类提供的。运行看右边--是指运行的结果是看右边，看子类的实现方式）

目的

多态的目的是统一调用标准--标准就是父类。

多态的好处

好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

只需要传入的参数是 父类的类型 ,不需要具体指定是哪个子类,屏蔽了子类之间的不同.

多态的使用

--成员变量/成员方法/静态资源

--方法声明父类的，方法体用子类的

--使用父类的成员变量

--静态资源不能被重写（使用父类的方法声明和方法体）

异常

用来封装错误信息的对象

--1.概述：是指程序中出现的bug，被封装成一个异常类。

--2.继承体系

--throwable

--Error：系统级错误，非软件错误

--Exception：软件中出现的错误

异常处理

--因为程序中可能会发生异常，为了不能让用户看见异常，需要研究异常处理的方法

--捕获--相当于自己处理的错误

try{

.....

.....

....

....

}catch(异常类型 异常名字){

给出合理的解决方案

}

--抛出:我不管，爱谁关谁管

在方法声明上加一段代码 throws 异常类型1，异常类型2

异常之后的代码不会执行，必须要执行必须方法finally里

try{

}finally{

}

总结

--1.当程序中出现异常时必须处理掉，不能暴露给用户。

--2.处理异常的方式有二种，捕获和抛出。

--3.捕获try{会有问题的代码}catch(异常类型 变量名){解决方案} 可以catch多次。

--4.抛出的语法：在方法声明上添加throws 异常类型1，异常类型2；

--5.如果代码放在try可能会出现异常后的代码不执行的情况。为了保障代码一定会执行，可以把这样代码放入finally块。

--6.怎么决定遇到异常时捕获还是抛出，知道方案尽量捕获，不知道方法可以抛出。

访问控制符

--1.概念

用来控制资源访问权限

--2.方法重写

要求子类在重写父类方法时权限要有足够的权限

抽象类

抽象的 public void eat ;//没有方法体就是抽象的方法

Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。

抽象类可以理解为是一个只有方法声明没有方法体的特殊类。

概述

当子类继承了父类后，如果想要修改就要发生重写现象。

重写要求紫的方法声明和父类一样，此时父类的方法多余。

干脆父类不提供方法体，没有方法体的方法是一个抽象方法

类里有抽象方法就是抽象类。

特点

1、 通过java关键字abstract实现

2、 可以修饰方法或者类

3、 抽象类中可以没有抽象方法（由子类去实现）

4、 如果类中有抽象方法，那该类必须定义为一个抽象类

5、 子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写

6、 多用于多态中

7、 抽象类不可以被实例化（抽象类不能new）

总结

--抽象类有构造方法

--抽象类不能被实例化

--抽象类提供构造方法的目的是给子类实例化--子类new时隐藏着一个super（）；

--抽象类中有变量也有常量

--抽象类是一个特殊的类因为他基友普通方法也有抽象方法。

--子类继承了抽象类，要么重写所以抽象方法，要么变成抽象的子类

接口

概述

接口的好处：接口是一套开发的规范。+ 同时使用多个接口，体现了可扩展性灵活性

以后的开发要做到面向接口编程，面向抽象编程。

特点

-- 接口中都是抽象方法

-- 通过interface关键字创建接口

-- 通过implements让子类来实现

-- 可以理解成，接口是一个特殊的抽象类

-- 接口突破了java的单继承的局限性

-- 接口和类之间可以多实现，接口和接口之间可以多继承

-- 接口是对外暴露的规则，是一套开发规范

-- 接口提高了程序的功能扩展，降低了耦合性

接口的复杂用法

--接口和类之间可以多实现，接口和接口之间可以多继承

继承父类的同时，实现接口。

总结

--类和类间的关系

继承关系，而且是单继承

--class A extends B

A是子类，B是父类

A的优势，可以使用B里的功能，而且可以使用自己的扩展功能

A可以修改B里的方法，方法的重写

接口和接口的关系

继承关系，而且是多继承

--interface Inter01 extends Inter02,Inter03

其中Inter01是子接口Inter02,Inter03父接口

子接口的优势：同时使用自己和父接口的所有功能。

--class InterImpl1 implements Inter1

InterImpl1 需要重写Inter1里所有的抽象方法，否则就是一个抽象的实现类。

类和接口的关系

实现关系，可以多实现

--class Aimplements B,C

其中A是实现类，B和C都是接口

对A的要求：

重写B和C中使用的所有的抽象方法。

--class A extends B implements C,D

A可以使用父类B的所有功能和接口C D 的所有功能

A必须重写所有的抽象方法。否则A包含没重写的抽象方法就是一个抽象的类