Java学习-02面向对象

最新推荐文章于 2021-07-09 09:37:54 发布

xxxjrr

最新推荐文章于 2021-07-09 09:37:54 发布

阅读量115

点赞数

分类专栏： Java学习视频知识点

本文链接：https://blog.csdn.net/xxxjrr/article/details/107964305

版权

Java学习视频知识点专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、面向对象基础

1. 面向对象思想

1.1 概述

面向对象（Object Oriented）是相对于面向过程来讲的，指的是把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

面向过程到面向对象思想层面的转变：

面向过程关注的是执行的过程，面向对象关注的是具备功能的对象。
面向过程到面向对象，是程序员思想上从执行者到指挥者的转变。

1.2 三大思想

面向对象思想从概念上讲分为以下三种：OOA、OOD、OOP

OOA：面向对象分析（Object Oriented Analysis）
OOD：面向对象设计（Object Oriented Design）
OOP：面向对象程序（Object Oriented Programming

1.3 三大特征

封装性：所有的内容对外部不可见
继承性：将其他的功能继承下来继续发展
多态性：方法的重载本身就是一个多态性的体现

2. 类与对象

2.1 两者关系

类表示一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。类必须通过对象才可以使用，对象的所有操作都在类中定义。
类由属性和方法组成：

属性：就相当于人的一个个的特征。
方法：就相当于人的一个个的行为。

2.2 类的定义格式

在这里插入图片描述

属性定义格式：数据类型属性名;
属性定义并赋值的格式：数据类型属性名 = 初始化值;

方法定义格式：

2.3 对象的创建与使用

一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下:
类名称对象名称 = new 类名称() ;

如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式：
访问类中的属性：对象.属性 ;
调用类中的方法：对象.方法(实际参数列表) ;

3. 创建对象内存

3.1 栈

栈存储的特点是：先进后出

3.2 堆

存放的是类的对象

3.3 方法区

存放的是类信息、静态的变量、常量、成员方法
方法区中包含了一个特殊的区域 ( 常量池 )(存储的是使用static修饰的成员)

3.4 PC寄存器

PC寄存器保存的是当前正在执行的JVM指令的地址
在Java程序中, 每个线程启动时, 都会创建一个PC寄存器

3.5 本地方法栈

保存本地(native)方法的地址

4. 构造方法

二、面向对象进阶

1. 封装private

在开发中，为了避免出现逻辑错误，我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得操作。

2. this

在Java基础中，this关键字是一个最重要的概念。使用this关键字可以完成以下的操作：

调用类中的属性
调用类中的方法或构造方法
表示当前对象

3. static

3.1 概述

static表示“静态”的意思，可以用来修饰成员变量和成员方法(后续还会学习静态代码块和静态内部类)。
static的主要作用在于创建独立于具体对象的域变量或者方法
简单理解：
被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。并且不会因为对象的多次创建而在内存中建立多份数据。

3.2 重点

静态成员在类加载时加载并初始化。
无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )
在访问时：静态不能访问非静态 , 非静态可以访问静态 !

4.包

4.1 介绍

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
包如同文件夹一样，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

4.2 使用规则

包中java文件的定义：
在.java文件的首部，必须编写类所属哪个包
格式： package 包名;

包的定义：通常由多个单词组成，所有单词的字母小写，单词与单词之间使用.隔开，一般命名为“com.公司名.项目名.模块名…”。

4.3 import 关键字

import 包名.类名;

5. 权限修饰符

在这里插入图片描述

6. 代码块

普通代码块 在执行的流程中出现的代码块，我们称其为普通代码块。
构造代码块 在类中的成员代码块，我们称其为构造代码块，在每次对象创建时执行，执行在构造方法之前。
静态代码块 在类中使用static修饰的成员代码块，我们称其为静态代码块，在类加载时执行。每次程序启动到关闭，只会执行一次的代码块。
同步代码块 在后续多线程技术中出现。

7. main方法详解

public static void main(String args[])

以上的各个参数的含义如下：

public：表示公共的内容，可以被所有操作所调用
static：表示方法是静态的，可以由类名称直接调用。java StaticDemo09
void：表示没有任何的返回值操作
main：系统规定好的方法名称。如果main写错了或没有，会报错NoSuchMethodError: main
String[] args：字符串数组，接收参数

三、面向对象高级

1.继承

1.1 概念

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象(实例)具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

1.2 格式

class 父类{

}
class 子类 extends 父类 {

}

1.3 继承的限制

Java中只有单继承，多重继承（C想继承B和A，可以C继承B，B继承A），没有多继承（同时继承多个父类。因为不同的父类可能有相同的特征时，如何选择继承谁的）

1.4 super关键字

通过super，可以访问父类构造方法
调用super构造方法的代码，必须写在子类构造方法的第一行。

