Day1| Java基础 | 1 面向对象特性

基础补充版

---

Java中的开闭原则

Open-Closed Principle, OCP：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。

这意味着，当需求变化时，应该通过添加新的代码（扩展）来满足，而不是修改现有的代码（特别是那些已经经过验证并投入使用的代码）。

一些实现开闭原则的方法：抽象化（接口或抽象类）、策略模式、装饰器模式、工厂方法/抽象工厂、使用配置而非硬编码、依赖注入、模板方法。（具体不展开）

SOLID原则

• 单一职责（Single Responsibility），类或者对象最好是只有单一职责，在程序设计中如果发现某个类承担着多种义务，可以考虑进行拆分。
• 开关原则（Open-Close, Open for extension, close for modification），设计要对扩展开放，对修改关闭。换句话说，程序设计应保证平滑的扩展性，尽量避免因为新增同类功能而修改已有实现，这样可以少产出些回归（regression）问题。
• 里氏替换（Liskov Substitution），这是面向对象的基本要素之一，进行继承关系抽象时，凡是可以用父类或者基类的地方，都可以用子类替换。
• 接口分离（Interface Segregation），我们在进行类和接口设计时，如果在一个接口里定义了太多方法，其子类很可能面临两难，就是只有部分方法对它是有意义的，这就破坏了程序的内聚性。对于这种情况，可以通过拆分成功能单一的多个接口，将行为进行解耦。在未来维护中，如果某个接口设计有变，不会对使用其他接口的子类构成影响。
• 依赖反转（Dependency Inversion），实体应该依赖于抽象而不是实现。也就是说高层次模块，不应该依赖于低层次模块，而是应该基于抽象。实践这一原则是保证产品代码之间适当耦合度的法宝。

面向对象

面向对象特性简介：

封装：利用抽象将数据和基于数据的操作封装在一起，使其构成一个不可分割的实体。把一个对象的属性私有化，对外提供接口以访问该对象。有4大好处：

• 良好的封装能够减少耦合

• 类内部的结构可以自由修改

  例如将某一属性的数据类型由int改为String，只需要稍微改动接口方法（内部实现），而无需修改使用了该类的代码。

• 可以对成员进行更精确的控制

• 隐藏信息，实现细节

继承：子类继承父类的属性和方法，使子类对象（实例）具有父类的属性和方法；或子类从父类继承方法，使得子类具有父类相同的方法。分为两类：

• 单继承：一个子类只拥有一个父类。
  • 优点：在类层次结构上比较清晰
  • 缺点：结构的丰富度有时不能满足使用需求
• 多继承：一个子类拥有多个直接的父类。
  • 优点：子类的丰富度很高
  • 缺点：容易造成混乱

多态：同一个类的对象在不同情况下表现出来的不同行为和状态。（即，同一个行为具有不同的表现形式）

• 目的：提高代码的灵活性和可扩展性，使得代码更容易维护和扩展。
• 前提条件有三个：
  • 子类继承父类
  • 子类重写父类的方法
  • 父类引用指向子类的对象

理解：

• 子类可以继承父类的字段和方法，子类对象可以直接使用父类中的字段和方法（非私有）
• 子类可以重写父类的方法，从而子类对象调用该方法时表现出不同的行为
• 将子类对象赋给父类类型的引用，从而通过父类类型的引用调用子类中重写的方法，实现多态

继承

实现继承

extends关键字、implements关键字（可以变相实现多继承的效果）

// 1.
class 子类名 extends 父类名{}
// 2.
class 子类名 implements 接口1,接口2{@override //必须重写接口内的方法public void 方法(){……}
}

子类抛出的异常必须是父类抛出的异常，或，父类抛出的异常的子异常。

this和super关键字

// this表示当前对象，是指向自己的引用
this.属性 // 调用成员变量，（区别于局部变量）
this.方法() // 调用本类的某个方法
this() // 表示调用本类构造方法
// super表示父类对象，是指向父类的引用
super.属性 // 父类对象中的成员变量
super.方法() // 父类对象中定义的方法
super() // 【调用】父类的构造方法

