Static Final Abstract

  1. static修饰方法
  2. static修饰变量或属性
  3. static修饰类
  • final
    1. final修饰数据
    2. final修饰方法
    3. final修饰类
  • abstract
    1. abstract类
    2. abstract类和接口的区别:
  • static字面上是表示静态的意思,可以修饰类方法,变量,对象。一般当需要某个类的时候需要实例化这个类,通过类的实例去得到类的属性或方法。

    首先java中类就是对现实的抽象,类中的字段表示一些属性,而通过方法来操作这些属性。但是有一种情况是类中所有的对象都具有同样的一个属性。打个比方,人是一个类,脑子是每个人都有的,因此每一个人要获取脑子这个字段就不需要实例化。 而身高则每个人都不同,因此需要具体的调用对象具体对待需要实例化。

    static修饰方法

    public int add(int n,int m){
            return 0;
        }
    
    public static void main(String[] args) {
            getNum(5);
            Solution solution = new Soltion();
            solution.add(1,2);   
         }
    
        private static void getNum(int n) {
            int res=0,temp=1;
            for (int i=1;i<=n;i++ ){
                temp= i * temp;
                res += temp;
            }
            System.out.println(res);
        }

    对应方法为静态方法时,如果在一个类中可以直接调用,不在的话通过类名.方法名调用,而对于非静态方法则只能先实例化然后再调用。因为静态方法在类加载的过程中就已经被分配了空间,而这个时候非静态字段或非静态方法还没分配空间(只有实例化类才会创建),因此根本访问不到,所以不能调用非静态方法,但是你可以实例化一个对象再调用。

    static修饰变量或属性

    static修饰变量或属性时同方法类似,静态方法或非静态方法均可以直接调用。

    static修饰类

    修饰类时,这个类不能实例化,类中只能有静态方法,一般是用来用作静态内部类,静态内部类就是与外部类没有关系,但是想隐藏一下自己。 具体参见官方文档。

    https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

    总结一下:

    static可以修饰类,方法,字段,静态方法和静态变量在类初始化就存放在方法区中,只会被加载一次,修饰类时一般用在内部类中。

    优缺点:

    优点: 对于频繁使用的方法或变量,只初始化一次。

    缺点:

    1. 直接加载到方法区内,不管使用与否都会存在,可能会存在内存浪费的情况。

    2. 静态变量属于共享变量,容易造成并发的问题,可以按照需求加上final或vilatile

    final

    final可以修饰数据,方法和类,字面意思是不可变,下面分别对修饰的三种类型进行说明

    final修饰数据

    final修饰数据时表示数据是不可变的,只能修饰基本类型的数据。

    private final int i=1;
    
        public int add(int n,int m){
            this.i=3;
        }

    使用上面的语句时会报错误,final类型的变量不能被修改。

    关于final和static final的区别:

    public class Test2 {
    
        private final int i=1;                              //编译时常量
        private static Random random=new Random(20);   
        private final int a = random.nextInt(10);           //运行时常量
        private static final int b= random.nextInt(10);     //编译时常量
    
        public static void main(String[] args) {
            Test2 test1=new Test2();
            System.out.println("test1:a="+test1.a);
            System.out.println("test1:b="+b);
            Test2 test2=new Test2();
            System.out.println("test1:a="+test2.a);
            System.out.println("test1:b="+b);
        }
    }
    -------------------------------------------------------
    test1:a=6
    test1:b=3
    test2:a=1
    test2:b=3

    可以看出来: a是变化的,b是不变的,用static修饰的只会初始化一次,这就是区别。

    final修饰对象时表示对象的引用不可变,但是对象的值可变。

      public class Test2 {
        private int i;
        public void set(int i){
            this.i=i;
        }
    
        public static void main(String[] args) {
            final Test2 test = new Test2();
            System.out.println(test.i);
            test.set(1);
            System.out.println(test.i);
            test=new Test2();                 //错误,不能更改final定义的对象的引用
        }
    
    }
    --------------------------------------------------
    0
    1

    final修饰方法

    修饰方法时表示该方法不能被重写,用final修饰可以确保该方法不会被任何继承类修改。

    所有的private方法默认都是final的,因为private的方法无法被覆盖

    final修饰类

    final类表示该类无法被继承,类中的方法默认都是final的。

    abstract

    abstract可以修饰类,方法。java中将不同类的相同的方法提取出来放到interface中来定义,但是接口中定义了很多种方法,有一些是通用的并不需要每个实现接口的类来实现,但是又有一些需要,抽象类就是在类和接口之间的一个中庸之道。

    abstract类

    类中含有抽象方法时必须将类定义为抽象的。其他类可以继承抽象类,抽象类中的抽象方法必须重写。

    abstract class A{
        public abstract void add(int a,int b);
    
        public int minus(int a,int b){
            return a-b;
        }
    
    }

    对于抽象方法只提供一个方法体,不提供实现。抽象类不能被实例化,只能被子类继承。

    abstract类和接口的区别:

    • abstract类中既可以有抽象方法也可以有非抽象方法,接口中只含有抽象方法(现在不是了)

    • 接口可以解决多继承的问题,抽象类不行

    • 一般来说抽象类的效率比接口的效率高一些,抽象子类可以直接调用类的方法;而接口还要去找具体的实现类。

    • 抽象层次不同:抽象类是对类抽象,而方法是对行为的抽象。抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。

    • 抽象类所抽象的是具有某些相似特点的类,而接口则可以是完全不同的类。抽象类是从子类中发现公共部分,然后泛化成抽象类,子类继承该父类即可。但是接口不同。实现它的子类可以不存在任何关系。例如猫、狗可以抽象成一个动物类抽象类,具备叫的方法。鸟、飞机可以实现飞Fly接口,具备飞的行为,这里我们总不能将鸟、飞机共用一个父类吧!所以说抽象类所体现的是一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在”is-a” 关系,即父类和派生类在概念本质上应该是相同的。对于接口则不然,并不要求接口的实现者和接口定义在概念本质上是一致的, 仅仅是实现了接口定义的契约而已

    • 对于抽象类,是知道子类才能抽象出父类,而接口不同,接口不需要知道子类的存在。比如接口定义一个fly的方法,它并不需要知道什么东西实现了这个接口,怎么实现也不管。


    本网站发布的一切文章仅限用于学习和研究目的;不得将上述内容用于商业或者非法用途,否则,一切后果请用户自负。本站信息来自网络,版权争议与本站无关。您必须在下载后的24个小时之内,从您的电脑中彻底删除上述内容。如果您喜欢该程序,请支持正版软件,购买注册,得到更好的正版服务。如有侵权请联系邮箱:1194325527@qq.com处理

    目录
    ×

    给作者杯卡布奇诺

    github