关键字final和static用法

最新推荐文章于 2024-03-25 22:32:23 发布
最新推荐文章于 2024-03-25 22:32:23 发布
阅读量381 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xixiyuguang/article/details/113586859
版权

目录

 

1.final

1.1修饰类

1.2修饰方法

1.3修饰方法

1.4修饰变量

2.static

2.1修饰成员变量

2.2修饰方法

2.3静态代码块

2.4修饰内部类

2.5static导入包

2.6static例子

2.6.1静态代码块

 2.6.2静态代码块和构造函数

2.6.3　　面试题（继承、静态代码块、构造函数、成员变量）

2.6.4static代码块多个按照顺序执行

 

1.final

主要用法有以下四种：

  1. 用来修饰数据：变量只能被赋值一次且它的值无法被改变。对于成员变量来讲，我们必须在声明时或者构造方法中对它赋值；

  2. 用来修饰方法参数：在变量的生存期中它的值不能被改变；

  3. 修饰方法：该方法无法被重写；（不常用）

  4. 修饰类：该类无法被继承extends。（不常用）

1.1修饰类

以下代码编译器直接报错

package finalstudy;

/**
 * @author yuguang
 * @date 2021/2/3 10:24
 * @description
 * todo final修饰类无法被继承
 */
public class TestFinal01 {

    public static void main(String[] args) {
        ManPeople man = new ManPeople();
        System.out.println(man.getAge());
    }
}

class ManPeople extends People {

}

final class People{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

1.2修饰方法

编译器报错

package finalstudy;

/**
 * @author yuguang
 * @date 2021/2/3 10:24
 * @description todo final修饰方法无法被重写override
 */
public class TestFinal02 {

    public static void main(String[] args) {
        People man1 = new ManPeople();
        System.out.println(man1.getNameAndAge());

        ManPeople man = new ManPeople();
        man.setAge(18);
        man.setName("xixi");
        System.out.println(man.getNameAndAge());
    }
}

class ManPeople extends People {

    @Override
    public String getNameAndAge() {
        return "不想告诉你";
    }
}

class People {
    private String name;
    private int age;

