Java面向对象基础

面向对象和面向过程的区别

• 面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。
• 面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。

单一职责

一个对象应该只有一个职责，并且该职责被完整地封装在一个类中。

如果一个类承载的功能越多，它的耦合性越高（当类的某个职责改变，可能会引起同类中其他职责的变化），
被复用的可能性越低。

实例化和初始化

实例化时通过 new 关键字创建一个对象实例，对象实例存在于堆内存

初始化是指，把一个具体的值赋给变量

对象实体与对象引用有何不同?

new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。

对象的相等和引用相等的区别

• 对象的相等一般比较的是内存中存放的内容是否相等。
• 引用相等一般比较的是他们指向的内存地址是否相等。

类的构造方法的作用是什么?

构造方法是一种特殊的方法，主要作用是完成对象的初始化工作

构造方法不允许被重写，可以被重载

静态成员变量与成员变量

在jdk8之前，静态成员（即静态变量和静态方法）都是存储在方法区中。

在jdk8开始，静态成员放在了堆中。

而成员变量属于对象实例，几乎所有的对象实例都放在堆中

封装

• 将对象的某些信息隐藏在对象的内部，不允许外部直接访问
• 通过该类提供的方法来实现对隐藏信息的操作和访问
• 在隐藏对象信息的同时，留出访问的接口

继承

• 继承是使用 已存在的类的定义 作为基础，去创建一个新的类
• 使用 extends 关键字实现继承，Java中的类只允许继承一个类
• 子类可以访问父类的非私有成员
• 子类方法名可以跟父类方法名相同，属于方法重写；子类可以拥有和父类相同的成员属性
• 在调用子类构造之前会先调用父类构造，默认调用无参构造

多态

• 一个对象具有多种的状态，具体表现为父类的引用指向子类的实例
• 对象类型和引用类型之间具有继承（类）/实现（接口）的关系
• 引用类型变量发出的方法调用到底是哪个类中的方法，必须在程序运行期间才能确定

多态中的向上转型与向下转型

• 向上转型：父类引用指向子类实例，是自动类型转换
• 向下转型：子类引用指向父类实例，也是强制类型转换
• instanceof 运算符：判断对象是否满足类的特征，返回 true/false

if(dog instanceof Dog){
  //...
}

this、super关键字

• this 是当前对象的引用，this 可以调用当前类型中 允许被访问的 成员变量、成员方法，this() 表示无参构造
• super 是父类引用，可以调用父类中 允许被访问的 父类方法、属性
• this 不能在静态方法中使用，原因是 静态方法不能调用非静态成员

final关键字

总的来说，final提高了性能，但降低了可拓展性

• final + 类 此类不能被继承
• final + 方法 此方法不能被子类重写，可以被子类使用，final不能修饰构造方法
• final + 局部变量 此变量不可修改，即常量
• final + 成员变量，final修饰的变量必须初始化一个值，可以在构造方法中赋值，也可以在构造代码块中赋值
• final修饰的基本数据类型是常量，final修饰的引用数据类型，地址不能改变，属性值可以改变

Object

Object是所有类的父类，所有类都可以使用Object中的方法，包括数组

== 和 equals() 的区别

• 对于基本数据类型来说，== 比较的是值。

• 对于引用数据类型来说，== 比较的是对象的内存地址。

  Java 只有值传递，所以，对于 == 来说，不管是比较基本数据类型，还是引用数据类型，本质上比较的都是值，只是引用类型存的值是对象的地址

  equals() 方法默认比较的是对象地址，与 == 作用相同

Object常用方法

/**
 * native 方法，用于返回当前运行时对象的 Class 对象，使用了 final 关键字修饰，故不允许子类重写。
 */
public final native Class<?> getClass()
/**
 * native 方法，用于返回对象的哈希码，主要使用在哈希表中，比如 JDK 中的HashMap。
 */
public native int hashCode()
/**
 * 用于比较 2 个对象的内存地址是否相等，String 类对该方法进行了重写以用于比较字符串的值是否相等。
 */
public boolean equals(Object obj)
/**
 * naitive 方法，用于创建并返回当前对象的一份拷贝。
 */
protected native Object clone() throws CloneNotSupportedException
/**
 * 返回类的名字实例的哈希码的 16 进制的字符串。建议 Object 所有的子类都重写这个方法。
 */
public String toString()
/**
 * native 方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。
 */
public final native void notify()
/**
 * native 方法，并且不能重写。跟 notify 一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。
 */
public final native void notifyAll()
/**
 * native方法，并且不能重写。暂停线程的执行。注意：sleep 方法没有释放锁，而 wait 方法释放了锁 ，timeout 是等待时间。
 */
public final native void wait(long timeout) throws InterruptedException
/**
 * 多了 nanos 参数，这个参数表示额外时间（以毫微秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 毫秒。。
 */
public final void wait(long timeout, int nanos) throws InterruptedException
/**
 * 跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念
 */
public final void wait() throws InterruptedException
/**
 * 实例被垃圾回收器回收的时候触发的操作
 */
protected void finalize() throws Throwable

抽象类

• 通过 abstract 关键字定义一个抽象类，可以避免父类无意义的实例化，实现代码的复用
• 抽象类不能被实例化，可以包含抽象方法，可以有自己的实现
• 子类中必须重写父类的抽象方法，否则子类必须是抽象类

抽象类应用场景

某个父类只是知道子类应该包含怎样的方法，但无法确切的知道子类方法的实现方式，实现方式可以有很多种

接口

• 对类的行为进行约束，实现了某个接口就具有了对应的行为
• 不能被实例化，可以包含抽象方法，可以有自己的实现（default关键字）
• 当类实现接口时，必须实现接口中的所有抽象方法，否则必须将类设置为抽象类
• 接口中的方法默认是 public，接口中的常量默认是 public static final
• 使用 default 关键字可以让接口方法有自己的实现，实现类中调用带 default 的方法必须用 (接口名).super.(方法名)
• 接口中的 static 静态方法也可以有方法体，static 方法不能被重写

抽象类和接口的区别

共同点

• 不可以被实例化，可以包含抽象方法，可以有自己的实现

区别

• 接口对类的行为进行约束；抽象类的应用场景是，父类只是知道子类应该有什么方法，但是不知道具体的实现逻辑，实现方式可以有很多种。

• 一个类只能继承一个类，但是可以实现多个接口

• 接口中的成员变量只能是 public static final 类型的，不能被修改且必须有初始值；而抽象类的成员变量与类的成员变量一样