07 - 面向对象编程（高级部分二）

本文主要是介绍07 - 面向对象编程（高级部分二），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一、final 关键字

基本介绍

final 可以修饰类、属性、方法和局部变量。
在某些情况下，程序员可能有以下需求,就会使用到final:

	1）当不希望类被继承时，可以用final修饰。
	
	2）当不希望父类的某个方法被子类覆盖/重写(override)时，可以用final关键字修饰。
	【语法：访问修饰符 final 返回类型 方法名】
	
	3）当不希望类的的某个属性的值被修改，可以用final修饰。
	【 public final double TAX RATE = 0.08】
	
	4）当不希望某个局部变量被修改，可以使用final修饰【final double TAX RATE = 0.08】

//如果我们要求 hi 不能被子类重写
//可以使用 final 修饰 hi 方法 
public final void hi() {}

//当不希望类的的某个属性的值被修改,可以用 final 修饰
public final double TAX_RATE = 0.08;//常量

//当不希望某个局部变量被修改，可以使用 final 修饰
//这时，NUM 也称为 局部常量
final double NUM = 0.01;

注意事项

1）final修饰的属性又叫常量，一般用XX_XX_XX来命名

2）final修饰的属性在定义时，必须赋初始值，并且以后不能再修改，赋值可以在如下位置之一【选择一个位置赋初值即可】:
	1 - 定义时：如 public final double TAX_RATE = 0.08;
	2 - 在构造器中
	3 - 在代码块中

3）如果 final修饰的属性是静态的，则初始化的位置只能是：
	1 - 定义时赋值
	2 - 在静态代码块，不能在构造器中赋值。

4）final类不能继承，但是可以实例化对象。[A2类]

5）如果类不是 final类，但是含有 final方法，则该方法虽然不能重写，但是可以被继承。[A3类]

package com.spock.final_;

public class FinalDetail01 {
	public static void main(String[] args) {
		CC cc = new CC();
		
		new EE().cal();
	}
}

class AA {
	/*
	1. 定义时：如 public final double TAX_RATE = 0.08;
	2. 在构造器中
	3. 在代码块中
	*/
	public final double TAX_RATE = 0.08;//1.定义时赋值
	public final double TAX_RATE2 ;
	public final double TAX_RATE3 ;
	public AA() {
		//构造器中赋值
		TAX_RATE2 = 1.1;
	}
	
	{
		//在代码块赋值
		TAX_RATE3 = 8.8;
	}
}

class BB {
	/*
	如果 final 修饰的属性是静态的，则初始化的位置只能是
	1 - 定义时赋值 2 - 在静态代码块 不能在构造器中赋值。
	*/
	public static final double TAX_RATE = 99.9; //定义时赋值
	public static final double TAX_RATE2;
	
	static {
		//静态代码块赋值
		TAX_RATE2 = 3.3;
	}
}

//final 类不能继承，但是可以实例化对象
final class CC { }

//如果类不是 final 类，但是含有 final 方法，则该方法虽然不能重写，但是可以被继承
//即，仍然遵守继承的机制
class DD {
	public final void cal() {
		System.out.println("cal()方法");
	}
}

class EE extends DD { }

6）一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

7）final不能修饰构造方法(即构造器)

8）final 和 static 往往搭配使用，效率更高，不会导致类加载。底层编译器做了优化处理。
	class Demo {
		public static final int i = 16;
		static {
			System.out.println("代码块执行，类加载了")
		}
	}

8)包装类（Integer，Double，Float，Boolean等都是final），String也是final类。

二、抽象类

使用抽象类的原因

解决父类方法不确定性的问题
	1 - 考虑将该方法设计为抽象(abstract)方法
	2 - 所谓抽象方法就是没有实现的方法
	3 - 所谓没有实现就是指，没有方法体
	4 - 当一个类中存在抽象方法时，需要将该类声明为 abstract 类
	5 - 一般来说，抽象类会被继承，有其子类来实现抽象方法

小结：
当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。

抽象类快速入门

当父类的一些方法不能确定时，可以用 abstract关键字 来修饰该方法，这个方法就是抽象方法。
用 abstract 来修饰该类就是抽象类。

如何把Animal做成抽象类，并让子类Cat类实现。
	abstract class Animal{
		String name;
		int age;
		abstract public void cry();
	}

抽象类的介绍

1）用 abstract关键字 来修饰一个类时，这个类就叫抽象类。
语法：
	访问修饰符 abstract class 类名 {
	}

