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
     

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值