OOP(面向对象)总结(有这一篇足矣)

落日飞行

已于 2023-11-21 09:22:01 修改

阅读量1.7w

点赞数 27

分类专栏： Java基础拓展与总结(项目总结) 文章标签：蓝桥杯职场和发展 java

于 2022-01-26 17:25:08 首次发布

本文链接：https://blog.csdn.net/m0_53151031/article/details/122696692

版权

Java基础同时被 2 个专栏收录

12 篇文章 4 订阅

订阅专栏

拓展与总结(项目总结)

6 篇文章 0 订阅

订阅专栏

前言：OOP是Java语言中重要组成部分，其中面向对象编程是Java中核心编程思想，今天就将OOP知识进行总结

一、思维导图

二、面向对象

1、首先先了解面向对象是什么（这里将面向对象和面向过程进行对比）

七、this、static、单例模式、instanceof

前言：OOP是Java语言中重要组成部分，其中面向对象编程是Java中核心编程思想，今天就将OOP知识进行总结

一、思维导图

首先在总结知识点前看一幅思维导图

二、面向对象

1、首先先了解面向对象是什么（这里将面向对象和面向过程进行对比）

面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发

面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以易维护、易复用、易扩展。可以设计出低耦合的系统。但是性能上来说，比面向过程要低。

2、具体说法：

1、面向对象—针对具体的对象是把构成问题的事务分解成各个对象

2、建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为和特性

3、无序性是关键

3、面向对象三大特性

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

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

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

三、对象与类

1、对象

1、对象：万事万物皆对象，可以将身边的任何一件事以及任何一个事物作为对象

同时，对象还具有属性(对象具有的各种特种),以及属性值(每个对象的每个属性拥有的特定值)以及方法

举例：具体一个人是一个对象(但是人类是抽象类)，人的身高、姓名、体重是属性，而身高对应的183cm是属性值，其中人可以动脑、吃、睡都是方法

2、类

2.1概念：

类是Java程序的核心，它定义了对象的形状和本质，可以用类来创建对象。当使用一个类创建了一个对象时，通常说给出了这个类的一个实例。类由类声明和类体构成。

2.2类声明和类体

类声明： class className {

类体： //body

}

class是声明类的关键字，每个字母都小写。“class ClassName”是类的声明部分，“ClassName”需符合Java声明类名的标准规范，即每个单词的第一个字母需要大写 {}”以及之间的内容称为类体。

2.1.1其中类声明还有一些要注意的地方：

一、Java的类声明是创建类时必须对类的一些性质进行描述。包括类名、类的父类、类所实现的接口及类的修饰符。它的一般格式为：

1、[public][abstract|final] class ClassName [extends superclassName]

2、[implements interfaceNameList]

二、关键字class前面是可选修饰符的，其中：

1、public：访问权修饰词，允许所有的类访问它，如果某个类以public做修饰词，那么这个类的类名必须和Java文件名（*.java）相同。

2、abstract：对父类的修饰词，当这个类声明为抽象类时，该类就不能被实例化。

3、final：对子类的修饰词，当这个类被声明为最终类时，它不能再有子类。如果这个类上面还有父类，那么就需要用到extends修饰词，在之后跟父类名。如果要实现某个接口，就需要用到implements修饰词，后面跟接口名。

2.1.2类体注意点：

一、紧跟在类名后面的大括号以及大括号之间的内容称之为类体。

1、我们在程序中写类的目的就是为描述一类事物共有的属性和功能。

2、类体将完成对数据及对数据的操作进行封装。

二、类体内容由两种类型构成：

1、成员变量：

通过变量声明定义的变量，称之为成员变量或域，它用来描述类创建的对象的属性。

2、方法：

类体主要由方法构成。方法可分为构造方法和普通方法。其中构造方法具有重要地位，它供类创建对象时使用，用来给出类所创建的对象的初始状态。普通方法可以由类所创建的对象调用，对象调用这些方法操作成员变量形成一定的算法，体现了对象具有某种功能。

2.3类具体的实例：

public class Circle {
	private double radius;
	private double area;
	final double PI=3.14;
	public void setRadius(double r) {
		radius=r;
	}
	public double getArea( ) {
		return PI*radius*radius;
	}
}

2.4类与对象的对比

类：类是抽象的

对象：对象是具体的

补充：关于final关键字的使用：

