Java学习

final关键字

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

final class Father{
	final String TYPE = "父亲";
	final void info(){
		System.out.println(TYPE);
	}
}

注意

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

native关键字

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

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

abstract关键字

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

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

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

抽象类

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

定义

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

继承

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

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;
    }
}

接口

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

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

定义

// 定义接口
[修饰符] interface 接口名{
	// 静态常量
	[public static final] 常量名 = 值;
	// 抽象方法
	[public abstract] 返回值类型 方法名(形参类型 形参);
	// 静态方法, 通过 接口.静态方法名调用
	[public] static 返回值类型 方法名(形参类型 形参){
		方法体;
	}
	// 默认方法, 通过 实现对象.默认方法名调用
	[public] default 返回值类型 方法名(形参类型 形参){
		方法体;
	}
}
// 实现接口
[修饰符] class 类名 [extends 父类] implements 接口1,接口2,...{
}

实现

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("汪汪汪");
    }
}