面向对象编程:从事物中，抽离出相关的对象，然后从对象除法，解决问题，可以提高代码的通用性和维护拓展性

面向过程编程:按照过程中的步骤一步一步做

类是创建对象的模板，类是抽象的，不占存储空间，

对象是类的实例，是具体的，是占用存储空间的

类的访问修饰符只有两个，public,默认空

加public与不加的区别:加的话在别的包下也可以使用，但需要导包，不加的话，只能在同包下使用

构造方法作用是初始化

属性分为对象属性，类属性，用static修饰的是类属性，进入JVM中就拥有了自己的空间

非静态:在堆中动态开辟空间

方法

普通方法分为对象方法和类方法

类方法中不能直接调用对象方法，因为不确定类是否存在

签名指方法名+参数列表

构造方法

构造方法的作用:用于初始化对象，是对象在创建时被调用的

this

this可以省略，如果方法中的变量名与属性名一样时，为了区别，this写上。

this.方法 在类中的一个对象方法调用另一个对象方法时，可以用this,静态方法中不能使用this

this()可以用来访问本类中的构造方法，this不能在普通方法中使用，使用时必须是第一条语句(因为初始化)

this()可以添加响应的参数，调用有参构造方法

在同一个类中，构造方法不能通过this()互相调用

this可以访问该对象的属性和方法，因为this也指向了这个对象本身

super()

super()代表父类的构造方法，super不能跟this同时使用

方法参数

形参和实参

参数传递方式:值传递，引用传递

值传递:在方法调用时，实参通过把他的内容副本传入方法内部，此时形参接收的内容是实参的一个拷贝，因此在方法内对实参的任何操作，仅仅是对实参副本的操作，不影响原初始值的内容

引用传递:指向真实地址值，其实指的是栈中的地址，将真实地址复制传递，修改的话，原内容也会改变，加&

在main方法中引入一个类的静态方法，创建两个对象，引入此静态方法将两个对象进行交换

对象是引用类型，所以传入的是地址，在静态方法中只是将地址的值交换了，没有将地址所指的内容进行改变，因为没有返回，所以地址的交换的生效范围只有这个方法内部，类比一下，假如传进去的是两个int类型的数，将数进行交换，到最后他们也不会发生改变

static

可以使类和方法不依赖对象，

static关键字存储在我们的方法区当中的静态常量池中，可以修饰方法，变量和代码块，多个对象实例中，定义的静态属性所指的是同一块内存

static修饰方法 this关键字不能在static方法中使用，静态方法中不能使用非静态方法，

static代码块:主要作用是，变量初始化，先执行静态代码块，后执行构造方法，不能在方法内部定义

static加载顺序

继承(Java三大特性之一)

继承就是子类继承父类的特征和行为，使得子类具有父类的相同的行为，子类具有父类的实例域，父类不能调用子类方法

实例域:对象的属性和变量

重载是为了提高方法的灵活度

重写:意义在于提高继承的灵活度，父类的private修饰的无法被重写，意义，从父类的角度提高继承的灵活度

从某个特定类到其祖先的路径称为继承链，在继承链中，如果直系代没有重写方法，可以隔代重写方法，否则不可隔代重写方法，而是重写直系代的方法

继承的时候，子类要执行时，先执行父类

final

用final修饰的的基本类型的常量值不能改变，且必须给初始值，可以不给，但是需要使用的时候，必须赋值

用final修饰的引用类型的变量，地址不可变

对于全局的常量，必须给初始值，局部的常量，可以不给初始值，但是使用的话必须给初始值，且也是只能赋值一次

final修饰的方法，不能再重写

final修饰的类，不能被继承

final可以防止指令重排序，保证线程安全

指令重排序:是JVM性能优化过程，目的是提高整个代码执行的效率

多态

多态是同一个行为具有多个不同表现形式或形态的能力

程序的最终状态只有在执行过程中才被决定而非编译期间决定

多态目的提高系统的灵活性和拓展性

且只能调用父类独有的方法和子类共有的方法，实现的是子类方法

实现的必要条件:

必须继承关系，必须有重写，父类引用指向子类对象

Object类

所有类的父类

方法

equals()方法就是采用==比较地址

hashcode,外层是数组，每一次里面放的是头节点，内层是链表

hashcode()方法是native方法，是为了获取哈希值，哈希值的计算利用的是内存地址

equals方法和hashCode()方法关系

• 如果两个对象相同(equals方法返回的true)，那么他们的hashCode值一定相同
• 如果两个对象不同(equals方法返回的是false),那么他们的hashCode值可能相同也可能不同
• 如果两个对象hashCode相同(存在哈希冲突)，那么他们可能相同，也可能不同(equals方法可true,可false)
• 如果对象hashCode不同，那他们肯定不同(equals方法返回false)

