Java超详细透彻讲解static

目录
  • 1. 引入
  • 2. 理解
  • 3. 使用
    • 3.1 使用范围
    • 3.2 static修饰属性
      • 3.2.1 设计思想
      • 3.2.2 分类
      • 3.2.3 注意
      • 3.2.4 举例
      • 3.2.5 类变量内存解析
    • 3.3 static修饰方法
      • 3.3.1 设计思想
      • 3.3.2 理解
      • 3.3.3 使用
      • 3.3.4 注意
      • 3.3.5 举例
  • 4. 注意
  • 5. 单例 (Singleton)设计模式
    • 5.1 概述
    • 5.2 优点
    • 5.3 单例设计模式-饿汉式
    • 5.4 单例设计模式-懒汉式
    • 5.5 应用场景

1. 引入

当我们编写一个类时,其实就是在描述其对象的属性和行为,而并没有产生实质上的对象, 只有通过new关键字才会产生出对象,这时系统才会分配内存空间给对象,其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下,某些特定的数据在内存空间里只有一份。

例如所有的中国人都有个国家名称,每一个中国人都共享这个国家名称,不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。

2. 理解

static:静态的

3. 使用

3.1 使用范围

在Java类中,可用static修饰属性、方法、代码块、内部类

3.2 static修饰属性

3.2.1 设计思想

类属性作为该类各个对象之间共享的变量。在设计类时,分析哪些属性不因对象的不同而改变,将这些属性设置为类属性。相应的方法设置为类方法。

3.2.2 分类

属性,按是否使用static修饰,又分为:

静态属性(静态变量或类变量)vs 非静态属性(实例变量)

实例变量:我们创建了类的多个对象,每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时,不会导致其他对象中同样的属性值的修改。

静态变量:我们创建了类的多个对象,多个对象共享同一个静态变量。当通过某一个对象修改静态变量时,会导致其他对象调用此静态变量时,是修改过了的。

3.2.3 注意

静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用。

静态变量的加载要早于对象的创建。

修饰的成员,被所有对象所共享。

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

由于类只会加载一次,则静态变量在内存中也只会存在一份:存在方法区的静态域中。

无论创建多少个对象,静态数据都只占用一份存储区域。

static关键字不能应用于局部变量, 因此它只能作用于域。

① 如果一个域是静态的基本类型域,且也没有对它进行初始化,那么它就会获得基本类型的标准初值。

② 如果它是一个对象引用,那么它的默认初始化值就是null

静态变量与实例变量可修饰的范围区别:

  静态变量 实例变量
yes no
对象 yes yes

3.2.4 举例

静态属性举例: ① System.out;Math.PI;

应用举例:

应用举例1:

public class Test1 {
    public static void main(String args[]) {
                Circle c1 = new Circle(2.0);
                Circle c2 = new Circle(3.0);
                c1.display();//name:这是一个圆radius:2.0
                c2.display();//name:这是一个圆radius:3.0
    }
}
class Circle {
    private double radius;
    public static String name = "这是一个圆";
    public static String getName() {
        return name;
    }
    public Circle(double radius) {
        this.radius = radius;
    }
    public double findArea() {
        return Math.PI * radius * radius;
    }
    public void display() {
        System.out.println("name:" + name + "radius:" + radius);
    }
}

应用举例2:

class Person {
   private int id;
   public static int total = 0;
   public Person() {
     total++;
     id = total;
}
    public static void main(String args[]){
      Person Tom=new Person();
      Tom.id=0;
      total=100; // 不用创建对象就可以访问静态成员
    }
}

应用举例3:

public class StaticDemo {
    public static void main(String args[]) {
      Person.total = 100; // 不用创建对象就可以访问静态成员
      //访问方式:类名.类属性,类名.类方法
      System.out.println(Person.total);
      Person c = new Person();
      System.out.println(c.total); //101
    }
}

3.2.5 类变量内存解析

图解1:

图解2:

3.3 static修饰方法

3.3.1 设计思想

如果方法与调用者无关,则这样的方法通常被声明为类方法,由 于不需要创建对象就可以调用类方法,从而简化了方法的调用。

