在java 编程思想当中有这么一句话：接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法。个人感觉接口就是另一种方法，我很少写学习笔记，但是经过个人的经验，不写笔记还是不好的，所以我打算从新学习java，然后把我所学的记记，以后也可以用来复习和学习，笔记很粗糙，在学习接口前得先学习一下抽象类。
抽象类和抽象方法的学习
抽象类就是一个基类一样，用来让别人继承所用，可以通过这个通用的接口操纵一系列类，所以就出现一个抽象方法的机制，这个方法是不完整的，仅有申明而没有方法体，请看语法：abstract void f();其实就是c++当中的纯虚函数。包含抽象方法的类叫做抽象类，只要这个类当中有一个是抽象的方法，那么这个类就是抽象类，反过来就不一定了。
package tst;
abstract class Instrument4 {
int i; // storage allocated for each
public abstract void play();
public String what() {
return "Instrument4";
}
public abstract void adjust();
}
class Wind4 extends Instrument4 {
public void play() {
System.out.println("Wind4.play()");
}
public String what() {
return "Wind4";
}
public void adjust() {
}
}
class Percussion4 extends Instrument4 {
public void play() {
System.out.println("Percussion4.play()");
}
public String what() {
return "Percussion4";
}
public void adjust() {
}
}
class Stringed4 extends Instrument4 {
public void play() {
System.out.println("Stringed4.play()");
}
public String what() {
return "Stringed4";
}
public void adjust() {
}
}
class Brass4 extends Wind4 {
public void play() {
System.out.println("Brass4.play()");
}
public void adjust() {
System.out.println("Brass4.adjust()");
}
}
class Woodwind4 extends Wind4 {
public void play() {
System.out.println("Woodwind4.play()");
}
public String what() {
return "Woodwind4";
}
}
public class Music4 {
// Doesn't care about type, so new types
// added to the system still work right:
static void tune(Instrument4 i) {
// ...
i.play();
}
static void tuneAll(Instrument4[] e) {
for (int i = 0; i < e.length; i++)
tune(e[i]);
}
public static void main(String[] args) {
Instrument4[] orchestra = new Instrument4[5];
int i = 0;
orchestra[i++] = new Wind4();
orchestra[i++] = new Percussion4();
orchestra[i++] = new Stringed4();
orchestra[i++] = new Brass4();
orchestra[i++] = new Woodwind4();
tuneAll(orchestra);
}
}
Wind4.play()
Percussion4.play()
Stringed4.play()
Brass4.play()
Woodwind4.play()
就是基类变成了抽象了，其它的都没有什么变化。
接口的学习
interface关键字使抽象的概念更进一步，abstract关键字允许人们在类中创建一个或多个没有任何定义的方法，然后提供别人继承之用，interface产生一个完全抽象的类，它根本就没有提供任何具体实现。可以让创建者进行方法名，参数列表返回类型的修改。
interface不仅仅是一个极度抽象的类，java当中的类似多重继变种的特性。
要创建一个接口，只需要将class关键字替换成，interface就行，也可以加public 。也有域，都是static final 。
必须申明成public的，不然它们的访问权限就只能在默认的包访问权限，这样防问权限被降低了，java是不允许的。
java中的多重继承：
通过继承扩展接口
利用继承技术，可方便地为一个接口添加新的方法声明，也可以将几个接口合并成一个新接口。在这两种情况下，最终得到的都是一个新接口，如下例所示：
package tst;
interface Monster {
void menace();
}
interface DangerousMonster extends Monster {
void destroy();
}
interface Lethal {
void kill();
}
class DragonZilla implements DangerousMonster {
public void menace() {
}
public void destroy() {
}
}
interface Vampire extends DangerousMonster, Lethal {
void drinkBlood();
}
class HorrorShow {
static void u(Monster b) {
b.menace();
}
static void v(DangerousMonster d) {
d.menace();
d.destroy();
}
public static void main(String[] args) {
DragonZilla if2 = new DragonZilla();
u(if2);
v(if2);
}
}
DangerousMonster是对Monster的一个简单的扩展，最终生成了一个新接口。这是在DragonZilla里实现的。
Vampire的语法仅在继承接口时才可使用。通常，我们只能对单独一个类应用extends(扩展)关键字。但由于接口可能由多个其他接口构成，所以在构建一个新接口时，extends可能引用多个基础接口。正如大家看到的那样，接口的名字只是简单地使用逗号分隔。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