final变量就是我们常说的常量

1、按照Java的命名规范，常量的名字的所有字母都应该大写

2、 final变量是不占用内存的，所以在声明final变量时，必须初始化

3、final变量不同于类变量和实例变量，对象虽然可以使用它，但是不能对它进行更改操作

四、方法

1、方法定义

一个方法包括方法的名称、主体、返回的数据类型

其中返回类型包括带有返回值和没有返回值的。

2、有参构造和无参构造

有参构造：有参构造可以理解为带有参数的构造方法

无参构造：无参构造可以理解为没有参数的构造方法

五、封装、继承、多态

1、封装

1.1封装的定义

封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

1.2、封装的好处：

1.3、为什么要是用封装：

代码设计上的不合理赋值

1.4、如何使用封装：

案例：

package com.ZJ.www;

public class Dog {
    private String name = "旺财"; // 昵称
    private int health = 100; // 健康值
    private int love = 0;   // 亲密度
    private String strain = "拉布拉多犬"; // 品种
    public int getHealth() {
        return health;
    }
    public void setHealth (int health) {
        if (health > 100 || health < 0) {
            this.health = 40;
            System.out.println("健康值应该在0和100之间，默认值是40");
        } else
            this.health = health;
    }
    // 其它getter/setter方法


}

2、继承（extends）

2.1为什么需要继承：

看以下图片，可以发现狗类和虎类有相同的属性和方法，因此可以写一个父类，封装这些属性。如果没有继承，这些属性和方法每个都要写，是一件非常复杂且重复而且繁琐的事情

2.2继承的好处：

1、少写一些共有的代码

2、提供另外一种形式的分类

3、代码重用

2.3继承的特点：

1、子类可以继承父类的属性和方法。也可以拥有自己特有的方法

2、继承是单向的

2.1一个类只有一个父类

2.2子类能读取父类的方法与属性，但父类不能读取子类的方法和属性

3、多态

3.1什么是多态

多态：同一个引用类型，使用不同的实例而执行不同操作

生活中的多态：同一种事物，由于条件不同，产生的结果也不同

3.2多态如何实现

使用多态实现思路

编写父类

编写子类，子类重写父类方法

运行时，使用父类的类型，子类的对象

3.3实现多态的两个要素

实现多态的两个要素：

1. 方法重写

2. 使用父类类型

六、重载、构造、重写

1、重载：

重载一般是指方法的重载，和重写两个概念要区别开来

重载和重写的区别：

override（重写）

　　 1、方法名、参数、返回值相同。

　　 2、子类方法不能缩小父类方法的访问权限。

　　 3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。

　　 4、存在于父类和子类之间。

　　 5、方法被定义为final不能被重写。

　overload（重载）

　　1、参数类型、个数、顺序至少有一个不相同。

　　2、不能重载只有返回值不同的方法名。

　　3、存在于父类和子类、同类中。

2、构造：

构造分为有参构造和无参构造

有参构造

    
    private Dog(String name, int health, int love, String strain) {
		super();
		this.name = name;
		this.health = health;
		this.love = love;
		this.strain = strain;
	}

无参构造

 public Dog() {
		// TODO Auto-generated constructor stub
	}

3、重写：

方法重写的规则：

1、在继承关系的子类中

2、重写的方法名、参数、返回值类型必须与父类相同

3、私有方法不能继承因而也无法重写

4、方法重写与方法重载的区别

七、this、static、单例模式、instanceof

1、this关键字：

this的字面意思是指这个，this的用法有以下用法：

1.1调用属性

        this.name = name;
		this.health = health;

1.2调用方法

        this.print();

1.3调用构造方法

        this("小黑",100,100,"雄");

2、static关键字：

static字面意思为静态的，可用在方法和属性后面，一般放在修饰符的后面

1、特点：

1、非静态的属性和方法只能通过对象来拿到或者调用

2、修饰符不为private的情况下，静态的属性和方法可以类名直接调用

3、对于属性来讲:如果加了static，那么这个属性就是公用的，所有通过这个类产生的对象都共享该属性

4、对于方法来讲：

4.1：静态的只能调用静态的

4.2：静态方法里面只能调用静态的的方法与属性

4.3：非静态的方法既能调用静态的方法，也能使用静态的属性

2、用途：

2.1创建工具类

2.2计算对象个数

2.2.1网站在线人数

2.2.1游戏在线人数

