(六) 面向对象 - static关键字

最新推荐文章于 2023-02-10 14:13:57 发布
最新推荐文章于 2023-02-10 14:13:57 发布
阅读量146 收藏
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43341842/article/details/113446974
版权
本文详细介绍了Java中的`static`关键字及其在方法、成员变量、代码块和内部类上的应用，强调了静态成员的加载时机和共享特性。同时，文章深入探讨了单例模式的概念、优点和应用场景，包括饿汉式和懒汉式的实现，并分析了多线程下可能出现的安全问题。最后，提到了静态和非静态代码块的执行顺序，以及它们在类加载过程中的角色。
摘要由CSDN通过智能技术生成

一、static关键字

 

1、介绍：

译为静态，可以作用在方法，成员变量，代码块上，内部类。

随着类的加载而加载 ，优先于对象存在，因此静态方法不能调用非静态方法、实例变量、非静态内部类，反过来是可以的。

 

2、作用：

 
作用在方法上：

访问权限允许时，可不创建对象，直接被类调用。

public class User{
    ...
    public static void print(){
        System.out.println("打印信息!");
    }    
    ...
}

public class Test{
    
    public static void main(String[] args){
        User.print();
    }
}

 
作用在成员变量上：

同一个类的不同对象共享该成员变量。

public class User{
    private static int value = 0;
    ...
   
    public void setValue(int value1){
        value = value1;
    }
    
    public int getValue(){
        return value;
    }
}

public class Test{
     public static void main(String[] args){
         User user1 = new User();
         User user2 = new User();
         
         user1.setValue(1);
         System.out.println(user1.getValue()); //1
         System.out.println(user2.getValue()); //1
         
     }
    
}

 
作用在代码块上：

随着类的加载而加载，且只执行一次。

public class Parent {
			
	static {
		System.out.println("我是静态代码块");
	}
			
			   
			
	public Parent(){
		System.out.println("我是构造方法");
	}
}


public class Test{
    public static void main(String[] args){
        Parent parent1 = new Parent();
        
        Parent parent2 = new Parent();
    }
}

打印信息:

我是静态代码块
我是构造方法
我是构造方法

 

作用在内部类上：

定义在类内部，当外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的，并且只要内部类不需要访问外围类对象，就应该使用静态内部类。

public class ArrayAlg {

    public static class Pair{
        private double first;
        private double second;

        public Pair(double first, double second) {
            this.first = first;
            this.second = second;
        }

        public double getFirst() {
            return first;
        }

        public void setFirst(double first) {
            this.first = first;
        }

        public double getSecond() {
            return second;
        }

        public void setSecond(double second) {
            this.second = second;
        }
    }

    public static Pair minmax(double[] values){
        double min = Double.POSITIVE_INFINITY;
        double max  = Double.NEGATIVE_INFINITY;

        for(double v : values){
            if(min > v) min  = v;
            if(max < v) max = v;

        }

        return new Pair(min,max);
    }

    public static void main(String[] args) {

        ArrayAlg.Pair minmax = ArrayAlg.minmax(new double[]{1.1, 4.5, 6.7, 8.9});
        System.out.println("min = " + minmax.getFirst() + " max = " + minmax.getSecond());
    }
}

 
 

二、单例模式

 

1、介绍：

对于某个类使其只存在一个对象：

​ 构造方法定义为私有的。

​ 定义一个私有的成员变量，定义为static。

​ 定义一个静态方法，获取这个变量。

 
优点：只生成一个对象，减少系统的性能开销。

 
 

2、应用场景：

  • 网站的计数器，一般也是单例模式实现，否则难以同步。

  • 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志 文件一直处于打开状态，
    因为只能有一个实例去操作，否则内容不好追加。

  • 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库 资源。

  • 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置 文件数据，都生成一个对象去读取。

  • Application 也是单例的典型应用 。

 

3、饿汉式：

class Single{

	private static Single a = new Single();
	private Single(){
	}
			
	public static Single instance(){
		return a;
	}
}

 

4、懒汉式：

class Single{
	
