java——构造函数、构造代码块、Static关键字、main函数 & 继承：子父类中的变量、函数的特点、抽象类、接口等

代码实例1.1：

对象一建立就会调用与之对应的构造函数。

构造函数的作用：可以用于给对象进行初始化。

示例如下：

class Person
{
Person()
{
System.out.println("person run");
}
}

class  PersonDemo2
{
public static void main(String[] args)
{
Person p = new Person();
}
}

运行结果：
---------- 运行java ----------
person run

输出完成 (耗时 0 秒) - 正常终止

构造函数的小细节：

当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。

当在类中自定义了构造函数后，默认的构造函数就没有了。

构造函数和一般函数在写法上有不同。

在运行上也有不同。

构造函数是在对象一建立就运行。给对象初始化。

而一般方法是对象调用才执行，给是对象添加对象具备的功能。

一个对象建立，构造函数只运行一次。

而一般方法可以被该对象调用多次。

什么时候定义构造函数呢？

当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

代码实例1.2：

class Person
{
private String name;
private int age;

Person()
{
System.out.println("A: name="+name+",,age="+age);
System.out.println("cry");

}

Person(String n)
{
name = n;
System.out.println("B: name="+name+",,age="+age);

System.out.println("cry");
}

Person(String n,int a)
{
name = n;
age = a;
System.out.println("C: name="+name+",,age="+age);
System.out.println("cry");
}
}

class  PersonDemo2
{
public static void main(String[] args)
{
Person p1 = new Person();

Person p2 = new Person("lisi");

Person p3 = new Person("wnagu",10);
}
}
//运行结果：
---------- 运行java ----------
A: name=null,,age=0
cry
B: name=lisi,,age=0
cry
C: name=wnagu,,age=10
cry

输出完成 (耗时 0 秒) - 正常终止

观察以上程序代码里面都有相同的 “System.out.println("cry");”可以提取出一个哭的方法，每个对象只要调用这个哭的方法即可

代码实例1.3

class Person
{
private String name;
private int age;

Person()
{
System.out.println("A: name="+name+",,age="+age);
cry();

}

Person(String n)
{
name = n;
System.out.println("B: name="+name+",,age="+age);

cry();
}

Person(String n,int a)
{
name = n;
age = a;
System.out.println("C: name="+name+",,age="+age);
cry();
}
void cry()
{
System.out.println("cry");
}
}

class  PersonDemo2
{
public static void main(String[] args)
{
Person p1 = new Person();

Person p2 = new Person("lisi");

Person p3 = new Person("wnagu",10);
}
}
/*运行结果：
---------- 运行java ----------
A: name=null,,age=0
cry
B: name=lisi,,age=0
cry
C: name=wnagu,,age=10
cry

输出完成 (耗时 0 秒) - 正常终止
*/

观察以上代码可以发现每个对象的构造函数中都有一个cry（）的方法，所以可以把它提取出来写一个构造代码块即可

构造代码块。

作用：给对象进行初始化。

对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：

构造代码块是给所有对象进行统一初始化，

而构造函数是给对应的对象初始化。

构造代码快中定义的是不同对象共性的初始化内容，因为大家都有就没必要每个对象都去分别定义了

代码实例1.4：

class Person
{
private String name;
private int age;

{
//System.out.println("person code run");
cry();
}

Person()
{
System.out.println("A: name="+name+",,age="+age);
cry();

}

Person(String n)
{
name = n;
System.out.println("B: name="+name+",,age="+age);

cry();
}

Person(String n,int a)
{
name = n;
age = a;
System.out.println("C: name="+name+",,age="+age);
cry();
}
void cry()
{
System.out.println("cry");
}
}

class  PersonDemo2
{
public static void main(String[] args)
{
Person p1 = new Person();

Person p2 = new Person("lisi");

Person p3 = new Person("wnagu",10);
}
}
/*
---------- 运行java ----------
cry
A: name=null,,age=0
cry
cry
B: name=lisi,,age=0
cry
cry
C: name=wnagu,,age=10
cry

输出完成 (耗时 0 秒) - 正常终止
*/

