java大数据接口_Java抽象类及接口

一、final

final的中文意思就是不可更改的，最终的。

1.final修饰变量，那么该变量无法更改。一旦该变量赋了初值，就不能重新赋值。

1 final MAX = 1100;

2 //final修饰后MAX就无法重新赋值。

2.final修饰方法

final修饰方法，那么该方法不能被子类重写，但可以重载。

1 class Person{

2 final void getName(){.....}

3 }

4

5 //getName()方法，无法被子类重写。

3.final修饰类

final修饰类，该类无法被继承。

二、抽象类

首先什么是抽象类，简而言之就是包含了抽象方法的类。

那什么又是抽象方法了，就是只有声明部分，但没有方法体。

完整的方法应该是

1 void getName() //方法声明

2 { //方法体

3 System.out.println("i am hcf");

4 }而抽象方法是没有方法体的，abstract void getName();

抽象方法前面必须加abstra修饰，拥有抽象方法的类称为抽象类，那么抽象类前面要加上abstract修饰。

1 abstract class Person{

2 abstract void getName();

3 }

下面简述抽象类的几个要点：

1.有抽象方法的类只能定义为抽象类，不然会出现错误。

1 abstract class Person{ //定义为抽象类，那么必须包含抽象方法。

2 abstract void getName(); //有抽象方法，必定为抽象类

3 }

2.抽象类不能用new创建对象，即使你在抽象类里面添加构造方法也不行。

public class TestAbstract {

public static void main(String[] args) {

/* Person stu = new Person(); */ //Person是抽象类，无法实例化

}

}

abstract class Person{

abstract void getName();

public void Person(){ //即使添加了构造方法也无法实例化。

} //只要是抽象类，就无法实例化。

}

3.抽象类中可以包含一般的方法或属性，但只能被子类调用。

1 public class TestAbstract {

2 public static void main(String[] args) {

3 Student stu = new Student();

4 stu.getName();

5 stu.out(); //抽象类中的其他方法可以通过子类来调用

6 }

7 }

8

9 abstract class Person{

10 abstract void getName();

11 void out(){ //抽象类中包含的其他方法

12 System.out.println("1132");

13 }

14 }

15

16 class Student extends Person{

17 public void getName(){

18 System.out.println("i am hcf");

19 }

20 }

运行结果：

i am hcf

1123

4.抽象类只能被继承。

5.子类必须实现抽象类中的抽象方法。

abstract class Person{

abstract void getName();

void out(){

System.out.println("1132");

}

}

class Student extends Person{

public void getName(){ //子类必须实现抽象方法，否则会报错。

System.out.println("i am hcf");

}

}

三、接口

接口比抽象类还要抽象，接口只能包含方法声明和常量。

接口说明：

1.接口只能用public 或default修饰，public修饰的接口名称必须和文件名相同(这点和public类相似)。

1 public interface Fly{

2 void flyStyle();

3 }

4

5

6 interface attack{

7 int attackRange(String arms);

8 }

2.一个文件中只能有一个被public修饰的接口。

3.接口可以多继承

public interface Fly{

void flyStyle();

}

interface Attack{

int attackRange(String arms);

}

interface FlyArms extends Fly, Attack{ //飞行武器(FiyArams)就继承了Fly(飞行)接口和attack(攻击)接口

}

4.接口中常量默加上public static final，写于不写都一样。

1 interface Fly{

2 int MIN_HIGHT = 1; //相当于public static final int MIN_HIGHT = 1;

3 void flyStyle(); //相当于public abstract void flyStyle();

4 }

5.接口中的方法默认加上public abstract。

接口要点：

1.接口不可被类继承，只能被类实现(implements)。

2.接口中的方法必须实现，且方法必为public。

1 public interface Fly{

2 void flyStyle();

3 }

4

5

6 interface Attack{

7 int attackRange(String arms);

8 }

9

10

11 class implements Fly{ //接口只能被实现(implements)

12 public void flyStyle(){ //类实现接口必须实现接口中定义好的方法。

13 System.out.println("飞飞飞！");

14 }

15 }

3.接口不能创建实例，但可以声明引用变量类型。

1 public class FramPaint {

2 public static void drawFram(MyPaint p){ //(Mypaint p) 接口声明引用变量类型

3 System.out.println("启动线程"); //有点像之前的多态父类声明引用子类对象。

4 System.out.println("增加循环"); //这个还涉及到后面的回调函数，其实就是多态。

5 System.out.println("查看消息");

6 p.paint();

7 System.out.println("启动缓存");

8

9 }

10 public static void main(String[] args) {

11 FramPaint.drawFram(new GameFarm()); //调用静态方法可以直接类名加方法调用，12 } //静态方法中只能调用静态方法。

13

14 }

15

16 interface MyPaint {

17 void paint();

18 }

19

20 class GameFarm implements MyPaint{

21 @Override

22 public void paint() {

23 System.out.println("GameFarm");

24 }

25 }