	private static Single a ;
	private Single(){
        
	}
			
	public static Single instance(){
		if(a == null){
            a = new Single();
        }
        return a;
	}
}

 
问题：在多线程情况下，会出现线程安全问题。

public class Single{
   
    private static Single a ;
    private Single(){

    }

    public static Single instance(){
        if(a == null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            a = new Single();
        }
        return a;
    }

    public static void main(String[] args) {


        for(int i = 0; i < 1000; i++){
            new Thread(()->{
                System.out.println(Single.instance().hashCode()); 
                //默认的hashCode值为地址计算后的结果，地址相同值是一样的。
            }).start();
        }
        
    }
}

结果:
2051899962
1802975985
2051899962
1802975985
1802975985
1802975985
1802975985
1802975985
1375911728
1375911728
1375911728
1375911728
1375911728
...

 

5、DCL单例：

双重检查机制

class Single{
	
	private static Single a ;
    
	private Single(){
        
	}
			
	public static Single instance(){
			if(a == null){
                synchronized (Single.class){
                    if(a == null){
            			a = new Single();
                    }
                }
        }
        	return a;
	}
}

问题：由于new对象的操作不是原子性的，会存在指令重排序的情况。代码最终会被编译成多条汇编指令。
（1）给Single的实例分配内存
（2）调用Single()的构造函数，初始化成员字段
（3）将a对象指向分配的内存空间

 

6、 volatile的DCL

class Single{
	
	private  static volatile Single a ;
    
	private Single(){
        
	}
			
	public static Single instance(){
			if(a == null){
                synchronized (Single.class){
                    if(a == null){
            			a = new Single();
                    }
                }
        }
        	return a;
	}
}

 
 

三、代码块

 

1、静态代码块：

 
格式：

public class User{
    ....
    static {
        ....
    }    
    ....
}

 
特点：

  1. 可以有输出语句。

  2. 可以对类的属性、类的声明进行初始化操作。

  3. 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。

  4. 若有多个静态的代码块，那么按照从上到下的顺序依次执行。

  5. 静态代码块的执行要先于非静态代码块。

  6. 静态代码块随着类的加载而加载，且只执行一次。

 
 

2、代码块：

 
格式：

public class User{
    ....
    {
        ....
    }    
    ....
}

 
特点：

  1. 可以有输出语句。

  2. 可以对类的属性、类的声明进行初始化操作。

  3. 除了调用非静态的结构外，还可以调用静态的变量或方法。

  4. 若有多个非静态的代码块，那么按照从上到下的顺序依次执行。

  5. 每次创建对象的时候，都会执行一次。且先于构造器执行。

 
 

3、执行顺序：

 
顺序：

类变量和静态代码块的级别相同，那个在前，那个先执行

实例变量和代码块的级别相同，那个在前那个先执行。

先初始化父类的静态代码 -> 子类的静态代码 (如果不创建实例，后面将无意义) ->

父类的非静态代码 -> 父类的构造方法 -> 子类的非静态代码 -> 子类的构造方法

 
示例：

public class Parent {
			
	static {
		System.out.println("我是父类的静态代码块");
	}
			
	{
		System.out.println("我是父类的非静态代码块");
	}
			
	public Parent(){
		System.out.println("我是父类的构造方法");
	}
}
			 
public class Son extends Parent{
			
			
	static {
		System.out.println("我是子类的静态代码块");
    }
			
	{
		System.out.println("我是子类的非静态代码块");
	}
			
	public Son(){
		System.out.println("我是子类的构造方法");
	}
			
}

 
测试结果：

Son son = new Son();
				 
我是父类的静态代码块
我是子类的静态代码块
我是父类的非静态代码块
我是父类的构造方法
我是子类的非静态代码块
我是子类的构造方法

 
 
参考资料：

尚硅谷资料，博客，马士兵老师公开课等。