父类的构造方法不能被继承，子类的构造过程必须调用父类的构造方法。

修饰符

用来定义类、方法或变量。分两类：

• 访问权限修饰符：public、protected、private、default等
  • 用来控制访问权限。
  • Java子类重写继承的方法时，不可以降低方法的访问权限，访问修饰符的作用域不能比父类的小。所以在继承中需要重写的方法不能用private修饰。
• 非访问修饰符：static、final、abstract等
  • 每个都有各自的作用。
  • static 静态/类变量、静态/类方法： 可以直接通过类访问，不需要创建一个类的对象来访问成员。
    • 构造方法不允许被声明为static
    • 静态方法中不存在当前对象，因此不能用this和super
    • 静态方法能被静态方法重写，不能被非静态方法重写
  • final：final变量必须显示指定初始值，一旦赋值后，不能被重新赋值。父类中的final方法可以被子类继承，但不能被重写。final类不能被继承。
  • abstract 抽象类/方法：有抽象方法的类必须是抽象类，指可以表达概念但无法构造实体。抽象方法指可以表达概念但无法具体实现（只能抽取声明，没有具体的方法体）。

Object类和转型

Object类：所有类的根类，是最抽象的一个类。java.lang.Object。

• 所有的类都隐式的继承自Object类。任何类都可以可以使用Object类的方法，创建的类也可以和Object类进行向上、向下转型。
• Java中，所有的对象都拥有Object的默认方法。如，toString()返回该对象的字符串、equals()比较两个对象是否相等、hashCode()、wait()、notify()、getClass()等
• 该类有一个构造方法，并且是无参构造方法。

子父类初始化顺序

在Java继承中，初始化先后顺序为：

1. 父类中静态成员变量和静态代码块
2. 子类中静态成员变量和静态代码块
3. 父类中普通成员变量和代码块，父类的构造方法
4. 子类中普通成员变量和代码块，子类的构造方法
   静态>非静态、父类>子类、非构造方法>构造方法

理解：

• 静态变量也称类变量，可以看成一个全局变量。静态成员变量和静态代码块在类加载的时候就初始化，而非静态变量和代码块在对象创建的时候初始化。∴静态>非静态。
• 调用构造方法时，是对成员变量进行初始化操作。∴普通成员变量和代码块>构造方法。

多态

一个简单应用

在运行时根据对象的的类型进行后期绑定，能使编译器在只有一个Wanger引用的情况下，知道应该调用父类的write方法还是子类的write方法。虽然编译器在编译阶段并不知道对象的类型，但是Java的方法调用机制能找到正确的方法体并执行。

多态的一个简单应用（多态使程序具有良好的可扩展性，能使我们将改变的与未改变的分离开来。例如在子类中添加eat()方法，也不会影响write()的调用）：

