软件构造课程随笔——3-4【面向对象编程】

最新推荐文章于 2024-10-16 10:13:45 发布

丿AnGel灬翼丶族

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量262

点赞数

分类专栏：软件构造课程随笔文章标签： java

本文链接：https://blog.csdn.net/wangwsibo/article/details/106344640

版权

软件构造课程随笔专栏收录该内容

18 篇文章 1 订阅

订阅专栏

一、面向对象的标准

OOP以类为核心概念，通过ADT实现。
静态类型（定义良好的类型系统应该通过执行一些类型声明和兼容性规则来保证它所接受的系统的运行时类型安全），“易于改变”“为重用设计”（编写通用类），继承，多态性，动态调度/绑定。

二、基本概念：对象、类、属性、方法

对象
识别现实世界中事物的状态和行为，是开始OOP的好方法。观察对象有哪些状态，有哪些行为。
类
每个对象都有一个类，类定义了类型和实现， API 类的方法就是其应用程序接口
举例：
在这里插入图片描述

类的静态、实例变量/方法
类变量（静态变量）和静态方法与类有关而不是实例。不同于静态变量和静态方法，实例变量与实例方法每个实例都会触发。
另外，静态方法无法调用非静态成员（方法和变量）。
在这里插入图片描述

三、接口

Java中的interface（接口）是一种表示抽象数据类型的好方法。接口中是一连串的方法标识，但是没有方法体（定义）。如果想要写一个类来实现接口，我们必须给类加上implements关键字，并且在类内部提供接口中方法的定义。所以接口+实现类也是Java中定义抽象数据类型的一种方法。

这种做法的一个优点就是接口只为使用者提供“契约”（contract），而使用者只需要读懂这个接口即可使用该ADT，他也不需要依赖ADT特定的实现/表示，因为实例化的变量不能放在接口中（具体实现被分离在另外的类中）。

接口的另一个优点就是它允许了一种抽象类型能够有多种实现/表示，即一个接口可以有多个实现类。而当一个类型只用一个类来实现时，我们很难改变它的内部表示。例如之前阅读中的 MyString 这个例子，我们对 MyString 实现了两种表示方法，但是这两个类就不能同时存在于一个程序中。

Java的静态检查会发现没有实现接口的错误，例如，如果程序员忘记实现接口中的某一个方法或者返回了一个错误的类型，编译器就会在编译期报错。不幸的是，编译器不会去检查我们的方法是否遵循了接口中的文档注释。

接口举例：
在这里插入图片描述

可以看到，同一个接口不同的实现体现了多态性，并且降低了对实现的依赖。例如Set< Stirng > a = new HashSet<>();

接口vs类
接口：确定 ADT 规约；类：实现 ADT
也可以不需要接口直接使用类作为 ADT ，既有 ADT 定义也有 ADT 实现
实际中更倾向于使用接口来定义变量

为什么多种实现？
1、不同的性能–选择最适合您的使用的实现
2、不同的行为–选择所需的实现–行为必须符合接口规范（“合同”）
3、性能和行为通常都不同–提供功能性能折衷–示例：哈希集

产生的问题：
打破了抽象边界，接口定义中没有包含 constructor ，也无法保证所有实现
类中都包含了同样名字的 constructor 。
故而，客户端需要知道该接口的某个具体实现类的名字

使用静态工厂而不是构造器
Java 8中，允许接口包含静态方法。这种方法是对实现的完全隐藏，而是否完全隐藏实现需要进行权衡。
在这里插入图片描述
接口的优势
调用者理解ADT时只需要理解接口即可
调用者不能在 ADT的表示上创建无意的依赖
不同实现可以在不同的类中
抽象数据类型的多个不同表示可以共存于同一个程序中，作为实现接口的不同类

为什么需要多种实现
可以提供多种性能表现，更好的适应具体情况，选择用户需要的实现。通常，性能和行为都会改变，例如HashSet和TreeSet。

接口小结
有助于编译器帮助检查ADT实现中的bug，也有助于用户脱离代码理解方法，可以根据需求选择合适的实现，实现性能的折中。ADT的规格说明中，对方法的实现未明确指定，为实现提供了自由，可以有多种方式实现。一个类可以实现多个接口，展现多个视图，是对Java不支持多继承的一种补偿。通过对多个实现在性能和bug free方面的比较，进行实现的选择。

四、封装和信息隐藏