2）用 abstract关键字 来修饰一个方法时，这个方法就是抽象方法。
语法：
	访问修饰符 abstract 返回类型 方法名(参数列表); //没有方法体

3）抽象类的价值更多的作用是在于设计，是设计者设计好后，让子类继承并实现抽象类

4）抽象类，是考官比较爱问的知识点,在框架和设计模式使用较多

注意事项

1）抽象类不能被实例化

2）抽象类不一定要包含 abstract方法。也就是说，抽象类可以没有abstract方法
3）一旦类包含了 abstract方法，则这个类必须声明为abstract
4）abstract 只能修饰类和方法，不能修饰属性和其它的东西。

package com.spock.abstract_;

public class AbstractDetail01 {
	public static void main(String[] args) {
		//抽象类，不能被实例化
		new A();//报错
	}
}

//抽象类不一定要包含 abstract 方法。
//也就是说，抽象类可以没有 abstract 方法
//还可以有实现的方法。
abstract class A {
	public void hi() {
		System.out.println("hi");
	}
}

//一旦类包含了 abstract 方法，则这个类必须声明为 abstract
abstract class B {
	public abstract void hi();
}

//abstract 只能修饰类和方法，不能修饰属性和其它的
class C {
	//错误 public abstract int n1 = 1;
}

5）抽象类可以有任意成员【抽象类本质还是类】
	比如:非抽象方法、构造器、静态属性等等

6）抽象方法不能有主体，即不能实现

7）如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法
除非它自己也声明为 abstract类。

8）抽象方法不能使用 private、final 和 static来修饰，因为这些关键字都是和重写相违背的。

package com.spock.abstract_;

public class AbstractDetail02 {
	public static void main(String[] args) {
		System.out.println("hello");
	}
}

//抽象方法不能使用 private、final 和 static 来修饰
//因为这些关键字都是和重写相违背的
abstract class H {
	public abstract void hi();//抽象方法
}

//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法
//除非它自己也声明为 abstract 类
abstract class E {
	public abstract void hi();
}

abstract class F extends E {
}

class G extends E {
	@Override
	public void hi() {
		//这里相等于 G 子类实现了父类 E 的抽象方法
		//所谓实现方法，就是有方法体
	}
}

//抽象类的本质还是类，所以可以有类的各种成员
abstract class D {
	public int n1 = 10;
	public static String name = "抽象类";
	public void hi() {
		System.out.println("hi");
	}
	public abstract void hello();
	
	public static void ok() {
		System.out.println("ok");
	}
}

三、抽象类最佳实践-模板设计模式

基本介绍

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板
子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

模板设计模式能解决的问题

1）当功能内部中一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

2）编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

最佳实践

需求：
1）有多个类，完成不同的任务job
2）要求统计得到各自完成任务的时间
3）请编程实现TestTemplate.java

思路：
1）先用最容易想到的方法 ---> 代码实现
2）分析问题，提出使用模板设计模式

package com.spock.abstract_;

//抽象类-模板设计模式
//模板类
abstract public class Template {
	public abstract void job();  //抽象方法
	
	public void calculateTime() {  //实现方法，调用 job 方法
		//得到开始的时间
		long start = System.currentTimeMillis();

		job(); //动态绑定机制
		//得的结束的时间
		long end = System.currentTimeMillis();
		System.out.println("任务执行时间 " + (end - start));
	}
}



package com.spock.abstract_;

//继承模板类
public class AA extends Template {
	//计算任务
	//1+....+ 800000
	
	@Override
	public void job() { //实现 Template 的抽象方法 job
		long num = 0;
		for (long i = 1; i <= 800000; i++) {
		num += i;
		}
	}
	
	// public void job2() {
	// 		//得到开始的时间
	// 		long start = System.currentTimeMillis();
	// 		long num = 0;

	// 		for (long i = 1; i <= 200000; i++) {
	// 			num += i;
	// 		}
	// 		//得的结束的时间
	// 		long end = System.currentTimeMillis();
	// 		System.out.println("AA 执行时间 " + (end - start));
	// }
}



package com.spock.abstract_;

public class BB extends Template{
	public void job() {//重写了 Template 的 job 方法
		long num = 0;
		for (long i = 1; i <= 80000; i++) {
			num *= i;
		}
	}
}


package com.spock.abstract_;
public class TestTemplate {
	public static void main(String[] args) {
		AA aa = new AA();
		aa.calculateTime(); //这里还是需要有良好的 OOP 基础，对多态
		BB bb = new BB();
		bb.calculateTime();
	}
}