1）：Static关键字：

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，

还可以直接被类名调用。类名.静态成员。

实例代码2.1：

[java] view
plaincopy





class Person

{

String name;//成员变量，实例变量。

static String country = "CN";//静态的成员变量，类变量。

public void show()

{

System.out.println(name+"::::"+country);

}

}

class StaticDemo

{

public static void main(String[] args)

{

Person p = new Person();

//p.name = "zhangsan";

//p.show();

//System.out.println(p.country);

System.out.println(Person.country);

}

}

[java] view
plaincopy





/*运行结果：

---------- 运行java ----------

CN

输出完成 (耗时 0 秒) - 正常终止

*/

示例代码2.2：

[java] view
plaincopy





class Person

{

String name;//成员变量，实例变量。

static String country = "CN";//静态的成员变量，类变量。

public static void show()

{

System.out.println("::::");

}

}

class StaticDemo

{

public static void main(String[] args)

{

Person p = new Person();

//p.name = "zhangsan";

//p.show();

//System.out.println(p.country);

//System.out.println(Person.country);

Person.show();

}

}

*/

/*运行结果：

---------- 运行java ----------

::::

输出完成 (耗时 0 秒) - 正常终止

*/

静态使用注意事项：

1，静态方法只能访问静态成员。

非静态方法既可以访问静态也可以访问非静态。

2，静态方法中不可以定义this，super关键字。

因为静态优先于对象存在。所以静态方法中不可以出现this。

3，主函数是静态的。

代码实例2.3：

[java] view
plaincopy





class Person

{

String name;//成员变量，实例变量。

static String country = "CN";//静态的成员变量，类变量。

public static void show()

{

System.out.println("::::"+name);

}

}

class StaticDemo

{

public static void main(String[] args)

{

Person p = new Person();

//p.name = "zhangsan";

//p.show();

//System.out.println(p.country);

//System.out.println(Person.country);

Person.show();

}

}

*/

/*运行结果：

---------- 编译java ----------

StaticDemo.java:81: 无法从静态上下文中引用非静态 变量 name

System.out.println("::::"+name);

^

1 错误

输出完成 (耗时 1 秒) - 正常终止

分析：因为没有对象，所以不能访问name

*/

2）main函数
代码实例2.4：

[java] view
plaincopy





（String[] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

主函数是固定格式的：jvm识别。

jvm在调用主函数时，传入的是new String[0];

代码实例：

class MainDemo

{

public static void main(String[] args)//new String[]

{

System.out.println(args.length);

}

}

运行结果：

---------- 运行java ----------

0

输出完成 (耗时 0 秒) - 正常终止

*/

javac是打开编译器编译java；java是打开虚拟机执行传入的那个类 当在类后面传入参数的时候虚拟机自动把那些参数装在一个数组里面

代码实例2.5：

[java] view
plaincopy





/*

public static void main(String[] args)

主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。

主函数的定义：

public：代表着该函数访问权限是最大的。

static：代表主函数随着类的加载就已经存在了。

void：主函数没有具体的返回值。

main：不是关键字，但是是一个特殊的单词，可以被jvm识别。

（String[] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

主函数是固定格式的：jvm识别。

jvm在调用主函数时，传入的是new String[0];

代码实例：

*/

class MainDemo

{

public static void main(String[] args)//new String[]

{

String[] arr = {"hah","hhe","heihei","xixi","hiahia"};

MainTest.main(arr);

}

}

//String[] args = new String[3];

//String[] args = null;

class MainTest

{

public static void main(String[] args)

{

for(int x=0; x<args.length; x++)

System.out.println(args[x]);

}

}

运行结果：

---------- 运行java ----------

hah

hhe

heihei

xixi

hiahia

输出完成 (耗时 0 秒) - 正常终止