信息隐藏
内部数据和实现细节的隐藏程度是模块化设计质量评价的最重要标准。好的设计API同实现分离，模块间只通过API通讯，对其他模块的内部实现一无所知。
信息隐藏的好处
分离组成系统的类，加速系统开发（允许类同时开始，减小依赖），更利于维护，有效地进行性能调整，提高软件的可复用性
使用接口进行信息隐藏
使用接口类型声明变量
客户端只能使用接口方法
无法从客户端代码访问的字段

成员的可见修饰符
在这里插入图片描述
信息隐藏最好的做法
可以在不妨碍调用者的情况下，在后期将私有变为公有，但不能进行相反操作，会破坏调用者的使用。

五、继承和重写

继承
继承是为了代码复用。
在这里插入图片描述
（1）覆盖/重写
子类可以重新实现父类中的方法，但要有相同的签名。根据调用时的对象类型决定被调用方法的版本，也就是new的时候左侧定义的类型是什么。
严格重写
默认父类中的方法均是可以被重写的，而“严格继承”则只能继承不能重写，这样的方法需要被定义为final。
可重写方法设置为空
例如，某个方法在各个子类中通用性很强，则可以编写具体的方法体，如果各自实现不同或者常常被重写，不如设置方法体为空。而如果想放弃父类的方法，可以通过空方法体来重写父类的方法。
在这里插入图片描述
覆盖/重写
子类中可以通过super关键字调用父类中被重写的方法。

class Thought {
public void message() {
System.out.println("
Thought
}
}
public class Advice extends Thought {
@Override
// @Override annotation in Java 5 is optional but
public void message() {
System.out.println("
Advice.
super.message();
// Invoke parent's version of
}
}
Thought parking = new Thought();
parking.message(); // Prints "
Thought
Thought dates = new Advice();
dates.message(); // Prints Advice in Thought.

在这里插入图片描述
含有this和super的构造函数

可以看到，在子类的构造函数中，可以通过this调用其他重载方法，可以通过super调用父类方法
错误引用重写的示例

final

final field：不允许被重新赋值
final method：不允许被重写
final class：不允许被继承

重写方法的建议
签名保持一致
使用@Override(这样compiler 会检查覆盖方法和被覆盖的方法签名是否完全一致)不允许降低类中权限

（2）抽象类
抽象方法只有定义没有实现，通过abstract进行定义。
抽象类介于接口和类之间，当然，抽象类也不能实例化，继承某个抽象类的子类在实例化时，所有父类中的抽象方法必须已经实现。抽象类可以不包含抽象方法，但包含抽象方法的类一定是抽象类。
在这里插入图片描述
接口不同于抽象类，只有抽象方法。
一种常见的设计方法，抽象类实现接口，具体的类继承抽象类。（Concrete class → Abstract Class → Interface）

六、多态性、子类型和重载

（1）三种多态性的类型
多态性是指为不同类型的实体提供一个接口，或者使用一个符号来表示多个不同的类型。
Ad hoc polymorphism：一个函数可以有多个同名的实现(方法重载)
参数多态性：一个类型名字可以代表多个类型(泛型编程)
子类型：一个变量名字可以代表多个类的实例( 子类型)

（2）Ad hoc polymorphism和重载
Ad hoc polymorphism：一个函数作用于几个不同的类型（可能不显示一个共同的结构）并且可能以不同的方式对每个类型进行操作。
重载：重载是指在一个类中存在多个同名函数，必须具有不同的参数列表，返回值类型可同可不同。重载为调用者带来了方便(便于记忆同类方法的名字) 。重载是一种静态的多态，通过参数列表决定依赖哪个实现，在编译时决定调用哪个方法。
重载规则：
1、必须改变参数列表
2、可以改变返回值类型
3、可以改变访问修饰符
4、可以进行新的或更广泛的异常检查
对某个方法的重载可以在一个类中进行，也可以在子类中进行。此时需要注意同重写的区别：如果父类和子类中两个方法的签名相同，则为重写；名称一样，参数列表不一样时，则为重载。
合法重载
调用重载方法
在这里插入图片描述
可以看到，左侧定义为animal，右侧new Horse，使用的是对应animal的方法。重载是在编译阶段完成，重写于运行时完成。

class Animal { 
	public void eat() {
		System.out.println("I'm an animal. I like eating everything!");
	}
}

class Horse extends Animal {
	public void eat(String food) {
		System.out.println("I'm a horse. I like eating "+ food);
	}
	public void eat() {
		System.out.println(“I‘m a horse. I like eating grass！"
	}
}

为了更好的区分，下面举几个例子：
Animal a = new Animal(); a.eat(); =>I’m an animal. I like eating everything!

Horse h = new Horse(); h.eat();=>I’m a horse. I like eating grass!

Animal ah = new Horse(); ah.eat();=>I’m a horse. I like eating grass! Polymorphism works- the actual object type(Horse), not the reference type(Animal), is used to determine which eat() is called.

Horse he = new Horse(); he.eat(“Apples!”);=>I’m a horse. I like eating Apples! The overloaded eat(String s) method in Horse is invoked.

Animal a2 = new Animal(); a2.eat(“Carrots”);=>Compiler error! Animal class doesn’t have an eat() method that takes a String

Animal ah2 = new Horse(); ah2.eat(“Carrots”);=>Compiler error! Compiler still looks only at the reference, and sees that Animal doesn’t have an eat() method that takes a String.
再看下面这个例子：
在这里插入图片描述
重写与重载
重写使用原签名，而重载与原签名不同。但使用时两者并不冲突，子类重载了父类的方法后，子类仍然继承了被重载的方法。

具体总结一下重载与重写的区别见下面这张表：
在这里插入图片描述
（3）参数多态性与通用编程
参数多态性
参数多态性是指方法针对多种类型时具有同样的行为（这里的多种类型具有通用的结构），此时可使用统一的类型表达多种类型。在运行时根据传入的具体类型确定。
则也就是Java中“Generics (泛型)”的概念。
泛型编程是一种编程风格，其中数据类型和函数是根据待指定的类型编写的，随后在需要时根据参数提供的特定类型进行实例化。
泛型编程围绕“从具体进行抽象”的思想，将采用不同数据表示的算法进行抽象，得到泛型化的算法，可以得到复用性、通用性更强的软件。
在这里插入图片描述
Java中的泛型
举例：

List< Integer > ints = new ArrayList< Integer >(); 
public interface List< E >;
public class Entry<KeyType, ValueType>;

Java中的泛型包括泛型类、泛型接口、泛型方法。类中如果声明了一个或多个范型变量，则为泛型类。这些类型变量称为类的类型参数。

public class PapersJar<T> {
	private List<T> itemList = new ArrayList<>();
	
