抽象类与接口

抽象类和接口

一、final关键字

final表示最终的，可以用来修饰变量、方法和类

1.修饰变量

被final修饰的变量，称为常量constant，常量的值是不能被修改的

被static final修饰的变量，称为静态常量，一般来说也称为常量

常量的命名规范：所有字母全大写，多个单词之间使用下划线连接如USER_STATE

应用：一般用于替代硬编码/僵尸代码大多是难于阅读和理解的值

2.修饰方法

被final修饰的方法，不能被重写

3.修饰类

被final修饰的类，不能被继承，即不能有子类

final类中的所有方法都默认为final方法，不能被重写

4.修饰参数

被final修饰的参数，只能读取不能修改

public class Test01_final关键字 {

	static final int b = 6;
	static final int c;
	static final double PI = 3.1415936;

	static {
		c = 2;// 在静态代码块中对静态常量进行初始化
	}

	public static void main(String[] args) {
		final int a = 5;// 常量
        //a=8;//不能被修改
		Dog dog = new Dog();
		dog.sum(2, 3);
	}
}

class Animal {
	public void show() {
		System.out.println("Animal.show()");
	}
    
	// final修饰的方法不允许被重写
	public final void print() {
		System.out.println("Animal.print");
	}
}

//final修饰的类不允许被继承
final class Dog extends Animal {

	@Override
	public void show() {
		// TODO Auto-generated method stub
		super.show();
	}

	public void sum(final int num1, int num2) {
		// num1=111;
		num2 = 222;
		System.out.println("Dog.sum()" + num1 + "," + num2);
	}
}

二、抽象类

如何防止父类被实例化？

如何保证子类必须重写父类的方法？

1.概念

被abstract修饰的类，称为抽象类

• 定义方式：public abstract class 类名{}
• 抽象类不能被实例化，即不能使用new创建一个对象，只能被继承

被abstract修饰的方法，称为抽象方法

• 定义方式：public abstract 返回值类型 方法名();
• 抽象方法只有声明，没有具体实现，即没有方法体，以分号结尾

2.特性

抽象类中可以有抽象方法，也可以没有抽象方法

含有抽象方法的类，必须为抽象类

子类继承抽象类后，必须实现/重写抽象类中所有的抽象方法，否则子类仍然为抽象类

抽象类中可以有构造方法，但不是用来创建对象的，而是用来初始化成员属性

三、接口

如果一个抽象类中只有抽象方法和常量值，则可以定义为接口interface

1.概念

从本质上来讲，接口是一种特殊的抽象类，只能包含常量和方法的声明

2.用法

2.1定义接口

语法：

interface 接口名{
    常量;
    抽象方法;
}

接口中的属性，默认被public static final修饰，即接口中只有常量

接口中的方法，默认被public abstract修饰，即接口中只有抽象方法

接口中没有构造方法，不能实例化接口

2.2.实现接口

语法：

class 类名 extends 父类 implements 接口名{
    
}

实现接口的类，称为实现类

实现类必须实现接口中所有的抽象方法，且方法必须使用public修饰，否则其为抽象类

3.特性

一个类可以实现多个接口，多个接口之间以逗号隔开

JDK1.8及以后，可以使用 default关键字修饰方法，此时方法可以有方法体，但一般都为空方法（简化实现类的方法，无需实现所有方法）

一个接口可以继承多个其他接口，添加新属性和抽象方法，但接口不能继承类

在java中支持接口的多继承，不支持类的多继承

/*
 * 类、接口间的关系
 * 1.类与类之间
 *   一个类可以继承自另一个类：class 子类 extends 父类
 * 2.接口与接口之间
 *   一个接口可以继承自多个接口：interface 子接口  extends 父接口1，父接口2
 * 3.类与接口之间
 *   一个类可以实现多个接口：class 实现类 implements 接口1，接口2
 */
public class Test04_接口间的继承 {
	public static void main(String[] args) {
		D d = new D();
		d.a();
		d.b();
		d.c();
	}
}

interface A {
	public void a();
}
interface B {
	public void b();
}
interface C extends A, B {
	public void c();
}

class D implements C {
	@Override
	public void a() {
	}
	@Override
	public void b() {
	}
	@Override
	public void c() {
	}
}

4.作用

接口的作用：

• 间接实现多继承（java不支持多继承，但可以实现多个接口）
• 通过接口定义规范和标准
• 将标准的制定和实现分开

建议面向接口编程，提高扩展性

public class Test05_接口的作用 {
	public static void main(String[] args) {
		Computer computer = new Computer();
		// 将接口的引用，指向实现类的实例，实现多态
		Usb usb = new Mouse();// 向上转型
		Keyboard keyboard = new Keyboard();
		computer.runDevice(keyboard);
	}
}

class Computer {
	public void runDevice(Usb usb) {// 只要是符合Usb接口的设备都可以
		usb.power();
	}
}

/*
 * Usb接口，是一种标准
 */
interface Usb {
	// 具有供电的功能
	public void power();
}

class Mouse implements Usb {
	@Override
	public void power() {
		System.out.println("这是鼠标,符合USB接口的规范");
	}
}

class Keyboard implements Usb {
	@Override
	public void power() {
		System.out.println("这是键盘，符合USB接口的规范");
	}
}

5.接口与抽象类的比较

相同点：

• 接口和抽象类都不能实例化
• 都可以包含抽象方法

不同点：

• 接口中只有静态常量，抽象类中还可以有普通成员变量
• 接口中只有抽象方法，抽象类中还可以有非抽象方法（使用default关键字时接口中也可以有非抽象方法）
• 接口中不包含构造方法，抽象类中可以包含构造方法
• 接口支持多继承，抽象类不支持多继承

​