【软件构造】课件精译（八）面向对象编程

最新推荐文章于 2021-07-01 18:58:34 发布

Swocky

最新推荐文章于 2021-07-01 18:58:34 发布

阅读量367

点赞数 1

分类专栏：软件构造软件构造课件精译文章标签： OOP ADT 面向对象 Java

本文链接：https://blog.csdn.net/Swocky/article/details/88835703

版权

软件构造同时被 2 个专栏收录

25 篇文章 6 订阅

订阅专栏

软件构造课件精译

23 篇文章 10 订阅

订阅专栏

一、面向对象的标准

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

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

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

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

三、接口

接口
Java中的接口是一系列方法签名而没有方法体，若要继承接口，需要实现其方法。
一个接口可以扩展其他接口，一个类可以实现多个接口。
接口没有构造方法、属性或者具体实现。
接口和实现
举例：
在这里插入图片描述

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

通过空的private方法就可以做到避免直接new得到对象。接口不能有构造方法，所以创建对象时需要调用某个具体实现的构造方法。
使用静态工厂而不是构造器
Java 8中，允许接口包含静态方法。这种方法是对实现的完全隐藏，而是否完全隐藏实现需要进行权衡。
在这里插入图片描述
接口的优势
调用者理解ADT时只需要理解接口即可
调用者不能在 ADT的表示上创建无意的依赖
不同实现可以在不同的类中
抽象数据类型的多个不同表示可以共存于同一个程序中，作为实现接口的不同类
为什么需要多种实现
可以提供多种性能表现，更好的适应具体情况，选择用户需要的实现。通常，性能和行为都会改变，例如HashSet和TreeSet。
接口小结
有助于编译器帮助检查ADT实现中的bug，也有助于用户脱离代码理解方法，可以根据需求选择合适的实现，实现性能的折中。ADT的规格说明中，对方法的实现未明确指定，为实现提供了自由，可以有多种方式实现。一个类可以实现多个接口，展现多个视图，是对Java不支持多继承的一种补偿。通过对多个实现在性能和bug free方面的比较，进行实现的选择。

四、封装和信息隐藏

信息隐藏
内部数据和实现细节的隐藏程度是模块化设计质量评价的最重要标准。好的设计API同实现分离，模块间只通过API通讯，对其他模块的内部实现一无所知。
信息隐藏的好处
分离组成系统的类，加速系统开发（允许类同时开始，减小依赖），更利于维护，有效地进行性能调整，提高软件的可复用性
使用接口进行信息隐藏
使用接口类型声明变量
客户端只能使用接口方法
无法从客户端代码访问的字段
成员的可见修饰符
在这里插入图片描述
信息隐藏最好的做法
可以在不妨碍调用者的情况下，在后期将私有变为公有，但不能进行相反操作，会破坏调用者的使用。

五、继承和重写

继承
继承是为了代码复用。
在这里插入图片描述

（1）覆盖/重写

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

含有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：一个函数作用于几个不同的类型（可能不显示一个共同的结构）并且可能以不同的方式对每个类型进行操作。
重载：重载是指在一个类中存在多个同名函数，必须具有不同的参数列表，返回值类型可同可不同。重载为调用者带来了方便(便于记忆同类方法的名字) 。重载是一种静态的多态，通过参数列表决定依赖哪个实现，在编译时决定调用哪个方法。
重载规则
必须改变参数列表
可以改变返回值类型
可以改变访问修饰符
可以进行新的或更广泛的异常检查
对某个方法的重载可以在一个类中进行，也可以在子类中进行。此时需要注意同重写的区别：如果父类和子类中两个方法的签名相同，则为重写；名称一样，参数列表不一样时，则为重载。
合法重载
调用重载方法
在这里插入图片描述
可以看到，左侧定义为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 (泛型)”的概念。
泛型编程是一种编程风格，其中数据类型和函数是根据待指定的类型编写的，随后在需要时根据参数提供的特定类型进行实例化。
泛型编程围绕“从具体进行抽象”的思想，将采用不同数据表示的算法进行抽象，得到范型化的算法，可以得到复用性、通用性更强的软件。
C++中的模板
在这里插入图片描述
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);
	}
}

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

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

泛型方法

public <T> T genericMethod(Class<T> tClass) { 
	T instance = tClass.newInstance(); return instance; 
}