3.3.2 理解

static修饰方法为静态方法。

3.3.3 使用

没有对象的实例时,可以用类名.方法名()的形式访问由static修饰的类方法。

静态方法与非静态方法可修饰的范围区别:

  静态方法 非静态方法
yes no
对象 yes yes

3.3.4 注意

因为不需要实例就可以访问static方法,因此static方法内部不能有this。(也不能有super)

static修饰的方法不能被重写。

静态方法中,只能调用静态的方法或属性。

非静态方法中,既可以调用非静态的方法或属性,也可以调用静态的方法或属性。

3.3.5 举例

public class StaticTest {
	public static void main(String[] args) {
		Chinese.nation = "中国";
		Chinese c1 = new Chinese();
		c1.name = "姚明";
		c1.age = 40;
		c1.nation = "CHN";
		Chinese c2 = new Chinese();
		c2.name = "马龙";
		c2.age = 30;
		c2.nation = "CHINA";
		System.out.println(c1.nation);//CHINA
		//编译不通过
//		Chinese.name = "张继科";
		c1.eat();
		Chinese.show();
		//编译不通过
//		Chinese.eat();
//		Chinese.info();
	}
}
//中国人
class Chinese{
	String name;
	int age;
	static String nation;
	public void eat(){
		System.out.println("中国人吃中餐");
		//调用非静态结构
		this.info();
		System.out.println("name :" +name);
		//调用静态结构
		walk();
		System.out.println("nation : " + nation);
	}
	public static void show(){
		System.out.println("我是一个中国人!");
		//不能调用非静态的结构
//		eat();
//		name = "Tom";
		//可以调用静态的结构
		System.out.println(Chinese.nation);
		walk();
	}
	public void info(){
		System.out.println("name :" + name +",age : " + age);
	}
	public static void walk(){
	}
}

4. 注意

关于静态属性和静态方法的使用,可都从生命周期的角度去理解。

开发中,如何确定一个属性是否要声明为static的?

属性是可以被多个对象所共享的,不会随着对象的不同而不同的。

类中的常量也常常声明为static

开发中,如何确定一个方法是否要声明为static的?

操作静态属性的方法,通常设置为static的。

工具类中的方法,习惯上声明为static的。 比如:MathArraysCollections

5. 单例 (Singleton)设计模式

5.1 概述

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、 以及解决问题的思考方式。设计模免去我们自己再思考和摸索。就像是经典的棋谱,不同的棋局,我们用不同的棋谱。”套路”

所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象,我们应该怎么做呢?

① 我们首先必须将类的构造器的访问权限设置为private

这样,就不能用new操作符在类的外部产生类的对象了,但在类内部仍可以产生该类的对象。

② 其次,指向类内部产生的该类对象的变量也必须定义成静态的

因为在类的外部开始还无法得到类的对象,只能调用该类的某个静态方法以返回类内部创建的对象, 静态方法只能访问类中的静态成员变量,所以,指向类内部产生的该类对象的变量也必须定义成静态的。

5.2 优点

由于单例模式只生成一个实例,减少了系统性能开销,当一个对象的产生需要比较多的资源时,如读取配置、产生其他依赖对象时,则可以通过在应用启动时直接产生一个单例对象,然后永久驻留内存的方式来解决。

5.3 单例设计模式-饿汉式

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single = new Singleton();
    // 3.提供公共的静态的方法,返回当前类的对象
    public static Singleton getInstance() {
    return single;
    }
}

5.4 单例设计模式-懒汉式

(1)单例设计模式-懒汉式(线程不安全)

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single;
    // 3.提供公共的静态的方法,返回当前类的对象
    public static Singleton getInstance() {
      if(single == null) {
      single = new Singleton();
      }
     return single;
     }
}

(2)单例设计模式-懒汉式(线程安全)