重写equals方法比重写hashCode方法，(不是同一类肯定不相同)减少比较次数

Java访问权限修饰符

public 使用范围:当前类，同包，父子类，其他包

protected 使用范围:当前类，同包，(父子类，需要创建子类实例去调用)

默认 使用范围:当前类，同包

private 使用范围:当前类

包装类

基本类型不是对象，把基本类型包装一下，具备了原始存储各类类型数据的能力之外，额外的能力，比如不同种类型之间的转换

Byte,Character,Short,Integer,Long,Float,Double,Boolean

包装类的基本操作(Integer为例)

• int->Integer new Integer(值)
• Integer->int Integer 对象.xxValue()
• Integer->String Integer 对象.toString();
• String->Integer new Integer(String value)

装箱:把基本类型转出对应包装类型 Integer i=Integer.valueOf(a);

拆箱:把包装类型转换成对应的基本类型int a=i.intValue();

自动装箱:Java5之前，拆装箱需要手动进行，Java5之后可以自动完成

自动装箱:Integer i=a;

自动拆箱:int a=i

128陷阱：范围在-128到127之间，在缓存数组中放，并返回，地址一样，超出之后就重新开辟空间，在Integer中

abstract

抽象类

• 抽象方法:没有函数体的方法
• 只有抽象类中才能有抽象方法
• 由abstract修饰的类叫抽象类
• abstract修饰的抽象方法不可以在抽象类中实现，但可以在子类重写实现
• 抽象类当中，不一定全是抽象方法(模糊点)，可以有普通方法，普通方法子类不需要重写
• 抽象类不能实例化(重点)，但是可以使用多态
• final不能与abstract同时使用下
• private和abstract不能同时使用
• static不能与abstract同时使用，static是针对类层次的，abstract是针对对象层次的
• 抽象类可以有构造方法，目的:子类对象在初始化之前，先初始化父类对象，即new 子类构造方法之前，先调父类的构造方法
• 子类继承抽象类，如果不想实现抽象类中的抽象方法，那么该类必须是抽象类
• 抽象类中可以没有抽象方法

内部类

内部类是定义在另一个类中的类

• 内部类方法可以访问内部类所在的外部类中的数据，包括私有数据
• 内部类可以对统一的数据隐藏起来，增强面向对象的封装性
• 内部类的调用可以在外部类设置对象，在对象中new内部类
• 当定义一个函数且不想编写大量代码时，使用匿名内部类更便捷
• 借助内部类实现类的多继

类型

• 非静态代码块:非静态内部类如同外部类的对象方法

  • 持有隐式的外部类的引用，指向外部类对象的，故可以访问任意外部类的变量和方法

  • 非静态内部类不能使用static

  • 外部类.内部类 变量名 =new 外部类().new 内部类()

• 局部内部类(不常用),定义在代码块，方法体内

  • 不能使用public,private,static,protected这些修饰符
  • 局部内部类只能在当前的方法内使用
  • 局部内部类和非静态内部类一样，不能拥有静态成员，但是可以访问外部类的所有变量
  • 局部内部类访问的局部变量必须使用final修饰，Java 8之后自动隐式加上final

• 匿名内部类，局部内部类的一种特殊形式，是一个没有名称的内部类

• 使用条件:继承一个父类或实现一个接口

• 静态内部类：

  • 不能访问外部类的对象的变量和方法
  • 静态内部类创建内部类实例时不必要创建外部类实例
  • 静态内部类可以直接访问外部类的静态变量
  • 外部类可以通过完整的类目直接访问静态内部类的静态成员
  • 静态内部类可以定义静态和非静态的变量

接口

产生的背景：

有时候必须从几个类当中派生出一个子类，继承他们所有的方法，Java不支持多继承，于是就有了接口

当抽象类中全是抽象方法时，为了简化abstract关键字，于是就有了接口

特点：

• 接口用interface实现
• 抽象方法默认是public abstract修饰的
• 接口中所有变量都是public static final修饰的
• 接口没有构造方法，但是可以使用多态
• 实现接口的类必须实现接口中的所有方法，如果不实现接口，需要定义为抽象类
• 接口与实现类之间存在多态
• 接口与实现类之间是实现关系，使用implements关键字
• 接口与接口之间是继承关系同时可以多继承
• 类不会因为实现了接口，而不能继承其他类
• 类和接口之间可以多实现，即一个类可以实现多个接口
• Java 8之后，接口中可以有默认方法，使用default关键字修饰即可，也就是可以对方法写方法体了
• 当一个接口中完成了default的方法的写入，另一个接口中是同名的，则不需要重写，但是当父类中也有同名的方法先用父类的