3)静态什么时候用

什么使用静态？

要从两方面下手：

因为静态修饰的内容有成员变量和函数。

什么时候定义静态变量(类变量)呢？

当对象中出现共享数据时，该数据被静态所修饰。

对象中的特有数据要定义成非静态存在于堆内存中。

什么时候定义静态函数呢？

当功能内部没有访问到肺静态数据(对象的特有数据)， (视频演示见第7~9分钟的时候）

那么该功能可以定义成静态的。

代码实例：

[java] view
plaincopy





class Person

{

String name;

static String country = "cn";

public static void show()

{

System.out.println(contry+"haha");

}

}

class 静态什么时候用

{

public static void main(String[] args)

{

Person p = new Person();

p.show();

//Person .show();

}

}

4)静态代码块：

静态代码块。

格式：

static

{

静态代码块中的执行语句。

}

特点：随着类的加载而执行，只执行一次,并优先于主函数。

用于给类进行初始化的。

实例代码如下：

[java] view
plaincopy





class StaticCode

{

static

{

System.out.println("a");

}

}

class StaticCodeDemo

{

static

{

System.out.println("b");

}

public static void main(String[] args)

{

new StaticCode();

new StaticCode();

System.out.println("over");

}

static

{

System.out.println("c");

}

}

*/

/*

运行结果：

---------- 运行java ----------

b

c

a

over

输出完成 (耗时 0 秒) - 正常终止

*/

[java] view
plaincopy





/*

代码实例：

class StaticCode

{

static

{

System.out.println("a");

}

public static void show()

{

System.out.println("show run");

}

}

class StaticCodeDemo

{

static

{

// System.out.println("b");

}

public static void main(String[] args)

{

// new StaticCode();

// new StaticCode();

//System.out.println("over");

StaticCode.show();

}

static

{

//System.out.println("c");

}

}

*/

/*

运行结果：

---------- 运行java ----------

a

show run

输出完成 (耗时 0 秒) - 正常终止

*/

[java] view
plaincopy





代码实例：

class StaticCode

{

StaticCode()

{

System.out.println("b");

}

static //静态代码块：给类初始化的

{

System.out.println("a");

}

{ //构造代码块：给对象初始化的

System.out.println("c");

}

StaticCode(int x) //构造函数：给对应对像初始化的

{

System.out.println("d");

}

public static void show()

{

System.out.println("show run");

}

}

class StaticCodeDemo

{

static

{

// System.out.println("b");

}

public static void main(String[] args)

{

new StaticCode(4);

// new StaticCode();

// new StaticCode();

//System.out.println("over");

//StaticCode.show();

//StaticCode s = null;

//s = new StaticCode();

}

static

{

//System.out.println("c");

}

}

*/

/*

运行结果：

---------- 运行java ----------

a

c

d

输出完成 (耗时 0 秒) - 正常终止

*/

[java] view
plaincopy





class StaticCode

{

int num = 9;

StaticCode()

{

System.out.println("b");

}

static //静态代码块：给类初始化的

{

System.out.println("a");

}

{ //构造代码块：给对象初始化的

System.out.println("c"+this.num);

}

StaticCode(int x) //构造函数：给对应对像初始化的

{

System.out.println("d");

}

public static void show()

{

System.out.println("show run");

}

}

class StaticCodeDemo

{

static

{

//System.out.println("b");

}

public static void main(String[] args)

{

new StaticCode(4);//a c d

//new StaticCode();

//new StaticCode();

//System.out.println("over");

//StaticCode.show();

//StaticCode s = null;

//s = new StaticCode();

//StaticCode.show();

}

static

{

///System.out.println("c");

}

}

1）继承：

1，提高了代码的复用性。

2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。

Java语言中：java只支持单继承，不支持多继承。

因为多继承容易带来安全隐患:当多个父类中定义了相同功能，

当功能内容不同时，子类对象不确定要运行哪一个。

但是java保留这种机制。并用另一种体现形式来完成表示。多实现。