2.2.1赋予对象ID

3、单例模式：

3.1概念：

确保无论用户调用多少次，拿到的都是一个对象，或者说该类只能生成一个对象

注意：构造方法必须私有化，对外必须公开一个方法用来获得实例，

3.2单例模式的两种加载模式：

3.2.1：饿汉加载

3.2.1.1概念：

饿汉法就是在第一次引用该类的时候就创建对象实例，而不管实际是否需要创建

3.2.1.2优缺点：

优点：写法简单，在类加载的时候就完成实例化

缺点：如果自始至终都没有用过这个对象，就会造成内存浪费

3.2.2：懒汉加载

3.2.2.1概念：

当程序第一次访问单例模式实例（getInstance)时才进行创建（延迟加载）

3.2.2.2优缺点：

优点：当你访问时才会创建，如果自始至终都没有用过这个对象，也不会内存浪费

缺点：加载时间太长

看以下案例，就可以知道两者的区别了

                                        //饿汉加载                            饱汉加载
	private static Bank b = null;     //已经创建好对象                      还没创建对象
	public static Bank getInstance() {//访问方法时直接将对象给你    访问方法是时间，如果对象还 
                                                               //没创建，那么则创建。如果对象 
                                                               //已经创建了，则直接返回。
		if(b==null) {
			b=new Bank();
		}
		return b;
	}

4、instanceof：

4.1instanceof关键字说明：

1、该运算符用来判断一个对象是否属于一个类或者实现了一个接口，结果为true或false

2、在强制类型转换之前通过instanceof运算符检查对象的真实类型，可以避免类型转换异常，从而提高代码健壮性

举例代码：

public class TestPoly2 {
    public static void main(String[] args) {
        // Pet pet = new Penguin("楠楠", "Q妹");
        Pet pet = new Dog("欧欧", "雪娜瑞");
        pet.eat();
        if (pet instanceof Dog) {
            Dog dog = (Dog) pet;
            dog.catchingFlyDisc();
        } else if (pet instanceof Penguin) {
            Penguin pgn = (Penguin) pet;
            pgn.swimming();
        }
    }
}

八、接口

接口这里要注意一点就是实现接口，使用关键词implements，而实现类关键词是用extends

1、接口表示的其实是一种能力
对象是对现实世界物体的抽象
类是对对象的抽象
接口是对类的抽象
2、语法：public interface 接口名
如果一个类要实现这些功能：
语法是 public class 类名 implements 接口名1,接口名2...
3、接口与抽象类的区别：
a：抽象类是类所以只能单继承，而接口（interface）可以多实现
b：抽象类继承用extends，而接口用implements
c：抽象类可以有构造，接口不能
d：抽象类可以有一般的属性，接口中的属性只能是静态常量
e：抽象类中可以有抽象方法，也可以有一般的方法，而接口中只能有抽象方法
f：抽象类中抽象方法可以被除private以外的修饰符修饰，但是接口中只能是public
4、常量一定是全大写

九、异常

1、异常定义：

程序中预先想好了对付异常的处理办法，程序运行，如果出现异常，对异常进行处理，处理完毕，程序会继续进行。

2、异常种类

异常类型分为两种，一种是异常处理，另一种是抛出异常

2.1异常处理：

几种常见的处理方式：

2.1.1：使用try-catch进行抓错

2.1.2：使用try-catch-finally进行抓错

2.1.3：使用多重catch进行抓错

2.2抛出异常：

1、Java语言中通过throws声明某个方法可能抛出的各种异常

2、可以同时声明多个异常，之间由逗号隔开

3、异常处理

Java的异常处理是通过5个关键字来实现的：try、catch、 finally、throw、throws

4、异常分类

OOP的知识点总结到这了，希望能够帮助到大家！如有疏漏恳请大神指点！

落日飞行

关注

27
点赞
踩
244

收藏

觉得还不错? 一键收藏
1
评论
OOP(面向对象)总结(有这一篇足矣)

前言：OOP是Java语言中重要组成部分，其中面向对象编程是Java中核心编程思想，今天就将OOP知识进行总结一、思维导图首先在总结知识点前看一幅思维导图二、面向对象 1、首先先了解面向对象是什么（这里将面向对象和面向过程进行对比）面向过程：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发面向对象：是把构成问题的事务分解成各个对象，...
复制链接

扫一扫