Java学习日记2——final,抽象类,接口

Posted 2021-03-15 raincurtain

今天出去玩了，好不快活，只好在晚上默默补习Java。今天学习了final关键字，抽象类以及接口的概念，还是很有意思的。现在这些东西只是知道是个什么东西，我需要一个项目去强化它们。

final关键字

在我初次尝试Java的时候，我想定义一个常量，自然而然地使用了"const"，也自然而然地报错了，然后我就怀疑难道Java没有常量这么个东西么？真是心大啊！

然后我才发现，Java不仅有常量，还有“常类”（我自己这么叫），“常方法”也是我自己这么叫......

是的，final很容易理解，即“最后的”，自然引申至“不可修改的”（最后的嘛），所以被final修饰的属性为常量。

被final修饰的类不可被继承，被final修饰的方法不可被重写。

一目了然，不言而喻。

抽象类

emmmm我一直认为一切事物的发展应该自然而然，所有看起来突兀的事情不过是因为我们不了解其背后的道理罢了。

抽象类，顾名思义，抽象的类。抽象的反义词是实在，抽象类也就是无法被实例化的类。

抽象类被关键字abstract修饰，一个类，只要含有一个抽象方法（即被abstract修饰），就必须是抽象类，而抽象类的方法不一定非要是抽象方法。

抽象类的作用，就比如我们要写一个Animal类，主要用于被继承。这个Animal类有move方法，eat方法等等，我们可以知道的是每个动物eat大同小异（不严谨地说），但是move就很难去标明，有飞的跑的跳的游的。所以Animal类的move方法就可以被写成抽象方法。

 public abstract class Animal {
     abstract void move();
     void eat();
}

 

这个类只能被继承，类中的抽象方法没有方法体。如果一个类要继承这个类，必须实现这个类中的所有的抽象方法。

class Dog extends Animal{
    @Override
    public void move(){
        System.out.println("---Run---");
    }
}

一个抽象类可以继承另一个抽象类。

接口

接口和抽象类很想啊，不过接口可以多继承，可以多重继承。一个类可以实现（implements）多个接口。

我一直不明白为什么Java不支持多继承，不过接口可以承担一部分需要多继承的工作吧。（当然接口还可以实现一些其他的工作，也许Java开发者认为用接口的代价小于多继承加上一些其他更多的特性吧）

接口用关键字interface声明，接口中的所有变量默认类型为public static final（即使你不显式地这样写，而且如果你固执地想要其他类型，会报错），所有的方法默认为public abstract（同上，被隐式地这样声明了，且如果不想这样，会报错）。

一个类可以实现接口（你必须实现这个接口中所有的方法），如下：

 1 package TestInterface;
 2 
 3 public interface Animal {
 4     int legs = 4;
 5     void move();
 6     void eat();
 7     void shout();
 8 }
 9 
10 class Dog implements Animal{
11 
12     @Override
13     public void move() {
14         
15     }
16 
17     @Override
18     public void eat() {
19 
20     }
21 
22     @Override
23     public void shout() {
24 
25     }
26 }

接口之间的继承再次不展示了（可以多继承哦），一个类可以实现多个接口：

 1 public interface Animal {
 2     int legs = 4;
 3     void move();
 4     void eat();
 5     void shout();
 6 }
 7 
 8 interface FourLegs{
 9     void run();
10 }
11 
12 class Dog implements Animal, FourLegs {
13 
14     @Override
15     public void move() {
16         
17     }
18 
19     @Override
20     public void eat() {
21 
22     }
23 
24     @Override
25     public void shout() {
26 
27     }
28 
29     @Override
30     public void run() {
31         
32     }
33 }

同样地，你必须实现这所有接口中的所有方法，如果不这样，你必须把类声明为抽象类。

如果你既想继承一个类，又想实现接口，那么先extend，然后implements：

 1 import people.Person;
 2 
 3 public interface Animal {
 4     int legs = 4;
 5     void move();
 6     void eat();
 7     void shout();
 8 }
 9 
10 interface FourLegs{
11     void run();
12 }
13 
14 class Dog extends Person implements Animal, FourLegs {
15 
16     @Override
17     public void move() {
18 
19     }
20 
21     @Override
22     public void eat() {
23 
24     }
25 
26     @Override
27     public void shout() {
28 
29     }
30 
31     @Override
32     public void run() {
33 
34     }
35 }

这里emmmm因为不想再多写一个测试类，用Person代替下，毕竟人和狗之间的差别，有时候不如人和人之间，所以没什么好奇怪的。

至于接口的用处，一个是可以多继承，另一个，如果父类有改动而不想影响到子类，那么可以把改动写到一个接口里，让子类选择性地实现。

当然我刚学，很多地方难免狭隘，以后有幸工程用到再来补充。

最后引用求知讲堂（我就是在这学习Java的）的一句话：抽象类是对一类事物的高度抽象，其中既有属性也有方法；接口是对方法的抽象，也就是对一系列动作的抽象。当需要对一类事物抽象的时候，应该使用抽象类，方便形成父类；当需要对一系列的动作抽象，就使用接口，需要使用这些动作的类去实现相应的接口即可。