java支持多层继承。也就是一个继承体系

如何使用一个继承体系中的功能呢？

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。

通过了解共性功能，就可以知道该体系的基本功能。

那么这个体系已经可以基本使用了。

那么在具体调用时，要创建最子类的对象，为什么呢？

一是因为有可能父类不能创建对象，

二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

简单一句话：查阅父类功能，创建子类对象使用功能。

子父类中的变量：

[java] view
plaincopy





继承时子类默认访问子类成员：代码实例：

[java] view
plaincopy





class Fu

{

int num = 4;

}

class Zi extends Fu

{

int num = 5;

}

class ExtendDemo2

{

public static void main(String[] args)

{

Zi z = new Zi();

System.out.println(z.num+" "+z.num);

}

}

运行结果：

---------- 运行java ----------

5 5

输出完成 (耗时 0 秒) - 正常终止

*/

继承时子类默认访问子类成员，当子类要访问继承自父类成员的时候，要使用super关键字。

代码实例：

[java] view
plaincopy





class Fu

{

int num = 4;

}

class Zi extends Fu

{

int num = 5;

void show()

{

System.out.println(super.num);

}

}

class ExtendDemo2

{

public static void main(String[] args)

{

Zi z = new Zi();

z.show();

//System.out.println(z.num+" "+z.num);

}

}

运行结果：

---------- 运行java ----------

4

输出完成 (耗时 0 秒) - 正常终止

*/

继承时，子类默认访问子类成员，当子类没有的时候就访问父类的成员

观察如下两个代码实例：

程序1：

[java] view
plaincopy





class Fu

{

int num = 4;

}

class Zi extends Fu

{

//int num = 5;

void show()

{

System.out.println(num); //这里实际上是System.out.println(this.num);

}

}

class ExtendDemo2

{

public static void main(String[] args)

{

Zi z = new Zi();

z.show();

//System.out.println(z.num+" "+z.num);

}

}

运行结果：

---------- 运行java ----------

4

输出完成 (耗时 0 秒) - 正常终止

*/

程序2：

[java] view
plaincopy





class Fu

{

int num = 4;

}

class Zi extends Fu

{

int num = 5;

void show()

{

System.out.println(num);

}

}

class ExtendDemo2

{

public static void main(String[] args)

{

Zi z = new Zi();

z.show();

//System.out.println(z.num+" "+z.num);

}

}

运行结果：

---------- 运行java ----------

5

输出完成 (耗时 0 秒) - 正常终止

*/

2子父类中的函数：

当子类出现和父类一模一样的函数时，

当子类对象调用该函数，会运行子类函数的内容。

如同父类的函数被覆盖一样。

这种情况是函数的另一个特性：重写(覆盖)

当子类继承父类，沿袭了父类的功能，到子类中，

但是子类虽具备该功能，但是功能的内容却和父类不一致，

这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。

覆盖：

1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

2，静态只能覆盖静态。

记住：

重载：只看同名函数的参数列表。

重写：子父类方法要一模一样。

*/

//当子类出现和父类一模一样的函数时，

//当子类对象调用该函数，会运行子类函数的内容。

代码实例：

[java] view
plaincopy





class Fu

{

void show()

{

System.out.println("fu show");

}

void speak()

{

System.out.println("vb");

}

}

class Zi extends Fu

{

void speak()

{

System.out.println("java");

}

void show()

{

System.out.println("zi show");

}

}

class ExtendsDemo3

{

public static void main(String[] args)

{

Zi z = new Zi();

z.speak();

}

}

运行结果：

---------- 运行java ----------

java

输出完成 (耗时 0 秒) - 正常终止