    public final String getNameAndAge() {
        return name + " : " + age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

1.3修饰方法

编译器报错代码

package finalstudy;

/**
 * @author yuguang
 * @date 2021/2/3 10:24
 * @description todo final修饰方法无法被重写,编译器直接报错
 */
public class TestFinal03 {

    public static void main(String[] args) {

        int age = 1;

        System.out.println(age++);

        System.out.println(++age);
        People man1 = new ManPeople();
        System.out.println(man1.getNameAndAge());

        ManPeople man = new ManPeople();
        man.setAge(18);
        man.setName("xixi");
        System.out.println(man.getNameAndAge());

        System.out.println(man.testFinal(18, "xixi"));
    }
}

class ManPeople extends People {

    @Override
    public String getNameAndAge() {
        return "不想告诉你";
    }
}

class People {
    private String name;
    private int age;

    public String testFinal(final int age, final String name) {
        name = "不告诉你";
        age = 18;
        return name + " : " + age;
    }

    //重载
    public String testFinal(final String name, final int age) {
        return name + " : " + age;
    }

    public String getNameAndAge() {
        return name + " : " + age;
    }

    //重载
    public final String getNameAndAge(String name) {
        return name + " : " + age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

1.4修饰变量

package finalstudy;

/**
 * @author yuguang
 * @date 2021/2/3 10:24
 * @description 
 * 包括成员变量和局部变量，该变量只能被赋值一次且它的值无法被改变。
 * 对于成员变量来讲，我们必须在声明时或者构造方法中对它赋值；
 */
public class TestFinal04 {
    private final String name = null;

    private final int age;

    public TestFinal04() {
        age = 0;
    }


    public static void main(String[] args) {
        //变量只能被赋值一次且它的值无法被改变
        final int age;
        age = 18;
        System.out.println(age);
//        age = 19; //报错

    }
}

 

2.static

引入地址（https://www.cnblogs.com/adeng/p/6971366.html）

java中static关键字主要有两种作用：

第一：为某特定数据类型或对象分配单一的存储空间，而与创建对象的个数无关。

第二，实现某个方法或属性与类而不是对象关联在一起。

简单来说，在java语言中，static主要有5中使用情况：成员变量、成员方法、代码块，内部类和静态导包。

基本用法：

  1. static修饰成员变量：该成员变量属于类变量，可以通过 ClassName.attributeName 直接引用，而不需要new出类的实例。
  2. static修饰成员方法：该方法属于类的方法，可以通过 ClassName.methodName 直接引用，而不需要new出类的实例。
  3. static修饰代码块：仅在类初始化的时候执行一次，且加载顺序是严格按照类中静态资源的定义顺序来加载的；静态代码块对于定义在它之后的静态变量，可以赋值，但是不能访问。；父类代码块->子类代码块。
  4. static修饰内部类：static不能修饰普通类，只能修饰内部类，被static修饰的内部类的创建方式： new OuterClass.InnerClass()。
  5. static导入包：语法“import static java.lang.Math.*”，这样在类中就可以直接使用Math类中的静态方法而不需要写类名，个人认为，在频繁使用某个类的时候比较方便，但是降低了可读性。并且不建议导入*

2.1修饰成员变量

public class TestStatic02 {
 
    public static void main(String[] args) {
        System.out.println(People.description);
        People.printDescription();
    }

}

class People {
    public static String description = "人";

    public static void printDescription() {
        System.out.println("输出介绍： "+description);
    }
}

2.2修饰方法

public class TestStatic02 {
   

    public static void main(String[] args) {
 

        System.out.println(People.description);
        People.printDescription();
    }

}

class People {
    public static String description = "人";

    public static void printDescription() {
        System.out.println("输出介绍： "+description);
    }
}

2.3静态代码块

package study_static;

//初始化的顺序 静态代码块 > 构造代码块 > 构造函数
// 只需要进行一次的初始化操作都放在static代码块中进行。
public class TestStatic03 {


    public static void main(String[] args) {
        PersonWithStatic withStatic = new PersonWithStatic();
        withStatic.setSexType(1);
        System.out.println(withStatic.getSexText());

        PersonNoStatic noStatic = new PersonNoStatic();
        noStatic.setSexType(2);
        System.out.println(noStatic.getSexText());

    }

}


class PersonWithStatic {
    private String sexText;
    private Integer sexType;

    //常量
    private static String woman;
    private static String man;

    static {
        man = "男";
        woman = "女";
    }

    public String getSexText() {
        if (sexType == 1) {
            sexText = woman;
        } else {
            sexText = man;
        }
        return sexText;
    }


    public Integer getSexType() {
        return sexType;
    }

    public void setSexType(Integer sexType) {
        this.sexType = sexType;
    }

    public static String getWoman() {
        return woman;
    }

    public static void setWoman(String woman) {
        PersonWithStatic.woman = woman;
    }

    public static String getMan() {
        return man;
    }

    public static void setMan(String man) {
        PersonWithStatic.man = man;
    }
}


class PersonNoStatic {
    private String sexText;
    private Integer sexType;

    private static String woman = "女";
    private static String man = "男";

    public String getSexText() {
        if (sexType == 1) {
            sexText = woman;
        } else {
            sexText = man;
        }
        return sexText;
    }


    public void setSexText(String sexText) {
        this.sexText = sexText;
    }

    public Integer getSexType() {
        return sexType;
    }

    public void setSexType(Integer sexType) {
        this.sexType = sexType;
    }

    public static String getWoman() {
        return woman;
    }

    public static void setWoman(String woman) {
        PersonNoStatic.woman = woman;
    }

    public static String getMan() {
        return man;
    }

    public static void setMan(String man) {
        PersonNoStatic.man = man;
    }
}

 

2.4修饰内部类

static一般用来修饰成员变量或函数也修饰代码块，一般不能修饰类，只有内部类才可以，被修饰的内部类可以直接作为一个普通类来用，不需要创建一个外部类的实例，而普通内部类的引用需要创建一个外部类的实例。

package study_static;

public class TestStatic05 {

    public static void main(String[] args) {

        //非静态内部类需创建一个父类的实例，方能new
        TestStatic05 father = new TestStatic05();
        Inner inner = father.new Inner();
        inner.print();

        //静态内部类可以直接new
        InnerStatic innerStatic = new InnerStatic();
        innerStatic.print();
    }

    class Inner {

        public void print() {
            System.out.println("Inner");
        }
    }

    static class InnerStatic {
        public static void print() {
            System.out.println("InnerStatic");
        }
    }
}

class Inner1 {

}

 

 

 

2.5static导入包

 

package study_static;


import static java.lang.Math.random;
import static java.lang.System.out;
  
/**
 * @author yuguang
 * @date 2021/2/4 9:28
 * @description static 导入包
 */
public class TestStatic06 {
    

    public static void main(String[] args) {

        double random = Math.random();
        out.println((int) (random * 10000));

        //直接引入Math下面static方法
        out.println(random());

        out.println(random());

 
    }
}

 

2.6static例子

2.6.1静态代码块

 


 
public class TestStatic04 {


    public static void main(String[] args) throws ClassNotFoundException {

        Class<?> aClass = Class.forName("study_static.People1");
 
//        System.out.println(People1.description);
//        People1.printDescription();
    }

}

class People1 {
    //静态代码块
    static {
        System.out.println("People1 init ,static code");
    }

    //静态变量
    public static String description = "人";

    //静态方法
    public static void printDescription() {
        System.out.println("输出介绍： "+description);
    }

    //空构造方法
    public People1() {
        System.out.println("constructor");
    }
}

 2.6.2静态代码块和构造函数

静态代码块中：父>子

等级：    静态代码块>构造函数

package study_static;

public class demo2 extends Base {

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

    public demo2() {
        System.out.println("test constructor");
    }

    public static void main(String[] args) {
        new demo2();
    }
}

class Base {
     
    static {
        System.out.println("base static");
    }

    public Base() {
        System.out.println("base constructor");
    }
}

2.6.3　　面试题（继承、静态代码块、构造函数、成员变量）

在一个类中： 静态代码块  > 成员变量 > 构造函数

父 > 子：如父的 静态代码块、成员变量、构造函数   大于子的

package study_static;

/**
 * 　类似地，我们还是来想一下这段代码的具体执行过程。首
 * 1-先加载Test类，因此会执行Test类中的static块。
 * 2-接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，
 * 发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。
 * 在加载完之后，就通过构造器来生成对象。而在生成对象的时候，
 * 3---必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，
 * 而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，
 * 然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。
 */
//todo 静态代码块存在内存中只加载一次
public class Test {
    Person person = new Person("---4---Test");

    static {
        System.out.println("1---test static");
    }

    public Test() {
        System.out.println("5----test constructor");
    }

    public static void main(String[] args) {
        new MyClass();
    }
}

class MyClass extends Test {
    Person person = new Person("----6----MyClass");

    static {
        System.out.println("2----myclass static");
    }

    public MyClass() {
        System.out.println("7----myclass constructor");
    }
}

class Person {
    static {
        System.out.println("3----person static");
    }

    public Person(String str) {
        System.out.println("person " + str);
    }
}

2.6.4static代码块多个按照顺序执行

public class demo3 {

    static{
        System.out.println("test static 0");
    }
    static{
        System.out.println("test static 1");
    }
    public static void main(String[] args) {

    }

    static{
        System.out.println("test static 2");
    }

    static{
        System.out.println("test static 3");
    }
}

参考资料：

https://www.cnblogs.com/tonyluis/p/5582529.html

https://www.cnblogs.com/dolphin0520/p/3799052.html

https://www.cnblogs.com/dolphin0520/p/3799052.html

于光yuguang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【java基础】static和final关键字的作用及其用法详解
秃头披风侠的博客
02-26 1262
对于外部类和静态内部类可以相互访问静态变量和方法，静态内部类可以直接通过字段名或者方法名访问外部类中的static字段、方法，如果出现命名冲突，那么就需要使用外部类名.静态字段(方法)进行访问。对于静态内部类，我们简单一点理解就是静态内部类和外部类没有关系即可，都只能互相访问静态字段和方法，静态内部类的创建并不需要外部类的实例化。上面的B继承了A，并且重写了A类中的show方法，但是A类中show方法使用final修饰，这时，编译器提示以下信息。对于类的字段使用final修饰，必须在定义的时候就进行赋值。
Java关键字final、static使用总结
liuyu2783的博客
10-27 748
一、final 根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。 final类不能被继承，没有子类，final类中的方法默认是final的。 final方法不能被子类的方法覆盖，但可以被继承。 final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 fin
Java中static、final关键字【详解】
最新发布
qq_44700578的博客
03-25 1167
java中static、final关键字详解，概述、定义、使用、访问
JAVA之static与final用法
老布丁的博客
03-13 1057
1.final关键字 1.1.final关键字修饰变量 （1）类加载时执行顺序 static代码块>代码块>构造器 该关键字可以在定义时赋值，可以在静态代码块中赋值，可以在代码块中赋值，以及在构造器中赋值。 必须要有值 （2）如果是基本数据类型的数据，该变量一旦赋值，便相当于一个常量。 （3）如果是引用数据类型的变量，初始化后不能更改他的引用，但可以更改引用对象的值。 1.2.final关键字修饰方法 （1）表明该方法不能被子类重写，防止类修改他的含义 （2）与static比较
final关键字和static_用法
11-25
java 关键字final和static
java多线程关键字final和static详解
08-25
Java多线程关键字final和static详解 Java多线程编程中，final和static关键字扮演着非常重要的角色，它们可以帮助开发者编写更加安全、可靠的多线程程序。在本文中，我们将深入探讨final和static关键字在Java多线程...
浅析对Java关键字final和static的理解
08-30
首先，`final`关键字在Java中具有三个主要用途：修饰类、方法和变量。 1. **final修饰类**： 当一个类被声明为`final`时，这意味着它不能被其他类继承。这样做可以保护类的设计不被改变，通常用于那些设计完成并且...
详解Java编程中static关键字和final关键字的使用
09-03
Java编程中的`static`关键字和`final`关键字是两个非常重要的概念，它们分别代表不同的特性。首先，我们来看`static`关键字。 `static`关键字用于声明静态变量和静态方法。静态变量，也称为类变量，属于类本身而...
final关键字和static关键字
hzw_mvp的博客
05-15 1097
final关键字 1、被final修饰的类不可以被继承 2、被final修饰的方法不可以被重写 3、被final修饰的变量不可以被改变 static的作用 1、修饰成员变量 给变量加上static关键字后，此变量变为全局变量，JVM在加载时会直接将此变量加载到方法区里而不是堆里，无论哪一个方法修改了此变量，此变量就会改变，可以让对象共享属性并且，当再次new该类的对象时，static修饰的类成员不...
static与final关键字
陈如水的专栏
07-14 3732
在Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。 1、修饰类:  当用final修饰一个类时，表明这个类是最终类，不能被继承。如果一个类你不想让它被继承，就可以用final进行修饰。 2、修饰方法：使用final修饰的方法不能被子类重写。(最终方法) 3、修饰变量: 对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果
Java中final、static关键字的作用
总结经验，与君共勉
12-15 3178
final关键字可用于三个地方： 用于修饰类、类属性和类方法。 被final修饰的类不能被继承，被final修饰的类属性和类方法不能被覆盖（重写）； 一、final 1. final修饰变量： final意为不可改变，修饰成员变量时可以在生命时初始化或者在构造函数中初始化，修饰局部变量时在使用之前初始化。要是企图改变final修饰等变量值则会编译错误 2. final修饰方法： final修饰的方...
【面试篇】Java中static和final关键字的作用是什么？
Mind_programmonkey的博客
11-28 2108
1.Java中final关键字的作用？ final的意思是最终，不可变的。是一个修饰符，可用来修饰类、类的成员以及局部变量； final修饰的类，该类不能被继承 被final修饰的类，final类中的成员变量可以根据自己的实际需要设计为final； 被final修饰的类，final类中的成员方法都会被隐式的指定为final方法； 在JDK中，被设计为final类的有String、System。 被final修饰的方法不能被重写 注：类的private方法会隐式地被指定为final方法。 fin
Java学习之final修饰符（成员变量，局部变量，基本与引用类型变量，方法和类）
爱科比的博客
06-11 3663
本文主要讲述内容： final成员变量 final局部变量 final修饰基本类型变量和引用类型变量的区别 “宏替换”的final final方法 final类 1.final成员变量 final指定的成员变量必须由程序员显式的进行指定初始值 归纳总结：final修饰的类变量，实例变量指定初始值的位置如下。 类变量：必须再静态初始化...
JAVA入门级教学之（final关键字）
LBJ8888888的博客
02-27 342
新建一个User类 package com.lbj.javase12; public class User { public int id; public User() { super(); } public User(int id) { super(); this.id = id; } } 新建一个测试类 package com.lbj.javase12;...
Java中static 和 final关键字的基本用法
qq_46152881的博客
11-22 278
一、static 1、static修饰变量 即静态变量， public class Person { private static int sum = 0; private String name; public Person(String name) { this.name = name; sum++; } public static void main(String[] args) { // TODO Auto-generated method stub Person[] pe
Java关键字final、static、abstract使用总结
u013842976的博客
05-10 4116
一、final 根据程序上下文环境，Java关键字final有“无法改变”或者“终态”的含义，它可以修饰非抽象类、非抽象类成员方法和变量。final类不能被继承，没有子类，final类中的方法默认是final的。 final方法不能被子类的方法覆盖，但可以被继承。 final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 final不能用于修饰构造方法
final和static关键字
04-27
`final`和`static`是Java中的关键字，它们都可以用来修饰变量、方法和类。 `final`关键字表示不可变的，一旦被赋值后就不能再被修改。在变量上使用`final`关键字时，必须在声明时或在构造函数中进行初始化。在方法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值