通过super，可以访问父类的属性

通过super，可以访问父类的方法

1.5 重写

1.5.1 重写(override)

规则:（子父类之间）

1，参数列表必须完全与被重写方法的相同；

2，返回类型必须完全与被重写方法的返回类型相同；

3，访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为public,那么在子类中重与该方法就不能声明为protected；

4，父类的成员方法只能披它的子类重写；（如果两个类之间没有关系，因为没有继承，所以不算重写）

5，声明为static和private的方法不能被重写，但是能够被再次声明。（静态static的方法与对象无关。私有private不能被继承，所以无法重写）

1.5.2 重写和重载的区别

发生的位置

重载：一个类中
重写：子父类中

参数列表限制

重载：必须不同
重写：必须相同

返回值类型

重载：与返回值类型无关
重写：返回值类型必须一致

访问权限

重载：与访问权限无关
重写：子的方法权限不能小于父的方法权限

异常处理

重载：与异常无关
重写：异常范围可以更小，但是不能抛出新的异常

1.6 final关键字

final用于修饰属性、变量。

变量成为常量，无法再次进行赋值；
final修饰的局部变量（在方法内部），只能赋值一次(可以先声明后赋值)
final修饰的是成员属性，必须在声明时赋值。
全局常量( public static final )

final用于修饰类。
final修饰的类，不能被继承。
final用于修饰方法。
final修饰的方法，不能被子类重写。

2. 抽象类

2.1 概念

抽象类必须使用abstract class声明
一个抽象类中可以没有抽象方法。抽象方法必须写在抽象类或者接口中。

2.2 抽象方法

只声明而未实现的方法称为抽象方法（未实现指的是：没有“{}”方法体），抽象方法必须使用abstract关键字声明。

格式：

abstract class 类名{ // 抽象类 
    public abstract void 方法名() ; // 抽象方法，只声明而未实现 
}

2.3 不能被实例化

在抽象类的使用中有几个原则：

抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写(重写)抽象类中的全部抽象方法

2.4 常见问题

抽象类不能使用final声明，因为final属修饰的类是不能有子类的，而抽象类必须有子类才有意义，所以不能。
抽象类能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法。

2.5 抽象类和普通类的区别

抽象类必须用public或procted 修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。默认缺省为 public
抽象类不可以使用new关键字创建对象，但是在子类创建对象时，抽象父类也会被JVM实例化。
如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为abstract类

3. 接口

3.1 概念

如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。

格式：

interface 接口名称{
       全局常量 ;
       抽象方法 ;
}

3.2 面向接口编程思想

这种思想是接口是定义（规范，约束）与实现（名实分离的原则）的分离。
优点：

降低程序的耦合性
易于程序的扩展
有利于程序的维护

3.3 全局常量和抽象方法的简写

因为接口本身都是由全局常量和抽象方法组成，所以接口中的成员定义可以简写：
1、全局常量编写时，可以省略public static final 关键字
2、抽象方法编写时，可以省略 public abstract 关键字

3.4 接口的实现

接口可以多实现

格式：

class 子类 implements 父接口1,父接口2...{

}

以上的代码称为接口的实现。那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下的格式编写即可：

class 子类 extends 父类 implements 父接口1,父接口2...{

}

3.5 接口的继承

接口因为都是抽象部分，不存在具体的实现，所以允许多继承,例如：

interface C extends A,B{
}

**注意：**如果一个接口要想使用，必须依靠子类。子类（如果不是抽象类的话）要实现接口中的所有抽象方法。

3.6 接口和抽象类的区别

1、抽象类要被子类继承，接口要被类实现。
2、接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。
3、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
4、抽象类使用继承来使用，无法多继承。接口使用实现来使用，可以多实现
5、抽象类中可以包含static方法，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）
6、接口不能有构造方法，但是抽象类可以有

4. 多态

4.1 概念

多态：就是对象的多种表现形式，（多种体现形态）

4.2 多态的体现

对象的多态性，从概念上非常好理解，在类中有子类和父类之分，子类就是父类的一种形态，对象多态性就从此而来。

ps: 方法的重载和重写也是多态的一种，不过是方法的多态（相同方法名的多种形态）。

重载：一个类中方法的多态性体现
重写：子父类中方法的多态性体现

4.3 多态的使用：对象的类型转换

类似于基本数据类型的转换：

向上转型：将子类实例变为父类实例
格式：父类父类对象 = 子类实例；
向下转型：将父类实例变为子类实例
格式：子类子类对象 = （子类）父类实例；

5. instanceof

作用：判断某个对象是否是指定类的实例，则可以使用instanceof关键字

格式：实例化对象 instanceof 类 //此操作返回boolean类型的数据

6. Object类

6.1 概念

Object类是所有类的父类（基类），如果一个类没有明确的继承某一个具体的类，则将默认继承Object类。
例如我们定义一个类：