/*

3.子父类中的构造函数。

在对子类对象进行初始化时，父类的构造函数也会运行，

那是因为子类的构造函数默认第一行有一条隐式的语句 super();

super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();

为什么子类一定要访问父类中的构造函数。

因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。

所以子类在对象初始化时，要先访问一下父类中的构造函数。

如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

注意：super语句一定定义在子类构造函数的第一行。

子类的实例化过程：

子类的所有的构造函数，默认都会访问父类中空参数的构造函数。

因为子类每一个构造函数内的第一行都有一句隐式super();

当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。

当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。

子类中至少会有一个构造函数会访问父类中的构造函数。

*/

如下程序运行结果可看出,当创建子类对象的时候既执行了子类的构造函数也执行了父类的构函数，原因就是 java虚拟机自动在子类的构造函数里面添加了super();

[java] view
plaincopy





class Fu

{

int num ;

Fu()

{

System.out.println("fu run");

}

}

class Zi extends Fu

{

Zi()

{

//super(); java虚拟机自动在子类的构造函数里面添加了 super();

System.out.println("zi run");

}

}

class ExtendsDemo4

{

public static void main(String[] args)

{

Zi z = new Zi();

}

}

*/

/*

程序运行结果：

---------- 运行java ----------

fu run

zi...0

输出完成 (耗时 0 秒) - 正常终止

*/

在对子类对象进行初始化时，父类的构造函数也会运行，

那是因为子类的构造函数默认第一行有一条隐式的语句 super();

super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();

见代码示例：

[java] view
plaincopy





class Fu

{

int num ;

Fu()

{

System.out.println("fu run");

}

Fu(int x)

{

System.out.println("fu ...."+x);

}

}

class Zi extends Fu

{

Zi()

{

//super(); java虚拟机自动在子类的构造函数里面添加了 super();

System.out.println("zi run");

}

Zi(int x)

{

//super(); java虚拟机自动在子类的构造函数里面添加了 super();

System.out.println("zi..."+x);

}

}

class ExtendsDemo4

{

public static void main(String[] args)

{

Zi z = new Zi();

Zi z1 = new Zi(4);

}

}

*/

/*

程序运行结果：

---------- 运行java ----------

fu run

zi run

fu run

zi...4

输出完成 (耗时 0 秒) - 正常终止

*/

/*

为什么子类一定要访问父类中的构造函数。

因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。

所以子类在对象初始化时，要先访问一下父类中的构造函数。

如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

注意：super语句一定定义在子类构造函数的第一行。

*/

[java] view
plaincopy





/*

class Fu

{

int num ;

Fu()

{

System.out.println("fu run");

}

Fu(int x)

{

System.out.println("fu ...."+x);

}

}

class Zi extends Fu

{

Zi()

{

//super(); java虚拟机自动在子类的构造函数里面添加了 super();

super(4); //通过手动定义super语句的方式来指定访问父类中指定的构造函数

System.out.println("zi run");

}

Zi(int x)

{

//super(); java虚拟机自动在子类的构造函数里面添加了 super();

super(3); //通过手动定义super语句的方式来指定访问父类中指定的构造函数

System.out.println("zi..."+x);

}

}

class ExtendsDemo4

{

public static void main(String[] args)

{

Zi z = new Zi();

Zi z1 = new Zi(4);

}

}

*/

/*

结果：

---------- 运行java ----------

fu ....4

zi run

fu ....3

zi...4

输出完成 (耗时 0 秒) - 正常终止

*/

在继承中当父类已经有了的成员属性或者成员方法，子类可以直接拿来用，不用再去创建

代码示例：

[java] view
plaincopy





class Person

{

private String name;

Person(String name)

{

this.name = name;

}

void show(){}

}

class Student extends Person

{

Student(String name)

{

super(name);

}

void method()

{

super.show();

}

}

class ExtendsDemo4

{

public static void main(String[] args)

{

Zi z = new Zi();

Zi z1 = new Zi(4);

}

}

/*运行结果：

---------- 运行java ----------

fu ....4

zi run

fu ....3

zi...4

输出完成 (耗时 0 秒) - 正常终止

*/

4.final 关键字：

