Java学习_day08_final&native&abstract&接口

final关键字

final关键字表示常量，其值在程序运行期间不会改变。
final用来修饰变量，可以是静态变量，也可以是成员变量，也可以是局部变量，表示变量初始化之后不能被再赋值。
final用来修饰方法，表示该方法不允许子类重写。
final用来修饰类，表示该类不能被继承。

final class Father{
	final String TYPE = "父亲";
	final void info(){
		System.out.println(TYPE);
	}
}
1
2
3
4
5
6

注意

• 常量用大写字母表示，多个单词时用_分隔
• 常量在定义后需要手动初始化，初始化后不能对其再赋值。
• 成员常量，可以在声明时，语句块，构造器等地方初始化。

native关键字

简单的理解native就是声明了一个非Java实现的方法，可以像其他方法一样被使用或重写。
native用来修饰方法，表示本地或原生的方法。
本地方法就是Java与外部环境交流的一种机制，它提供了一个非常简洁的接口，系统无须了解Java应用之外的繁琐细节，就能简单实现想要的功能。
本地方法的方法体由非Java语言实现，如C或C++。

public final native Class<?> getClass();
public native int hashCode();
1
2

abstract关键字

如果一个父类的某个方法，被每个子类都重写了，这样父类中就没有必要给出这个方法实质性的实现了。由此而衍生出abstract关键字，来修饰方法，表示声明了一个方法，类中没有方法体，需要子类重写该方法（方法的实现由子类设计).

[访问权限修饰符] abstract 返回值类型 方法名(参数列表) [throws 异常列表];
1

• 由于abstract修饰的方法，需要在子类中重写，所以访问权限修饰符不能是static, final和private
• 只能在抽象类和接口中声明抽象方法

抽象类

具有抽象方法的类被称为抽象类，抽象类不能直接创建实例对象，抽象类的子类需要重写抽象方法。
抽象类也具有构造器。
抽象类不能用final修饰，否则无法被继承了。
当子类不是抽象类时，必须重写父类的抽象方法。

定义

[权限修饰符] abstract class 类名{
}
1
2

继承

通过下面代码案例来理解抽象类的继承关系。

public class Test {
    public static void main(String[] args) {
        Graphic[] arr = new Graphic[2];
        arr[0] = new Rectangle(2,5);
        arr[1] = new Circle(4);
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i].detail());
        }

    }
}

//  定义抽象类
abstract class Graphic{
    public abstract double area();
    public abstract String detail();
}
//  定义继承抽象类的非抽象子类
class Rectangle extends Graphic{
    private double length;
    private double width;
    public Rectangle(double length, double width){
        super();
        this.length = length;
        this.width = width;
    }
    public double getLength(){
        return length;
    }
    public double getWidth(){
        return width;
    }
    // 实现抽象方法
    public double area(){
        return length * width;
    }
    // 实现抽象方法
    public String detail(){
        return "长方形, 长: " + length + ", 宽: " + width;
    }
}

//  定义继承抽象类的非抽象子类
class Circle extends Graphic{
    private double radius;
    public Circle(double radius){
        super();
        this.radius = radius;
    }
    public double getRadius(){
        return radius;
    }
    // 实现抽象方法
    public double area(){
        return Math.PI * radius * radius;
    }
    // 实现抽象方法
    public String detail(){
        return "圆, 半径: " + radius;
    }
}
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

接口

接口可以认为是一种规范，用interface关键字声明。

• 一个类可以实现多个接口
• 类必须实现接口中所有的抽象方法
• 接口可以包含静态常量，抽象方法，静态内部接口，静态方法(JDK8+)，默认方法(JDK8+)
• 不可直接实例化
• 当父类和接口默认方法具有相同的方法签名时，类遵循父类优先原则
• 当多个接口中具有相同方法签名的默认方法时，类必须重写这个默认方法
• 接口也可以继承别的接口

定义

// 定义接口
[修饰符] interface 接口名{
	// 静态常量
	[public static final] 常量名 = 值;
	// 抽象方法
	[public abstract] 返回值类型 方法名(形参类型 形参);
	// 静态方法, 通过 接口.静态方法名调用
	[public] static 返回值类型 方法名(形参类型 形参){
		方法体;
	}
	// 默认方法, 通过 实现对象.默认方法名调用
	[public] default 返回值类型 方法名(形参类型 形参){
		方法体;
	}
}
// 实现接口
[修饰符] class 类名 [extends 父类] implements 接口1,接口2,...{
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

实现

public class Test {
    public static void main(String[] args) {
//        使用接口的静态方法
        MyInterface.info();
//        当接口默认方法和父类方法签名一致时
        MyInterface dog = new Dog();
        dog.getNum();
//        多态的实现
        dog.say();

    }
}

interface MyInterface{
//  静态常量
    int NUM = 1;
//  静态方法
    static void info(){
        System.out.println("接口的静态方法");
    }
//  默认方法
    default void getNum(){
        System.out.println("接口的常量" + NUM);
    }
//  抽象方法
    void say();
    void eat();
}

class Animal{
    public void eat(){
        System.out.println("动物在吃东西");
    }
    public void getNum(){
        System.out.println("父类的方法");
    }
}

class Dog extends Animal implements MyInterface{
    public void say(){
        System.out.println("汪汪汪");
    }
}
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