Java中final关键字和抽象类

1.1 final

final关键字的作用：

1. 修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。

final  int   MAX_SPEED = 120;

1. 修饰方法：该方法不可被子类重写。但是可以被重载！

final  void  study(){}

1. 修饰类: 修饰的类不能被继承。比如：Math、String、System等。

final   class  A {}

public final class Maths {
    //常量的命名规则全部大写

    private  Maths() {
        //使其不不能够new Maths
        //出来Maths类不能够new对象
        //final 不能够修饰构造方法
    }
    public static final double PI = 3.14;

    public final double abs(double d) {
        if (d > 0) {
            return d;
        }else{
            return -d;
        }
    }
    public double pow(int n,int m){
        double result=1;

        for (int i = 1; i < m; i++) {
            result *= n;
        }
        return result;
    }
}
//final类不能够有子类
//常见的final类
// String  System  Math
//class SubMaths extends Maths{
//    @Override
//    public double abs(double d) {
//        return super.abs(d);
//    }

//    @Override
//    public double pow(int n, int m) {
//        return super.pow(n, m);
//    }
//}

public class Test {
    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(Math.PI);
        System.out.println(Math.abs(-5));
        System.out.println(Math.pow(2, 5));
        String str;
        //Maths.PI=3.15;//不能够重新赋值
        System.out.println(Maths.PI);


    }
}

1. 注意：final不能修饰构造方法
2. final修饰基本数据类型,值只能赋值一次，后续不能再赋值
3. final修饰引用数据类型，final Dog dog = new Dog("亚亚");，不能变化的引用变量的值，可以变化的是对象的属性

1.2 抽象类

例子：比如动物类，动物类中有Dog、Bird等等，但是动物是抽象泛泛的概念是不能被实例化的

利用abstract可以使得抽象类不能被new

·抽象方法

       使用abstract修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

·抽象类

      使用abstract修饰的类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

抽象类不能new

问题1：Animal an = new Animal();没有一种动物，名称是Animal，所以Animal不能被实例化

解决：抽象类
问题2：子类必须重写父类的某个方法，否则出现编译错误
解决：抽象方法

抽象方法没有方法体

/**
 * 一个抽象类最少0个抽象方法  使得抽象类不能new
 *
 * 最多所有方法都是抽象的（不包括构造方法）
 *
 */
public  abstract class Animal {
    private String color;

    public Animal() {

    }

    public Animal(String color) {
        this.color = color;
    }

    /**
     *抽象方法 定义了一个功能
     * 没有给出实现，必须要求子类给实现
     */
    public abstract void shout();
//    public void shout() {
//        System.out.println("------发出声音------");
//
//    }
}

/**
 * @override
 * 1.非抽象方法 要override
 * 2.抽象方法要implement（实现）
 */

public class Dog extends Animal {
    public Dog() {
      super();
    }
//提醒必须要重写，不重写会报错
    //父类的方法定义为抽象方法

    @Override
    public void shout() {
        System.out.println("-----汪汪汪------");
    }

    @Override
    public String toString() {
        return super.toString();
    }

    public static void main(String[] args) {
        //动物是泛泛的，是抽象的，所以希望Animal不能new

        //Animal an = new Animal();

        Dog dog = new Dog();
        dog.shout();

    }
}

抽象类的使用要点:

1. 有抽象方法的类只能定义成抽象类
2. 抽象类不能实例化，即不能用new来实例化抽象类。
3. 抽象类必须有构造方法，创建子类对象的时候使用
4. 一个抽象类至少0个抽象方法，至多（所有的方法都是抽象方法）个抽象方法
5. 子类必须重写父类的抽象方法，不重写就提示编译错误；或者子类也定义为抽象类
6. override 重写   implements 实现
     父类的方法是抽象的，需要子类实现；父类的方法不是抽象的，子类可以重写
7. 创建抽象方法时，使用abstract关键字后不能使用static