上面就是抽象类—模版设计模式
只需要继承这个抽象类
然后实现job方法，通过动态绑定机制。
就可以得到各自完成的时间。

四、接口

基本介绍

接口就是给出一些没有实现的方法，封装到一起，直到某个类要使用的时候，再根据具体情况把这些方法写出来。

语法:
interface 接口名 {
	//属性
	//抽象方法
}

class 类名 implements 接口 {
	自己属性;
	自己方法;
	必须实现的接口的抽象方法
}

小结：接口是更加抽象的抽象类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体【Jdk7.0】。接口体现了程序设计的多态和高内聚低偶合的设计思想。
特别说明：Jdk8.0 后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

接口快速入门

package com.spock.interface_;

//接口
public interface UsbInterface {
	//规定接口的相关方法
	public void start();
	public void stop();
}

package com.spock.interface_;

//实现接口,就是把接口方法实现
public class Camera implements UsbInterface{
	@Override
	public void start() {
		System.out.println("相机开始工作...");
	}
	
	@Override
	public void stop() {
		System.out.println("相机停止工作....");
	}
}


package com.spock.interface_;

//Phone类 实现 UsbInterface
//解读 1. 即 Phone类需要实现 UsbInterface 接口 规定/声明的方法
public class Phone implements UsbInterface {
	@Override
	public void start() {
		System.out.println("手机开始工作...");
	}
	
	@Override
	public void stop() {
		System.out.println("手机停止工作.....");
	}
}


package com.spock.interface_;

public class Interface01 {
	public static void main(String[] args) {
		//创建手机，相机对象
		//Camera 实现了 UsbInterface
		Camera camera = new Camera();
		
		//Phone 实现了 UsbInterface
		Phone phone = new Phone();
		
		//创建计算机
		Computer computer = new Computer();
	
		computer.work(phone);//把手机接入到计算机
		System.out.println("===============");
		computer.work(camera);//把相机接入到计算机
	}
}

注意事项

1 - 接口不能被实例化

2 - 接口中所有的方法是 public 方法, 接口中抽象方法，可以不用 abstract 修饰
	void aaa();
	实际上是 abstract void aaa();
	void aaa() {}; //错误，不需要花括号
	
3 - 一个普通类实现接口，就必须将该接口的所有方法都实现，可以使用 alt+enter 来解决

4 - 抽象类去实现接口时，可以不实现接口的抽象方法

//1.接口不能被实例化
//2.接口中所有的方法是 public 方法, 接口中抽象方法，可以不用 abstract 修饰 
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用 alt+enter 来解决 
//4.抽象类去实现接口时，可以不实现接口的抽象方法
interface IA {
	void say();//修饰符 public protected 默认 private
  	void hi();
  }

class Cat implements IA{ 
	@Override
	public void say() { }
	
	@Override 
	public void hi() { }
}

//抽象类
//抽象类去实现接口时，可以不实现接口的抽象方法
abstract class Tiger implements IA {}

5 - 一个类同时可以实现多个接口

6 - 接口中的属性，只能是final的，而且是 public static final修饰符。
	比如：int a = 1;
	实际上是 public static final int a=1;(必须初始化)

7 - 接口中属性的访问形式：
	接口名.属性名

8 - 接口不能继承其它的类，但是可以继承多个别的接口
	interface A extends B,C {}

9 - 接口的修饰符只能是 public 和 默认，这点和类的修饰符是一样的。

public class InterfaceDetail02 {
	public static void main(String[] args) {
		//证明 接口中的属性,是 public static final
		System.out.println(IB.n1);
		//说明 n1 就是 static
		//IB.n1 = 30; 说明 n1 是 final
		}
	}
	interface IB {
		//接口中的属性，只能是 final 的，而且是 public static final 修饰符
		int n1 = 10; //等价 public static final int n1 = 10;
	}
	
	interface IC {
		void say();
	}
}

//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {

}

//一个类同时可以实现多个接口
class Pig implements IB,IC {
	@Override
	public void hi() { }
	
	@Override
	public void say() { }
}

实现接口 vs 继承类

package com.spock.interface_;

public class ExtendsVsInterface {
	public static void main(String[] args) {
		LittleMonkey wuKong = new LittleMonkey("悟空");
		wuKong.climbing();
		wuKong.swimming();
		wuKong.flying();
	}
}