//子类继承父类
public class Wangxiaoer extends Wanger {public void write() { // 子类覆盖父类方法System.out.println("记住仇恨，表明我们要奋发图强的心智");}public void eat() {System.out.println("我不喜欢读书，我就喜欢吃");}public static void main(String[] args) {// 父类引用指向子类对象Wanger[] wangers = { new Wanger(), new Wangxiaoer() };for (Wanger wanger : wangers) {// 对象是王二的时候输出：勿忘国耻// 对象是王小二的时候输出：记住仇恨，表明我们要奋发图强的心智wanger.write();}}
}class Wanger {public void write() {System.out.println("勿忘国耻");}public void read() {System.out.println("每周读一本好书");}
}

在构造方法中调用多态方法

在创建子类对象时，会先去调用父类的构造方法。而父类构造方法中又调用了被子类覆盖的多态方法。由于父类并不清楚子类对象中的字段值是什么，于是把 int 类型的属性暂时初始化为0。最后，再调用子类的构造方法。子类构造方法知道age的值是4。

public class Wangxiaosan extends Wangsan {private int age = 3;public Wangxiaosan(int age) {this.age = age;System.out.println("王小三的年龄：" + this.age);}public void write() { // 子类覆盖父类方法System.out.println("我小三上幼儿园的年龄是：" + this.age);}public static void main(String[] args) {new Wangxiaosan(4);
//      上幼儿园之前
//      我小三上幼儿园的年龄是：0
//      上幼儿园之后
//      王小三的年龄：4}
}class Wangsan {Wangsan () {System.out.println("上幼儿园之前");write();System.out.println("上幼儿园之后");}public void write() {System.out.println("老子上幼儿园的年龄是3岁半");}
}

多态与向下转型

向下转型是指将父类引用强转为子类类型。这是不安全的：

• 若父类引用指向的是父类对象：类型转换失败。抛出ClassCastException。
• 若父类引用指向的是子类对象：向下转型成功。

public class Wangxiaosi extends Wangsi {public void write() {System.out.println("记住仇恨，表明我们要奋发图强的心智");}public void eat() {System.out.println("我不喜欢读书，我就喜欢吃");}public static void main(String[] args) {Wangsi[] wangsis = { new Wangsi(), new Wangxiaosi() };// wangsis[1]能够向下转型((Wangxiaosi) wangsis[1]).write();// wangsis[0]不能向下转型((Wangxiaosi)wangsis[0]).write();}
}class Wangsi {public void write() {System.out.println("勿忘国耻");}public void read() {System.out.println("每周读一本好书");}
}

另一个实例：

问题回答版

---

面向对象

面向对象的三大特性是什么？

1. 封装
   是对类的属性和方法进行封装，只对外暴露方法而不暴露具体使用细节。∴我们一般设计类成员变量的时候，大多设为私有，然后通过一些get、set方法去读写。
2. 继承
   子类继承父类，“子承父业”。子类拥有父类除私有外的所有属性和方法，自己还能在此基础上拓展自己新的属性和方法。主要目的是复用代码。
3. 多态
   是同一个行为具有不同表现形式或形态的能力。也就是说，一个父类可能有若干子类，各子类实现的父类方法多种多样。调用父类方法时，父类引用变量指向不同子类实例，从而执行不同方法。这样就称这个父类方法是多态的。
   

多态特性你是怎么理解？

多态，Polymorphism，字面意思“多种状态”。在面向对象语言中，指接口的多种不同的实现方式。用白话说，就是多个对象调用同一个方法，得到不同的结果。

语法格式：父类类名 引用名称 = new 子类类名()

当是多态时，该引用名称只能访问父类中的属性和方法，但是访问的时候，会优先访问子类重写以后的方法。

满足多态需要三个条件：子类必须继承父类、子类必须重写父类的方法、父类引用指向子类对象。

使用多态，可以使代码之间的耦合度（关联程度）降低，减少冗余代码的同时，提高项目的扩展能力。

Java 多态中，有两种类型转换，

• 向上转型：自动类型转换，子类型赋值给父类型，构成多态（）
• 向下转型：强制类型转换，父类型赋值给子类型。当使用多态、并访问子类独有的属性或方法时，必须进行向下转型。（先使用instance of关键字判断该对象合法性，即是否属于某一个类或其子类的实例）

具体过程

• 编译阶段：编译器首先检查父类中是否有该方法，如果没有，则编译错误java.lang.ClassCastException。如果有，（引用名称绑定的是父类中的方法，Java多态的静态绑定）
• 运行阶段：再去调用子类重写后的方法（引用名称绑定的是子类中的方法，Java多态的动态绑定）

参考链接

什么是向上转型和向下转型？

向上转型：通过子类对象（小范围）实例化父类对象（大范围），属于自动转换。Father f = new Son()，父类引用变量指向子类对象后，只能使用父类已声明的方法，但方法如果被重写会执行子类的方法，如果方法未被重写将执行父类的方法。

向下转型：通过父类对象（大范围）实例化子类对象（小范围），属于强制转换。Son s = (Son)f，但父类引用变量实际引用必须是子类对象才能成功转型。子类引用变量指向父类引用变量指向的对象后（一个Son()对象），就可以调用一些子类特有而父类没有的方法。

案例：

Object object=new Integer(666);//向上转型Integer i=(Integer)object;//向下转型Object->Integer，object的实质还是指向IntegerString str=(String)object;//错误的向下转型，虽然编译器不会报错但是运行会报错

Java可以多继承吗？为什么只能单继承？

不能，Java语言在设计时考虑到类层次的复杂性及其实际意义禁止了多继承，但可以通过内部类、多层继承或实现接口的方式达到多继承的目的。

参考链接

Java实现多继承效果的方式有三种：

• 内部类：可以继承一个与外部无关的类，保证了内部类的独立性。在类中分别继承多个内部类，以达到多继承的效果。
• 多层继承：子类继承父类，父类还继承其他类。这样子类就能拥有所有被继承类的属性和方法。
• 实现接口：接口可以看作是一组方法。

抽象类和接口

接口和抽象类有什么区别？

接口类和抽象类是Java面向对象设计的两个基础机制。

接口是对行为的抽象，是抽象方法的集合。利用接口可以达到API定义和实现分离的目的。接口不能实例化，不能包含任何非常量成员，任何filed都是隐藏着public static final的意义；同时，没有非静态方法实现，也就是说，要么是抽象方法，要么是静态方法。Java标准库中，定义了非常多的接口，比如java.util.List。实现接口，使用implements关键词。

抽象类是不能实例化的类，用abstract关键字修饰class，目的主要是代码重用。除了不能实例化，形式上和一般的Java类并没有太大区别，可以有一个或者多个抽象方法，也可以没有抽象方法。抽象类大多用于抽取相关Java类的共用方法实现，或者是共同成员变量，然后通过继承的方式达到代码复用的目的。Java标准库中，比如collection框架，很多用用部分就被抽取成为抽象类，例如java.util.AbstractList。继承抽象类，使用extends关键词。

参考Java标准库中的ArrayList。