注：泛型类/接口，是在实例化类的时候指明泛型的具体类型（类型擦除）；
泛型方法，是在调用方法的时候指明泛型的具体类型。
普通类中的泛型方法

public class GenericTest { 
	public void normalMethod(…){ …}
	
	public <T> T genericMethod(…){ 
		T var; 
		….; 
	}
}

泛型类中的泛型方法

class GenerateTest<T>{ 
	//下面的T同所在类的类型变量一致，show1不是范型方法 
	public void show1(T t){ 
		System.out.println(t.toString()); 
	}
	
	//下面的E是新的类型变量，只适用于此方法，show2是范型方法 
	public <E> void show2(E t){
	 	System.out.println(t.toString()); 
	}
	
	//下面的T是新的类型变量，同类的类型变量无关（即使名字一样） 
	//show3是范型方法 
	public <T> void show3(T t){ 
		System.out.println(t.toString()); 
	}
}

可以看到，show3虽然也有T，事实上会覆盖类中的T。
静态方法不能使用所在泛型类定义的范型变量。如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法。

/** 
* Create an empty graph. 
* @param <L> type of vertex labels in the graph, must be immutable 
* @return a new empty weighted directed graph 
*/ 
	public static <L> Graph<L> empty() {
	 	…… 
	}

一些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，会带来类型不安全。
行为子类型
（具体在后面的章节讨论

七、动态分派

决定在运行时一个具有多态的操作，哪个具体实现被选择执行。

举例
在这里插入图片描述
父类变量赋值为子类，执行方法时会动态选择具体的方法。
为了更好的测试，我写了一个小demo

public class Main {

    public static void main(String[] args) {
        Father father = new Father();
        Child child = new Child();
        father.speak();
        child.speak();
        father = child;
        father.speak();
    }
}

class Father{
    Father(){
        System.out.println("I'm father");
    }

    void speak(){
        System.out.println("Father speaks");
    }
}

class Child extends Father{
    Child(){
        System.out.println("I'm child");
    }

    void speak(){
        System.out.println("child speaks");
    }
}

结果如下：

I'm father
I'm father
I'm child
Father speaks
child speaks
child speaks

可以看到，子类方法实例化的时候会首先调用父类的构造函数，然后是自己的，如果子类不写构造函数那么只会调用父类的构造方法。然后，当把子类赋值给父类后，会动态调用子类的方法。

八、委托和复合

（5.2节中讨论）

九、Java中的一些重要Object方法

toString()如果需要输出通常需要重写。
equals()和hashCode()当需要通过value相关信息判定相等时，需要重写。

十、回忆：可变与不可变类（和防御性拷贝）

（具体查看之前的PPT
可变类型通常存在一个具备复制功能的构造方法称为clone，区分与copy，具体解释如下：

java创建对象的方式有以下两种：
（1）使用new操作符创建一个对象
（2）使用clone的方法复制一个对象，（在Java中，clone是Object类的protected方法）
这两种对象创建方法有什么区别？
new操作时，首先根据new后面的类型（知道类型才能判断需要分配多大的内存空间）分配内存空间（此时分配到的内存空间相当于产生了一个新的对象，只是还有初始化），分配完内存空间后，在调用构造函数，初始化对象（填充对象的各个域的值）。构造方法返回后，一个对象创建完毕，可以把它的引用发布到外面，可以根据这个引用操作这个对象。
clone方法拷贝对象的第一步与new操作类似，都是分配内存，调用clone方法时，分配的内存和源对象（即调用的clone方法的对象）相同，然后再使用源对象中对应的各个域，填充新对象域，填充完成后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。

另外，防止表示泄露的重点是审视参数和返回值是否可变，有需要则进行防御性拷贝。如果想实现不可变类，那么不要提供任何mutator方法，确保没有方法能够被重写，所有的字段都设置为final private，并且确保可变组件的安全性。

十一、OOP的历史

Swocky

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【软件构造】课件精译（八）面向对象编程

一、面向对象的标准OOP以类为核心概念二、基本概念：对象、类、属性、方法和接口类举例：类的静态、实例变量/方法类变量（静态变量）和静态方法与类有关而不是实例。不同于静态变量和静态方法，实例变量与实例方法每个实例都会触发。另外，静态方法无法调用非静态成员（方法和变量）。三、接口接口Java中的接口是一系列方法签名而没有方法体，若要继承接口，需要实现其方法。一个接口可以扩展其...
复制链接

扫一扫

专栏目录