public class Person{
}

其实它被使用时是这样的：

public class Person extends Object{
}

6.2 Object的多态

使用Object可以接收任意的引用数据类型

6.3 toString

此方法的作用：返回对象的字符串表示形式。
Object的toString方法，返回对象的内存地址

6.4 equals

建议重写Object中的equals(Object obj)方法，此方法的作用：指示某个其他对象是否“等于”此对象。
Object的equals方法：实现了对象上最具区别的可能等价关系; 也就是说，对于任何非空引用值x和y ，当且仅当x和y引用同一对象（ x== y具有值true ）时，此方法返回true 。

equals方法重写时的五个特性：

自反性：对于任何非空的参考值x ， x.equals(x)应该返回true 。
对称性：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报true 。
传递性：对于任何非空引用值x ， y和z，如果x.equals(y)回报true个y.equals(z)回报true，然后x.equals(z)应该返回true。
一致性：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，前提是未修改对象上的equals比较中使用的信息。
非空性：对于任何非空的参考值x ， x.equals(null)应该返回false 。

7. 内部类

7.1 概念

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。
广泛意义上的内部类一般来说包括这四种：
1、成员内部类
2、局部内部类
3、匿名内部类
4、静态内部类

7.2 成员内部类

成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式:

class Outer {
   private double x = 0;
   
   public Outer(double x) {
       this.x = x;
   }
   
   class Inner {     //内部类
       public void say() {
           System.out.println("x="+x);
       }
   }
}

特点：成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量
外部类.this.成员方法

外部使用成员内部类

       Outter outter = new Outter();
       Outter.Inner inner = outter.new Inner()

7.3 局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
注意:局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

四、异常处理

1. 异常

异常是在程序中导致程序中断运行的一种指令流。

1.1 异常处理

如果要想对异常进行处理，则必须采用标准的处理格式，处理格式语法如下:

try{
    // 有可能发生异常的代码段 
}catch(异常类型1 对象名1){ 
    // 异常的处理操作 
}catch(异常类型2 对象名2){
    // 异常的处理操作 } ... 
finally{ 
    // 异常的统一出口 
}

在进行异常的处理之后，在异常的处理格式中还有一个finally语句，那么此语句将作为异常的统一出口，不管是否产生了异常，最终都要执行此段代码。

try+catch的处理流程
1、一旦产生异常，则系统会自动产生一个异常类的实例化对象。
2、那么，此时如果异常发生在try语句，则会自动找到匹配的catch语句执行，如果没有在try语句中，则会将异常抛出.
3、所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由此catch进行处理。

1.2 异常体系结构

异常指的是Exception ， Exception类，在Java中存在一个父类Throwable（可能的抛出）
Throwable存在两个子类：
1.Error：表示的是错误，是JVM发出的错误操作,只能尽量避免，无法用代码处理。
2.Exception：一般表示所有程序中的错误，所以一般在程序中将进行try…catch的处理。

在这里插入图片描述

多异常捕获的注意点：
1、捕获更粗的异常不能放在捕获更细的异常之前。
2、如果为了方便，则可以将所有的异常都使用Exception进行捕获。

1.3 异常处理常见面试题

1. try-catch-finally 中哪个部分可以省略？
答： catch和finally可以省略其中一个， catch和finally不能同时省略注意:格式上允许省略catch块,但是发生异常时就不会捕获异常了,我们在开发中也不会这样去写代码.
**2. try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？ **
答：finally中的代码会执行详解：执行流程：

先计算返回值，并将返回值存储起来，等待返回
执行finally代码块
将之前存储的返回值，返回出去；需注意：
返回值是在finally运算之前就确定了，并且缓存了，不管finally对该值做任何的改变，返回的值都不会改变
finally代码中不建议包含return，因为程序会在上述的流程中提前退出，也就是说返回的值不是try或 catch中的值
如果在try或catch中停止了JVM,则finally不会执行.例如停电- -, 或通过如下代码退出 JVM:System.exit(0);

2. throws

2.1 概念

在程序中异常的基本处理已经掌握了，但是随异常一起的还有一个称为throws关键字，此关键字主要在方法的声明上使用，表示方法中不处理异常，而交给调用处处理。

格式：

返回值 方法名称()throws Exception{

}

2.2 什么时候用throws/try-catch

如果是因为传入的参数导致异常的发生，则可以通过throws抛出异常。通常是谁调用谁处理；

如果是在此方法中调用时，可以使用try-catch处理异常，并使程序正常运行。

3. throw

throw关键字表示在程序中人为的抛出一个异常，因为从异常处理机制来看，所有的异常一旦产生之后，实际上抛出的就是一个异常类的实例化对象，那么此对象也可以由throw直接抛出。

4. 自定义异常

xxxjrr

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录