 public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//...
}

方法重写和重载

方法重写和重载有什么区别？

• 方法重写 override：子类中出现和父类一模一样的方法（包括方法名、参数书列表、返回值类型）。外壳不变，核心内容重写。
• 方法重载 overload：在一个类中定义了多个方法名相同，但参数的数量、次序或类型不一致不同的方法。

方法重写是子类与父类的一种多态性表现，而方法重载是一个类的多态性表现。

方法重载的好处就是让类以统一的方式处理不同类型的一种手段，调用方法时通过传递给他们的不同个数和类型的参数来决定具体使用哪个方法，这就是多态性。

内部类

为什么需要内部类？什么是匿名内部类？

• 接口和内部类提供了一种将接口与实现分离的更加结构化的方法：由于内部类拥有对其外部类的所有成员的访问权，因此可以隐藏实现的细节。

每个内部类都能独立地继承自一个（接口的）实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响。

• 内部类有效地实现了“多重继承”：内部类允许继承多个非接口类型（译注：类或抽象类）。

匿名内部类是局部内部类的一种简要写法，可以在不声明的情况下，继承其它类并创建对象。

局部内部类是定义在方法里面的内部类。对外来说，只有该方法内能调用局部内部类。对内来说，局部内部类可以任意访问该方法内的局部变量。

静态内部类和非静态内部类有什么区别？

-	静态内部类	非静态内部类
访问权限	四种：public、protected、default、private	三种：public、protected、default
实例化	可以直接通过类名访问，不依赖于外部类的实例	只能在外部类的实例方法中创建，必须依赖于外部类的实例
关系	只是被包含在外部类中，与外部类没有任何联系	可以访问外部类的成员和方法，可以使用外部类的引用来访问外部类的成员
应用场景	不需要访问外部类实例的情况下使用，例如实现一些独立的功能	需要访问外部类实例的情况下使用，例如实现一个事件监听器

静态内部类的使用场景是什么？

参见上一题。