Java 面向对象高级部分(final, 抽象类 ,接口)

2021/5/8 22:26:27

本文主要是介绍Java 面向对象高级部分(final, 抽象类 ,接口),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Final关键字

使用情况:

1. 不希望类被继承,该类用final修饰
2.不希望类的某个方法被子类重写,可以将该方法用final修饰(final修饰 方法不可以被重写但是可以被重载)
3.不希望类的某个属性值被修改/不希望局部变量被修改 ,用final修饰
细节:
1.final修饰的属性又称为常量,一般用XX_XX_XX命名
2.final修饰的属性在定义时,必须赋值并且之后不可修改,赋值操作可以在以下任一位置(选择一个位置赋初值即可):
​​​​​​          ①定义时,如:public final double TAX_RATE = 0.08;
          ②在构造器中                       ③在代码块中
3.当final修饰的属性是静态的,则初始化位置只能是 ①定义时 ②在静态代码块中,不能在构造器中赋值
4.final类不能被继承,但是可以创建对象
5.类不被final修饰,但是类中的方法是final修饰,则该方法不可被重写,但是可以被继承
6.如果一个类已经被final,其中的类内方法就不需要被final修饰,因为类已经不能被继承了,方法就不可能被重写, 因此不需要用final修饰
7.构造器不允许被final修饰
8.final和static通常搭配使用,效率更高,不会导致类被加载
public class A{
    public static void main(String[] args) {
        AA a = new AA();
        System.out.println(a.name);
        System.out.println(a.age);
    }
}

class AA {
    public final static String name = "am";

    public static int age = 18;

    static{
        System.out.println("haha");
    }

}

9.包装类和String都是final修饰,不可被继承 

 

抽象类

引出抽象类:如果父类的一些方法不能确定,或者说你实现了方法体但是并没有什么意义,可以考虑将该方法用abstract修饰为抽象方法,抽象方法就是没有方法体的方法,当一个类中存在抽象方法时,就需要将该类用abstract修饰为抽象类,一般来说,抽象类会被继承,其抽象方法由子类实现 【抽象类的更多作用在于设计,在设计者设计好之后,由子类继承实现】

细节:

1.抽象类不能被实例化

2.抽象类可以没有抽象方法,如果一个方法为抽象方法,则包含该方法的类就必须为抽象类

3.abstract只能用来修饰类和方法,不能用来修饰属性和其他

4.抽象类可以有任意成员(抽象类还是类),比如非抽象方法,静态属性,构造器

5.抽象方法不能有主体, abstract public int kk(){};  ×   abstract public int kk(); √     相反的对于非抽象方法就必须实现方法体

6.如果一个类继承了抽象类,那它就必须实现全部抽象方法,除非他自己也声明为抽象类

7.抽象方法不能被final, private,static来修饰,因为这些关键字修饰的方法都不可以被重写,对于抽象类则不能被final修饰【static修饰的方法属于类成员,不能被重写,只能被重新定义】

 

模板设计模式【抽象类最佳实践】

抽象类作为子类的模板,当功能内部一部分实现是确定的一部分是不确定,则将不确定的方法暴露给子类,让其实现。编写一个抽象父类,父类提供了多个子类的通用方法,并把一个或者多个抽象方法留给子类让其实现,就是模板设计模式

需求:有多个类完成不同的任务,要求统计出各自完成任务的时间:

package example12;

abstract class Template {

    abstract public void job();

    public void currenttime(){
        Long start = System.currentTimeMillis();
        job();//动态绑定机制
        Long end = System.currentTimeMillis();
        System.out.println("任务执行时间:" + (end - start)+ "毫秒");

    }
}


class A extends Template{

    @Override
    public void job() {
        int k = 0;
        for (int i = 0; i < 1000000; i++) {
            k ++;
        }
    }
}

class B extends Template{
    @Override
    public void job() {
        int k = 0;
        for (int i = 0; i < 9000000; i++) {
            k ++;
        }
    }
}
//测试类
public class test {
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        
        a.currenttime();
        b.currenttime();
    }
}

 

接口 :给出一些没有实现的方法,封装到一起,到某个类要使用的时候,再把这些方法实现

在jdk7.0之前,接口中的方法都没有实现,没有方法体,即都是抽象方法

jdk8.0后,接口中可以有静态方法,默认方法(default),就是说可以有方法的具体实现。

public interface inface {
    //写属性  属性都是默认public static final修饰,所以必须赋初值
    int age = 10;
    //写方法,抽象方法可以省略abstract关键字
    public void job();

    //默认方法 default修饰, jdk8 后
    default public void say(){
        System.out.println("say");
    }
    //静态方法,jdk8 后
    public static void say1(){
        System.out.println("say1");
    }
}

注意事项和相关细节:

1.接口不能被实例化

2.接口中的所有方法都是public,其抽象方法可以不用abstract修饰

3.一个普通类实现接口,必须实现全部抽象方法

4.抽象类实现接口,可以不用实现方法

5.一个类可以实现多个接口

6.接口中的属性都是默认public static final修饰,所以必须赋初值。

7.接口中的属性的访问形式:接口名.属性名

8.一个接口不能继承其他的类,但是可以继承多个别的接口

9.接口的修饰符只能是public或者默认

10.接口具有多态特性,接口A的引用可以指向其实现类的对象,同时接口多态还具有传递性,如果该接口A继承了接口B则可以让接口B的引用指向接口A实现类的对象。

11.假如: class B extends A implements C, 实现类B访问接口C的属性用 C.变量名,访问A的属性就用super.xx

 

 

 



这篇关于Java 面向对象高级部分(final, 抽象类 ,接口)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程