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

目录

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

一、思维导图

二、面向对象

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

          2、具体说法:

          3、面向对象三大特性

三、对象与类

          1、对象

          2、类

                    2.1概念:

                    2.2类声明和类体         

                    2.3类具体的实例:

                    2.4类与对象的对比       

四、方法

          1、方法定义

          2、有参构造和无参构造

五、封装、继承、多态

          1、封装

                    1.1封装的定义

                    1.2、封装的好处: 

                    1.3、为什么要是用封装:

                    1.4、如何使用封装:

          2、继承(extends)

                    2.1为什么需要继承:

                    2.2继承的好处:

                    2.3继承的特点:

          3、多态

                    3.1什么是多态

                    3.2多态如何实现

                    3.3实现多态的两个要素

六、重载、构造、重写

          1、重载:

          2、构造:

          3、重写:

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

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

          1、this关键字:

                    1.1调用属性    

                    1.2调用方法

                    1.3调用构造方法   

          2、static关键字:

                    1、特点:

                    2、用途: 

          3、单例模式:

          4、instanceof:

八、接口

九、异常

          1、异常定义:

          2、异常种类

                    2.1异常处理:

                    2.2抛出异常:

          3、异常处理

          4、异常分类


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

一、思维导图

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

OOP(面向对象)总结(有这一篇足矣)_第1张图片

二、面向对象

          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、方法定义

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

OOP(面向对象)总结(有这一篇足矣)_第2张图片

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

          2、有参构造和无参构造

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

OOP(面向对象)总结(有这一篇足矣)_第3张图片

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

五、封装、继承、多态

          1、封装

                    1.1封装的定义

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

                    1.2、封装的好处: 

OOP(面向对象)总结(有这一篇足矣)_第4张图片

                    1.3、为什么要是用封装:

代码设计上的不合理赋值

                    1.4、如何使用封装:

OOP(面向对象)总结(有这一篇足矣)_第5张图片

 案例:

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为什么需要继承:

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

OOP(面向对象)总结(有这一篇足矣)_第6张图片

                    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、方法重写与方法重载的区别

OOP(面向对象)总结(有这一篇足矣)_第7张图片

七、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(面向对象)总结(有这一篇足矣)_第8张图片

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

你可能感兴趣的:(Java之OOP总结,蓝桥杯,职场和发展,java)