/*

final : 最终。作为一个修饰符，

1，可以修饰类，函数，变量。

2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。

3，被final修饰的方法不可以被复写。

4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。

当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。

而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。

单词间通过_连接。

5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。

*/

[java] view
plaincopy





class Demo

{

final int x = 3;

public static final double PI = 3.14;

final void show1()

{}

void show2()

{

final int y = 4;

System.out.println(3.14);

}

}

class SubDemo extends Demo

{

//void show1(){}

}

class FinalDemo

{

public static void main(String[] args)

{

SubDemo p = new SubDemo();

System.out.println(p.PI);

}

}

5.抽象类：

/*

当多个类中出现相同功能，但是功能主体不同，

这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。

抽象：看不懂。

抽象类的特点：

1，抽象方法一定在抽象类中。

2，抽象方法和抽象类都必须被abstract关键字修饰。

3，抽象类不可以用new创建对象。因为调用抽象方法没意义。

4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。

如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。(也就是说子类必须全部覆盖掉父类（抽象类的抽象方法之后才不算是抽象类

，因为子类继承了父类，所以子类拥有父类的除私有以外的所有成员属性和成员方法，如果不全部覆盖掉父类的抽象方法那么子类就有抽象方法，

有抽象方法的类就是抽象类））

抽象类和一般类没有太大的不同。

该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。

这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。

通过抽象方法来表示。

抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。

抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

抽象也有构造函数，抽象类是一个父类，要给子类提供实例的初始化。

*/

/*

当多个类中出现相同功能，但是功能主体不同，

这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。

如下是两个具有相同功能但功能内容不同的两个类：

*/

[java] view
plaincopy





/*

class BaseStudent

{

void study()

{

System.out.println("base study");

}

}

class AdvStudent{

void study()

{

System.out.println("adv study");

}

}

class AbstractDemo

{

public static void main(String[] args)

{

new BaseStudent().study();;

}

}

运行结果：

---------- 运行java ----------

base study

输出完成 (耗时 0 秒) - 正常终止

*/

//观察上面两个类 对以上一段代码经行向上抽取之后：

[java] view
plaincopy





abstract class Student //对两个具有相同功能但功能内容不同的子类进行向上抽象之后产生的一个抽象类

{

abstract void study();

}

class BaseStudent extends Student

{

void study()

{

System.out.println("base study");

}

}

class AdvStudent extends Student

{

void study()

{

System.out.println("adv study");

}

}

class AbstractDemo

{

public static void main(String[] args)

{

new BaseStudent().study();

new AdvStudent().study();//子类创建一个匿名对象，因为抽象类不可以用new创建对象。因为调用抽象方法没意义。

}

}

/*

程序运行结果：

---------- 运行java ----------

base study

adv study

输出完成 (耗时 0 秒) - 正常终止

*/

6.接口：

/*

接口：初期理解，可以认为是一个特殊的抽象类

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类

interface 用于定义接口。

接口定义时，格式特点：

1，接口中常见定义：常量，抽象方法。

2，接口中的成员都有固定修饰符。

常量：public static final

方法：public abstract

接口中的成员都是public的。

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

*/

[java] view
plaincopy





interface Inter

{

public static final int NUM = 3;

public abstract void show();

}

interface InterA

{

public abstract void show();

}

class Demo

{

public void function(){}

}

class Test extends Demo implements Inter,InterA //Test 实现两个接口

{

public void show(){}

}

interface A

{

void methodA();

}

interface B //extends A

{

void methodB();

}

interface C extends B,A //接口也可以继承

{

void methodC();

}

class D implements C

{

public void methodA(){}

public void methodC(){}

public void methodB(){}

}

class InterfaceDemo

{

public static void main(String[] args)

{

Test t = new Test();

System.out.println(t.NUM);

System.out.println(Test.NUM);

System.out.println(Inter.NUM);

}

}

运行结果：

---------- 运行java ----------

3

3

3

输出完成 (耗时 0 秒) - 正常终止