public class BankTest {
}
class Bank{
    private Bank(){}
    private static Bank instance = null;
    public static Bank getInstance(){
        //方式一:效率稍差
//        synchronized (Bank.class) {
//            if(instance == null){
//
//                instance = new Bank();
//            }
//            return instance;
//        }
        //方式二:效率更高
        if(instance == null){
            synchronized (Bank.class) {
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

5.5 应用场景

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

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

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

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

Application也是单例的典型应用。

WindowsTask Manager (任务管理器)就是很典型的单例模式。

WindowsRecycleBin (回收站)也是典型的单例应用。在整个系统运行过程中,回收站一直维护着仅有的一个实例。

到此这篇关于Java超详细透彻讲解static的文章就介绍到这了,更多相关Java static内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 解析Java中的static关键字

    一.static关键字使用场景 static关键字主要有以下5个使用场景: 1.1.静态变量 把一个变量声明为静态变量通常基于以下三个目的: 作为共享变量使用 减少对象的创建 保留唯一副本 第一种比较容易理解,由于static变量在内存中只会存在一个副本,所以其可以作为共享变量使用,比如要定义一个全局配置.进行全局计数.如: public class CarConstants { // 全局配置,一般全局配置会和final一起配合使用, 作为共享变量 public static final in

  • 带你了解Java中Static关键字的用法

    目录 Java中Static关键字的一些用法详解 1. Static 修饰类属性,因为静态成员变量可以通过类名+属性名调用,非静态成员变量不能通过类名+属性名调用: 2. Static 修饰类方法,可以通过类名.静态方法名的方式调用静态方法,不可以用类名.静态方法名调用非静态方法: 3. 静态代码块,匿名代码块,构造函数.三者的调用顺序为(静态代码块(只调用1次) --> 匿名代码块 --> 构造函数). 总结 Java中Static关键字的一些用法详解 1. Static 修饰类属性,因为静

  • Java 梳理总结关于static关键字常见问题

    目录 1.static是什么意思? 2.为什么使用static关键字? 3.Java中是否可以覆盖(override)一个private或者是static的方法? 4.是否可以在static环境中访问非static变量? 5.static静态方法能不能引用非静态资源? 6.static静态方法里面能不能引用静态资源? 7.非静态方法里面能不能引用静态资源? 8.java静态变量.代码块.和静态方法的执行顺序是什么? 1.static是什么意思? static 关键字表明一个成员变量或者是成员方法

  • Java中的static关键字修饰属性和方法(推荐)

    目录 static关键字 1.static修饰属性(静态属性) 1.1.哪些成员属性可以被static修饰. 1.2.静态属性的访问. 2.static关键字修饰方法 1.那些方法可以使用static修饰 2.常见的问题 static关键字 static关键词与对象无关.static关键字主要修饰四个部分的内容 这里我们主要介绍static修饰属性和修饰方法. 1.static修饰属性(静态属性) 1.1.哪些成员属性可以被static修饰. 我们把static修饰的属性称为静态属性,又叫类属性

  • Java关键字详解之final static this super的用法

    目录 1. final 关键字: 2. static 关键字: 3. this 关键字: 4. super 关键字: final,static,this,super 关键字总结 正文开始@Assassin 1. final 关键字: final 关键字,意思是最终的.不可改变的,初始化之后就不能再次修改 ,用来修饰类.方法和变量,具有以下特点: final 修饰的类不能被继承,final类中的所有成员方法都会被隐式的指定为 final 方法: final 修饰的方法不能被重写: final 修饰

  • Java中的static关键字深入理解

    在学习Java以来很长一段时间,我都不能理解为什么修饰一个方法的关键字各不相同,为什么有的方法可以直接调用,而有的方法需要用对象才能调用.毫不夸张的说,最近一次让我决定去整理清楚static关键字,是因为在写jdbc工具类时,其中通过静态代码块来实现加载驱动才让我对它有了新的认识. 通俗来讲,归为几点: 由static关键字修饰的方法或成员变量,不需依赖对象,就可直接访问.(通过 类名.方法名() 或 类名.属性 直接调用) static关键字不会影响到变量或方法的作用域 static关键字不允

  • java关键字static的使用详解

    关键字 static 1. 概述 static 是一种修饰符 static 是Java中表静态的关键字 它可以修饰成员变量.成员方法.代码块 被static修饰的成员变量或成员方法,将不再依赖于对象的创建而去使用,而是依赖类的存在,成为类成员或类方法,是共享的(下面将会详细的解释). 2. static修饰成员变量 2.1 常见的修饰符 public 修饰符 private 修饰符 没有修饰符 static 修饰符(静态修饰符) class Test { // public 修饰符 public

  • Java中的static关键字你了解多少

    目录 一.static关键字的用途 1)static方法 2)static变量 3)static代码块 二.static关键字的误区 1.static关键字会改变类中成员的访问权限吗? 2.能通过this访问静态成员变量吗? 3.static能作用于局部变量么? 三.常见的笔试面试题 1.下面这段代码的输出结果是什么? 2.这段代码的输出结果是什么? 3.这段代码的输出结果是什么? 总结 一.static关键字的用途 在<Java编程思想>P86页有这样一段话: “static方法就是没有th

  • Java基础之static关键字的使用讲解

    static关键字 在Java中,static是静态修饰关键字.用于修饰类的成员方法.类的成员变量,另外可以编写static代码块来优化程序性能:被static关键字修饰的方法或者变量不需要依赖于对象来进行访问,只要类被加载了,就可以通过类名去进行访问. static关键字的作用 方便在没有创建对象的情况下来进行调用方法或者变量.被static关键字修饰的方法或者变量不需要依赖对象来进行访问,只要类被加载了,就可以通过类名去访问. 1.static修饰成员方法 static修饰的方法称为静态方法

  • Java超详细透彻讲解static

    目录 1. 引入 2. 理解 3. 使用 3.1 使用范围 3.2 static修饰属性 3.2.1 设计思想 3.2.2 分类 3.2.3 注意 3.2.4 举例 3.2.5 类变量内存解析 3.3 static修饰方法 3.3.1 设计思想 3.3.2 理解 3.3.3 使用 3.3.4 注意 3.3.5 举例 4. 注意 5. 单例 (Singleton)设计模式 5.1 概述 5.2 优点 5.3 单例设计模式-饿汉式 5.4 单例设计模式-懒汉式 5.5 应用场景 1. 引入 当我们编

  • Java超详细透彻讲解接口

    目录 一.引入 二.理解 三.使用 四.应用-代理模式(Proxy) 1. 应用场景 2. 分类 3. 代码演示 五.接口和抽象类之间的对比 六.经典题目(排错) 一.引入 一方面,有时必须从几个类中派生出一个子类,继承它们所有的属性和方法.但是,Java不支持多重继承.有了接口,就可以得到多重继承的效果. 另一方面,有时必须从几个类中抽取出一些共同的行为特征,而它们之间又没有is-a的关系,仅仅是具有相同的行为特征而已.例如:鼠标.键盘.打印机.扫描仪.摄像头.充电器.MP3机.手机.数码相机

  • Java超详细分析讲解final关键字的用法

    目录 基本介绍 final细节01 final细节02 基本介绍 final 可以修饰类.属性.方法和局部变量. 在某些情况下,程序员可能有以下需求,就会使用到final: Base Sub 类 1)当不希望类被继承时,可以用final修饰. 2)当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字 修饰.[案例演示:访问修饰符 final 返回类型方法名] 3)当不希望类的的某个属性的值被修改,可以用final修饰.[案例演示: public final dou

  • Java超详细整理讲解各种排序

    目录 稳定性 直接插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序 归并排序 计数排序 稳定性 两个相等的数据,如果经过排序后,排序算法能保证其相对位置不发生变化,则我们称该算法是具备稳定性的排序算法. 直接插入排序 直接插入排序就是每次选择无序区间的第一个元素,在有序区间内选择合适的位置插入. 从数组下标为1开始,将下标为1上的值取出来放在tmp中,然后它和前面的下标j上的值进行比较,如果前面下标j上的值比它大,则前面下标j上的值往后走一步,直到比到j回退到了-1或者j下标上的值比tm

  • Java超详细分析讲解哈希表

    目录 哈希表概念 哈希函数的构造 平均数取中法 折叠法 保留余数法 哈希冲突问题以及解决方法 开放地址法 再哈希函数法 公共溢出区法 链式地址法 哈希表的填充因子 代码实现 哈希函数 添加数据 删除数据 判断哈希表是否为空 遍历哈希表 获得哈希表已存键值对个数 哈希表概念 散列表,又称为哈希表(Hash table),采用散列技术将记录存储在一块连续的存储空间中. 在散列表中,我们通过某个函数f,使得存储位置 = f(关键字),这样我们可以不需要比较关键字就可获得需要的记录的存储位置. 散列技术

  • Java 超详细讲解设计模式之中的抽象工厂模式

    目录 抽象工厂模式 1.什么是抽象工厂 2.抽象工厂模式的优缺点 3.抽象工厂模式的结构与实现 4.抽象工厂方法模式代码实现 5.抽象工厂模式的应用场景 6.抽象工厂模式的扩展 抽象工厂模式 前面文章介绍的工厂方法模式中考虑的是一类产品的生产,比如案例中的百事可乐工厂只能生产百事可乐,可口可乐工厂只能生产可口可乐,也就是说:工厂方法模式只考虑生产同等级的产品. 1.什么是抽象工厂 在现实生活中许多工厂是综合型的工厂,能生产多种类)的产品,就拿案例里面的可乐来说,在节日的时候可能会有圣诞版的可乐,

  • Java 超详细讲解IO操作字节流与字符流

    目录 IO操作 字节流 FileInputStream FileOutputStream 字节流读写案例 字符流 FileReader FileWriter 字节流与字符流的区别 IO操作 字节流 java.io.InputStream 输入流,主要是用来读取文件内容的. java.io.OutputStream 输出流,主要是用来将内容字节写入文件的. FileInputStream 该流用于从文件读取数据,它的对象可以用关键字 new 来创建. 有多种构造方法可用来创建对象. 可以使用字符串

  • Java 超详细讲解设计模式之中的建造者模式

    目录 1.什么是建造者模式? 2.建造者模式的定义 3.建造者模式的优缺点 4.建造者模式的结构 5.建造者模式代码演示 6.建造者模式的应用场景 7.建造者模式和工厂模式的区别 1.什么是建造者模式? 我们知道在软件开发过程中有时需要创建一个很复杂的对象,通常由多个子部件按一定的步骤组合而成. 例如,比如我们在自己在组装一台计算机的时候,需要有 CPU.主板.内存.硬盘.显卡.机箱.显示器.键盘.鼠标等部件组装而成的.比如学校需要采购100台计算机,学校不可能自己把零件买过来自己组装,肯定是告

  • Java超详细讲解设计模式之一的工厂模式

    目录 工厂模式 1.简单工厂 1.1结构 1.2实现 1.3优缺点 1.4扩展 2.工厂方法 2.1结构 2.2实现 2.3优缺点 3.抽象工厂 3.1结构 3.2实现 3.3优缺点 4.模式扩展 4.1实现 工厂模式 在Java应用程序中对象无处不在,这些对象都需要进行创建,如果创建的时候直接new对象,那么如果我们要更换对象,所有new对象的地方都需要进行更改.违背了软件设计原则中的开闭原则.如果我们使用工厂生产对象,只需要在工厂中关注对象的改变即可,达到了与对象解耦的目的,工厂模式最大的特

  • Java 超详细讲解类的定义方式和对象的实例化

    目录 1.面对对象的初步认识 1.1什么是面向对象 1.2面向对象与面向过程 2.类的定义与使用 2.1简单认识类 2.2 类的定义格式 3.类的实例化 3.1什么是实例化? 3.2重点笔记 总结 1.面对对象的初步认识 1.1什么是面向对象 用面向对象的思想来涉及程序,更符合人们对事物的认知,对于大型程序的设计.扩展以及维护都非常友好. 1.2面向对象与面向过程 举一个买手机的例子 以面向对象的方式来处理买手机这件事的话,我们就不需要关注买手机的过程,具体手机怎么买,如何到手,用户不用去关心,

随机推荐