//猴子类
class Monkey {
	private String name;
	
	public Monkey(String name) {
		this.name = name;
	}
	
	public void climbing() {
		System.out.println(name + " 会爬树...");
	}
	
	public String getName() {
		return name;
	}
}


//接口
interface Fishable {
	void swimming();
}

interface Birdable {
	void flying();
}


// 继承
// 小结: 当子类继承了父类，就自动的拥有父类的功能
// 如果子类需要扩展功能，可以通过实现接口的方式扩展
// 可以理解 实现接口 是 对 java 单继承机制的一种补充.


class LittleMonkey extends Monkey implements Fishable,Birdable {
	public LittleMonkey(String name) {
		super(name);
	}
	
	@Override
	public void swimming() {
		System.out.println(getName() + " 通过学习，可以像鱼儿一样游泳...");
	}
	
	@Override
	public void flying() {
		System.out.println(getName() + " 通过学习，可以像鸟儿一样飞翔...");
	}
}

接口和继承解决的问题不同
	继承的价值主要在于：解决代码的复用性和可维护性。
	接口的价值主要在于：设计，设计好各种规范(方法)，让其它类去实现这些方法。即更加的灵活。
	
接口比继承更加灵活
	接口比继承更加灵活，继承是满足 is - a 的关系，而接口只需满足 like - a 的关系。

接口在一定程度上实现代码解耦 [即：接口规范性 + 动态绑定机制]

接口的多态特性

1）多态参数
	在前面的USB接口案例，UsbInterface usb，即可以接收手机对象，又可以接受相机对象，就体现了 接口的多态特性。

2）多态数组
	案例：给USB数组中，存放 Phone 和 相机对象，Phone类还有一个特有的方法 call()
	请遍历USB数组，如果是 Phone对象，除了调用USB接口定义的方法外，还需要调用 Phone类的特有方法 call()。

3）接口存在多态传递现象。

package com.spock.interface_;

public class InterfacePolyParameter {
	public static void main(String[] args) {
		//接口的多态体现
		//接口类型的变量 if01 可以指向 实现了 IF 接口类的对象实例
		IF if01 = new Monster();
		if01 = new Car();
		
		//继承体现的多态
		//父类类型的变量 a 可以指向 继承 AAA 的子类的对象实例
		AAA a = new BBB();
		a = new CCC();
	}
}


interface IF {

}
class Monster implements IF {}
class Car implements IF {}


class AAA {

}
class BBB extends AAA {}
class CCC extends AAA {}


package com.spock.interface_;

public class InterfacePolyArr {
	public static void main(String[] args) {
		//多态数组 -> 接口类型数组
		Usb[] usbs = new Usb[2];
		usbs[0] = new Phone_();
		usbs[1] = new Camera_();
		
		/*
		给 Usb 数组中，存放 Phone 和 相机对象，Phone 类还有一个特有的方法 call（），
		请遍历 Usb 数组，如果是 Phone 对象，除了调用 Usb 接口定义的方法外，
		还需要调用 Phone 特有方法 call
		*/
		for(int i = 0; i < usbs.length; i++) {
			usbs[i].work();//动态绑定.. //和前面一样，我们仍然需要进行类型的向下转型
			if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
				((Phone_) usbs[i]).call();
			}
		}
	}
}


interface Usb{
	void work();
}

class Phone_ implements Usb {
	public void call() {
		System.out.println("手机可以打电话...");
	}
	
	@Override
	public void work() {
		System.out.println("手机工作中...");
	}
}

class Camera_ implements Usb {
	@Override
	public void work() {
		System.out.println("相机工作中...");
	}
}


package com.spock.interface_;
/**
* 演示多态传递现象
*/
public class InterfacePolyPass {
	public static void main(String[] args) {
		//接口类型的变量可以指向，实现了该接口的类的对象实例
		IG ig = new Teacher();
		
		//如果 IG 继承了 IH 接口，而 Teacher 类实现了 IG 接口
		//那么，实际上就相当于 Teacher 类也实现了 IH 接口. //这就是所谓的 接口多态传递现象. 		IH ih = new Teacher();
	}
}


interface IH {
	void hi();
}

interface IG extends IH { }

class Teacher implements IG {
	@Override
	public void hi() {
	}
}

这篇关于07 - 面向对象编程（高级部分二）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

07 - 面向对象编程（高级部分二）

一、final 关键字

二、抽象类

三、抽象类最佳实践-模板设计模式

四、接口

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