喵星之旅-成长的雏鹰-java面向对象-5-抽象类与接口

成长的雏鹰java面向对象

抽象类

抽象类VS普通类:
抽象类不能被实例化
但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例
普通类可以被实例化

抽象方法VS普通方法:
有无方法体

抽象类与抽象方法的使用:
抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类
如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
没有抽象构造方法，也没有抽象静态方法
抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

public abstract class Base {
	//抽象类中可以没有抽象方法,但包含了抽象方法的类就必须被定义为抽象类
	public abstract void method1();
	public abstract void method2();
	public void method3(){}
	//没有抽象的构造方法
	//public abstract Base(){}
	//没有抽象的静态方法
	//static abstract void method4();
	
	public Base(){
		System.out.println("父类的无参构造方法");
	}
	
	static void method4(){
		System.out.print("静态方法表示类所特有的功能，这种功能的实现不依赖于类的具体实例，也不依赖于它的子类。因此，当前类必须为静态方法提供实现");
	}
	
}



//如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类

public abstract class Sub1 extends Base {

	public void method1() {
		System.out.println("重写父类的method1");
	}
	
}


//否则就必须实现父类的所有抽象方法
public class Sub2 extends Base {
	public Sub2(){
		System.out.println("子类的无参构造方法");
	}

	@Override
	public void method1() {
		System.out.println("重写父类的抽象方法method1");
	}

	@Override
	public void method2() {
		System.out.println("重写父类的抽象方法method2");
	}

}



public class Test {
	public static void main(String[] args) {
		//抽象类不允许实例化
		//Base base=new Base();
		//抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用
		//抽象类不能被实例化,但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例
		Base sub=new Sub2();
		sub.method1();
		sub.method4();
	}
}

接口

接口表示一种能力，也是一种类型，和类的级别一样，但是不是同类型的事物。
接口是一种约定，有些接口只有名称没有任何内容。

接口的使用：
接口中的成员变量默认都是public static final的，必须显式初始化；
接口中的方法默认都是public abstract的；
接口没有构造方法，不能被实例化；
一个接口不能实现另一个接口，但可以继承多个其他接口；
一个类必须实现接口抽象方法（implements），除非这个类也是抽象类。

1
2
3
4
5
6
7
public interface MyInterface {
    //所有方法默认都是：public abstract,不写也是。

    public void foo()；
    //其他方法
}

必须知道的接口特性：
接口不可以被实例化
实现类必须实现接口的所有方法
实现类可以实现多个接口
implements、多个接口使用逗号隔开
接口中的变量都是静态常量（public static final） 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
 * 测试类。
 * @param args
 */
public class Test {	
	public static void main(String[] args) {
		
		//1、U盘
		UsbInterface uDisk = new UDisk();
		uDisk.service();
		
		//2、USB风扇
		UsbInterface usbFan= new UsbFan();
		usbFan.service();
	}
}


/**
 * U盘。
 *
 */
public class UDisk implements UsbInterface {
	public void service() {
		System.out.println("连接USB口，开始传输数据。");
	}
}


/**
 * USB风扇。
 * 
 */
public class UsbFan implements UsbInterface {
	public void service() {
		System.out.println("连接USB口，获得电流，风扇开始转动。");
	}
}

/**
 * USB接口。
 * 
 */
public interface UsbInterface {
	/**
	 * USB接口提供服务。
	 */
	void service();
}


抽象类与接口

相同点:
代表系统的抽象层
都不能被实例化
都能包含抽象方法
用于描述系统提供的服务，不必提供具体实现

不同点:
在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法
抽象类便于复用，接口便于代码维护
一个类只能继承一个直接的父类，但可以实现多个接口

使用原则:
接口做系统与外界交互的窗口
接口提供服务
接口本身一旦制定，就不允许随意修改
抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点

文章目录
  1. 抽象类
  2. 接口
  3. 抽象类与接口
|