碧海暮苍梧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++学习6：static关键字
慢慢积累
06-29 875
c++中的static用于定义静态变量、函数，特点是在程序开始时分配空间，结束时释放空间，默认初始化为0。 1.静态局部变量 对于一个完整的程序，其内存分布情况如下图： 当定义一个局部变量时，会存储在栈中。使用static能够改变存储方式，在变量前增加static，该变量的存储空间将变为静态存储区，即数据段或BSS段，存储在该区域的数据只有在程序结束时才被释放，不会因函数退出释放空间。
第6关：static关键字------Java面向对象 - 类与对象
m0_63324772的博客
12-30 1125
package step5; public class Test { /********** Begin **********/ static String name = "楚留香"; static{ System.out.println("hello educoder"); } public static void main(String[] args) { System.out.println("我叫" + name); study(); } public static v.
第6次作业--static关键字、对象.
baijianfeng1978的博客
09-18 163
题目1：编写一个类Computer，类中含有一个求n的阶乘的方法。将该类打包，并在另一包中的Java文件App.java中引入包，在主类中定义Computer类的对象，调用求n的阶乘的方法（n值由参数决定），并将结果输出。 ··· Computer .java package cn; public class Computer { public int a; public int mul...
6、static关键字
S_壮
03-01 153
  一、static关键字       static是一个修饰符，用于修饰成员（成员变量和成员函数）   二、被修饰后的成员具备以下特点   随着类的加载而加载，也就是说：静态会随着类的消失而消失。说明它的生命周期最长 优先于对象存在，明确一点：静态是先存在的，对象是后存在的 被所有对象所共享 可以直接被类名调用 三、使用注意 静态方法只能访问静态成员，因为静态方法...
【第六章 static关键字、单例设计模式、main()方法】
qq_43742813的博客
09-03 145
第六章 static关键字、单例设计模式、main()方法
【Java之旅】6.static关键字
hmmm？
01-26 181
【Java之旅】6.static关键字 6.1 static关键字 ①意思 static意为静态的，用它来修饰成员变量和成员方法，在类加载阶段，这些被修饰的成员变量和成员方法，将会被载如JVM中的方法区内存空间中。 静态变量只有一个，被类所拥有，所有的对象都共享这个静态变量，而实例对象与具体对象有关。 如果有一个类，我们希望所有创建这个类型的对象的属性的值都是一样的，并且不对他进行修改，那么如果我们每创建一个新的对象，就会去重复 创建这个属性的内存空间，这样做会很浪费内存空间。 但如果给这个类中的某个属性前
Java面向对象（高级）- static关键字的使用
最新发布
11-16
Java中的`static`关键字是面向对象编程中的一个重要概念，它用于修饰类的成员变量和成员方法，以及静态初始化块。在Java中，`static`关键字具有以下几个核心特点和用途： 1. **类属性与类方法的设计思想**： 类的...
JavaOOP-04-static关键字笔记.pdf
07-27
Java中的`static`关键字是一个非常重要的概念，它在面向对象编程中扮演着核心角色。`static`关键字可以用于修饰变量、方法和代码块，每种修饰都有其特定的用途和意义。 首先，让我们来理解一下`static`修饰的变量，...
面向对象|static关键字
01-21
构造方法：对对象的数据进行默认初始化； 格式： 方法名与类名相同； 没有返回值类型，没有viod; 没有具体的返回值； 如果我们没有给出构造方法，系统会自动提供一个无参构造方法； 如果我们给出了构造方法，系统将...
面向对象基础-static关键字
09-06
面向对象编程语言中，`static`关键字是一种非常重要的机制，它允许我们定义静态成员和静态方法，这些成员和方法不属于任何特定的对象实例，而是属于类本身。在Java中，`static`关键字主要用于以下三个方面：静态变量...
《看不懂你打我系列》 之 —— 单例模式（DCL + 静态内部类实现）
vcj1009784814的博客
07-14 300
定义 ： 一个类在全局范围内只有一个实例对象，程序在需要使用该类时，获取到的都是同一个实例对象 实现步骤： 类的内部创建一个静态的实例对象 类的构造方法设为private 提供一个静态的方法（一般命名为getInstance），获取唯一的实例对象 实现方式： 饿汉式单例： 类加载的时候就直接创建出实例对象，表现的像是一个非常饥饿的汉子，迫不及待地创建出类的实例对象。因为类的加载过程是线程安全...
双检锁DCL与静态内部类实现单例模式的原理解析
马迪奥的小窗
05-21 993
双检锁实现单例模式 将上锁粒度降低到了仅仅是初始化实例的那部分，保证线程安全，提高执行效率。 双检锁的机制出现确实解决了多线程并行中不会出现重复的new对象，实现了懒加载，但是，因为jvm存在一个无序写的问题，原因在于： instance=new DoubleCheckedLock()这行代码在不同编译器上的行为是无法预知的。 编译器可能会有如下实现： 1. 给新的实体inst...
【Java基础】第6章_面向对象（下）-1：static关键字、main方法、代码块、final关键字
欢迎点赞 评论 关注
12-16 124
关键字：static static的使用 类变量 vs 实例变量内存解析 自定义 ArrayUtil工具类的优化 static 的应用举例 理解main方法的语法 代码块 代码块(初始化块)的使用 静态代码块的举例 总结：程序中成员变量赋值的执行顺序 关键字：final final的使用
Java基础学习第六节——面向对象，static关键字，包的使用
WC名字好难取的博客
11-22 324
面向对象概念 1 课程介绍 1.了解什么是面向对象（了解） 2.理解什么是类与对象（掌握） 3.类的设计（掌握） 4.对象的创建与赋值（掌握） instance (实例)对象 构造方法（构造器-构造函数 ）（掌握） static 修饰符 包（理解概念和作用） 2 初识面向对象 我们所说的面向对象是一种编程思想，什么是编程思想呢？让你如何去设计程序，同时也...
static静态关键字详解(工具类、代码块、单例模式)
weixin_53622554的博客
02-10 3542
静态成员变量(类变量)静态方法（类方法）。可以被类的所有对象共享（访问、修改）
第6节 Static静态
Django
08-13 108
Static静态 1.static关键字概述 一旦使用了static关键字，那么这样的内容不再属于对象自己，而是属于类的。 所以凡是本类的对象，都共享同一份 package day08; public class Student { private String name;//姓名 private int age;//年龄 static String room;//所在教室 private static int idCounter = 0;//学号计数器，当新建对象时，计数器++ private
[java]static关键字的四种用法
热门推荐
aoba5147的博客
01-29 1万+
在java的关键字中，static和final是两个我们必须掌握的关键字。不同于其他关键字，他们都有多种用法，而且在一定环境下使用，可以提高程序的运行性能，优化程序的结构。下面我们先来了解一下static关键字及其用法。 static关键字 1.修饰成员变量 在我们平时的使用当中，static最常用的功能就是修饰类的属性和方法，让他们成为类的成员属性和方法，我们通常将用static...
面向对象练习
samuBO的博客
08-15 356
//1、抽象类和接口的区别？ /** * 抽象类可以有构造函数，接口不可以有构造函数 抽象类中可以有普通成员变量，接口中没有普通成员变量，只能有常量 抽象类中的方法可以被static修饰，接口中的方法不可以被static修饰 抽象类中可以有普通方法和抽象方法，接口中的方法全是抽象方法 抽象中的方法可以被public,protected等修饰符修饰，接口中的方法全都是pub...
java 高级 选择题_java高级选择题
weixin_28836875的博客
02-16 3297
题目选项A选项B选项C选项D答案LinkedList常用的方法例如：Object getLast()在集合的首部添加元素在集合的尾部添加元素返回集合中的第一个元素返回集合中的最后一个元素D在JAVA的以下的变量赋值语句中，无法通过编译的是_____。char c1=”男”；char c2=’女’;int f1=128;double d1=1.2;A获取ResultSet对象rst的下一行数据,以下...
Java面向对象：static关键字详解
本课程主要讲解Java中的面向对象编程，特别是`static`关键字的使用。面向对象设计思想强调隐藏/封装、继承和多态，而Java正是这样一种面向对象的语言，其中一切皆为对象。对象是类的实例，包含静态属性（成员变量）...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值