接口与抽象类

• 接口的方法默认都public，是抽象的，接口中不能实现(Java 8之后，接口方法可以实现，使用default)；抽象类可以有非抽象方法
• 接口中的实例变量默认是final类型，而抽象类中则不一定
• 一个类可以实现多个接口，但最多只能继承一个抽象类
• 接口和抽象类都不能使用new来实例化，但是抽象类可以有构造方法，接口没有
• 从设计层面来说，抽象类是对事物的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为规范。

拷贝

浅拷贝

只拷贝原对象的地址，所有原对象的任何值发生改变，拷贝对象的值也会随之发生变化

个人总结:浅拷贝只是一个实例的两个名字

深拷贝

拷贝原对象的所有值而不是地址，所以原对象的值发生改变时，拷贝对象的值都不会发生变化

深拷贝实现方式

• 构造函数方式(常用，性能不好)
• 重写Clone方式(常用)
  • 重写Object类的clone方法，并修改为public
  • 实现Cloneable接口，来告诉JVM子类允许拷贝
    1. 实现Cloneable接口
    2. 重写Clone方法
    3. 使用第一个创建的实例的clone()方法，创建第二个实例

总结深拷贝：重写clone方法的深拷贝，只能对当前类进行拷贝，无法拷贝当前类引用的类

Java异常

最大的类：Throwable,底下有两个类：Error和Exception

Exception：分为运行时异常（非受检异常）和非运行时异常（受检异常）

Error是程序无法处理的错误，它是由JVM产生并抛出的，比如OutOfMemoryError,ThreadDeath，这些异常发生时，JVM会选择终止

Exception是程序本身可以处理的异常，程序应当尽可能去处理这些异常

运行时异常都是RuntimeException类及子类，如NullPointerException，IndexOutOfBoundsException等，这些异常可以选则捕获处理，或者抛出

非运行时异常是除了RuntimeException以外的异常，类型上属于Exception类，从程序角度语法角度讲，这些异常必须要进行处理。如果不处理，程序不能通过编译，如IOException，SQLException

try,catch,finally三个语句注意的问题

• 均不能单独使用，三个可以组合使用，组合方式，try…catch…,try…catch…finally,try…finally…,其中catch语句块可以有一个或多个，finally语句最多一个
• 三个语句块中变量的作用域为代码块，分别独立的，不能相互访问的，如果要在三块中都可以访问，就把变量定义在外面
• 多个catch存在时，最多只会匹配其中一个异常类且执行该catch块，而不会再执行其他catch块，且匹配顺序是从上到下的，最多只会匹配一个异常类，也就是说可以一个异常类也不执行
• 先catch捕获的异常类不能重复，且先捕获子类，再捕获父类
• 无论try中语句有没有问题，finally中的语句一定执行，finally为程序提供统一的出口。保证程序状态的统一管理，通常finally中进行资源的关闭清除工作

final定义常量的关键字

finally,异常中总能执行的代码块

finalize()垃圾回收

throws关键字：定义一个方法的时候可以使用throws关键字声明，表明该方法是不处理该异常的，而是交接给调用者处理该异常

如果主方法(main)也使用throws关键字，那么就意味着主方法也不处理异常，最终留给JVM处理

throws可以抛出多个异常，用逗号隔开就行

throws抛出一个子类异常，调用方法调用者可以不必要处理该异常

throw关键字(自定义异常)

可以抛出异常，抛出的是一个异常类，自己定义异常类，即new

throw与throws的区别

throws

• 用在方法声明后面，跟着的是异常类名
• 可以跟多个异常类，用逗号隔开
• 表示抛出异常，由该方法的调用者处理，throws表示异常的一种可能性，并不是一定发生异常

throw

• 用在方法体内，跟着异常对象
• 只能抛一个异常对象
• 表示抛出对象，有该方法体内语句处理
• throw抛异常是一定会发生异常，并不是可能

—————————————————————

Java双端队列Deque(接口)方法学习

支持两端元素的插入与删除的线性集合，没有数量的具体限制

此接口拓展了Queue接口，当使用deque作为队列时，(FIFO)先进先出行为的结果，元素将添加到deque队列的最后，并从头开始删除，也可作为(LIFO)后进先出的堆栈,且优先于Stack类，

请注意，当使用deque作为队列或堆栈时， peek方法同样适用; 与List接口不同，此接口不支持索引访问元素，此接口可以插入空值

具体方法如下：

E表示deque里面的元素

最后

以上就是温婉流沙为你收集整理的Deque详解—————————————————————的全部内容，希望文章能够帮你解决Deque详解—————————————————————所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。