	public void add(T item) { 
		itemList.add(item); 
	}
	
	public T get(int index) {
		return (T) itemList.get(index); 
	}
	
	public static void main(String args[]) {
		PapersJar<String> papersStr = new PapersJar<>(); 
		papersStr.add("Lion"); String str = papersStr.get(0); 
		System.out.println(str);
		PapersJar<Integer> papersInt = new PapersJar<>(); 
		papersInt.add(new Integer(100)); 
		Integer integerObj = papersInt.get(0); 
		System.out.println(integerObj);
	}
}

注意，泛型中实现与其具体类型无关。
Another example: Java Set
在这里插入图片描述
泛型接口
假如我们想要实现泛型Set< E >接口。
方法一：泛型接口，非泛型实现

方法二：泛型接口，泛型实现

一些Java中泛型的细节
可以有多个类型变量：e.g., Map<E, F>, Map<String, Integer>

通配符：e.g. List<?> or List<? extends Animal> or List<? super Animal>

Java中的范型是不“型变”的：对象存在父子关系，但采用List等不会保持其父子关系
ArrayList< String >是List< String >的子类
List< String >不是List< Object > 的子类
List< String > 是List<? extends Object > 的子类
List< Object >是List<? super String>的子类

泛型信息被擦除：不能使用instanceof来检测泛型
不能创建泛型数组： Pair< String >[] foo = new Pair< String >[42]; // 不会编译

（4）子类多态性
继承和子类
继承是为了代码复用
子类是为了多态性，没有继承同样可以实现子类型，比如接口。即采用同样的方式访问对象，会得到不同的行为。
抽象类是一种方便的混合(介于接口和具体实现类之间。
子类
一个类型代表了一组值，子类型是超类型的子集。
B是A的子类型，当且仅当B的规格说明至少同A的一样强。编译器会检查，确保接口中的所有方法在实现类中均被实现。
但是规格说明的强弱，编译器无法判断。以下的错误行为要避免：
加强方法某些输入的前置条件
削弱后置条件
削弱接口抽象类型对用户的保证
Java中的子类型一定要确保其规格说明不弱于超类型。

子类型多态性
客户端可以对不同类型的对象使用统一的方式进行处理(处理超类型) 。
在这里插入图片描述
类型转换
子类可以替换父类，即向上类型转换，但要避免向下类型转换，容易造成问题。

instanceof
instanceof不是方法，而是操作符，它的作用是判断其左边对象是否为其右边类的实例。除了其本身，其子类也会返回true，所以尽可能避免用instanceof，特别是检查某个对象是否是其子类的对象。除了在equals()方法中，不要使用instanceof，会带来类型不安全。