Java 多个类共用一个变量 java两个类共享一个变量

转载

mob6454cc62b754 2024-02-26 16:15:00

文章标签 Java 多个类共用一个变量 java 开发语言后端 System 文章分类 Java 后端开发

文章目录

关键字学习

static关键字
静态初始化块

时间处理相关类

Date时间类（java.util.Date）
DateFomat类和SlimpleDateFormat类
Calendar日历类

其他常用类

Math类
Random类
File类

枚举

关键字学习

static关键字

在类中，用static声明的成员变量为静态成员变量，也称为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。有以下特点：
为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化
对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享
一般用“类名.类属性/方法”来调用。（也可以通过对象引用或类名（不需要实例化）访问静态成员）
在static方法中不可以直接访问非static的成员

package com.bjsxt;
        public class jj{
            int id;
            String name;
            static String company="北京";//城市名称
            public jj(int id,String name){
                this.id=id;
                this.name=name;
            }
            public void login(){
                System.out.println("登录:"+name);
                System.out.println(comanpy);
            }
            public static void printComanpy(){
                //login();//调用非静态成员，编译就会报错
                System.out.println(company);
            }
            public static void main(String[] args){
                   jj U=new jj(15,"java");
                   jj.printComanpy();
        }
    }

方法区存放的是：静态变量，类或者static。

非静态可以调用静态
静态不可以调用非静态

静态初始化块

构造方法用于对象的初始化！静态初始化块，用于类的初始化操作！在静态初始化块中不能直接访问非static成员。

package com.bjsxt;
        public class jj{
            int id;
            String name;
            String pwd;
            static String company="北京o";//城市名称
            static { 
                     //不可以调用普通属性和普通方法
                     //因为做类的初始化，没有对象
                     //如果有构造器，先执行static，先类在构造。
                System.out.println("执行类的初始化工作");
                company="bf";
                printComanpy();
            }
            public static void printComanpy(){
                System.out.println(company);
            }
        public static void main(String[] args){
		           jj u3=null;
        }
    }

时间处理相关类

我们用long类型的变量来表示时间，从基准时间往前几亿年，往后几亿年都能表示。如果想获得现在时刻的“时刻数值”，可以使用：

long now=System.currentTimeMillis();

Date时间类（java.util.Date）

package com.bjsxt;
import java.util.Date;
        public class jj{
            public static void main(String[] args) {
               /** //Integer.MIN_VALUE
                long a=Long.MAX_VALUE/(1000L*3600*24*365);//Long.MAX_VALUE最大的值，加L防止溢出
                System.out.println(a);//大约表示到：2.9亿年后

                long nowNum=System.currentTimeMillis();//代表当前时刻的毫秒数
                System.out.println(nowNum);*/

                Date a1=new Date();//如果没有传参，代表当前时刻
                System.out.println(a1);
                System.out.println(a1.getTime());//返回当前时间的毫秒数

                Date a2=new Date(1000L*3600*24*365*250);
                System.out.println(a2);//
                
            }
    }

DateFomat类和SlimpleDateFormat类

DateFomat类的作用
把时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。
DateFomat是一个抽象类，一般使用它的子类SimpleDateFormat类实现。

package com.bjsxt;
/**
 * 测试时间对象和字符串的相互转化
 * 使用：DateFormat、SimpleDateFormat
 * */
import java.text.DateFormat;
import java.util.Date;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.Spliterators;
import java.util.function.LongConsumer;
public class jj{
            public static void main(String[] args) throws ParseException {
                //new出SimpleDateFormat对象
                // SimpleDateFormat s1=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
                SimpleDateFormat s1=new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");

                //将字符串转换Date对象
               // Date d1=s1.parse("1971-3-10 10:40:52");
                Date d1=s1.parse("1971年3月10日 10时40分52秒");
                System.out.println(d1.getTime());

                //将Date对象转换成字符串
                Date d2=new Date();
                String str=s1.format(d2);
                System.out.println(str);

                DateFormat df2=new SimpleDateFormat("今年第w周,今年第D天");
                System.out.println(df2.format(d2));
                //注意：将符合指定格式的字符串转换成时间对象，字符串格式需要和指定格式一致。

            }
}

Calendar日历类

Calendar类是一个抽象类，为我们提供了关于日期计算的相关功能，比如：年、月、日、时、分、秒的展示和计算。
GregorianCalendar是Calendar的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。

注意月份的表示，一月是0，二月是1，以此类推，12月是11.因为大多数人习惯于使用单词而不是使用数字来表示月份，这样程序也许更易读，父类Calendar使用常量来表示月份：JANUARY等等

GregorianCalendar类和Calendar类的使用

package com.bjsxt;
import java.util.*;
public class jj{
            public static void main(String[] args) {
                //得到日期相关元素
                GregorianCalendar calendar=new GregorianCalendar(2999,10,9,22,10,50);
                int year=calendar.get(Calendar.YEAR);//打印1999
                int month=calendar.get(Calendar.MONTH);//打印10
                int day=calendar.get(Calendar.DAY_OF_MONTH);//打印9
                int day2=calendar.get(Calendar.DATE);//打印9
                //日：Calendar.MONTH和Calendar.DAY_OF_MONTH同义词
                int date=calendar.get(Calendar.DAY_OF_WEEK);//打印3
                //星期几，这里是：1-7。周日是1，周一是2·····周六是7
                System.out.println(year);
                System.out.println(month);
                System.out.println(day);
                System.out.println(day2);
                System.out.println(date);
                //设置日期
                GregorianCalendar calendar2=new GregorianCalendar();
                calendar2.set(Calendar.YEAR,2999);
                calendar2.set(Calendar.MONTH,Calendar.FEBRUARY);
                calendar2.set(Calendar.DATE,3);
                calendar2.set(Calendar.HOUR_OF_DAY,10);
                calendar2.set(Calendar.MINUTE,20);
                calendar2.set(Calendar.SECOND,23);
                printCalendar(calendar2);
                //日期计算
                GregorianCalendar calendar1=new GregorianCalendar(2999,10,9,22,10,50);
                calendar1.add(Calendar.MONTH,-7);//月份减少7
                calendar1.add(Calendar.DATE,7);//增加7天
                printCalendar(calendar1);
                //日历对象和时间对象转化
                Date d=calendar1.getTime();
                GregorianCalendar calendar3=new GregorianCalendar();
                calendar3.setTime(new Date());
            }
            static  void printCalendar(Calendar calendar){
                int year=calendar.get(Calendar.YEAR);
                int month=calendar.get(Calendar.MONTH)+1;
                int day=calendar.get(Calendar.DAY_OF_MONTH);
                int date=calendar.get(Calendar.DAY_OF_WEEK)-1;//星期几
                String week=""+((date==0)?"日":date);
                int hour=calendar.get(Calendar.HOUR);
                int minute=calendar.get(Calendar.MINUTE);
                int second=calendar.get(Calendar.SECOND);
                System.out.printf("%d年 %d月 %d日，星期%s %d:%d:%d\n",year,month,day,week,hour,minute,second);
            }
}

其他常用类

Math类

Math类常用方法

package com.bjsxt;
public class jj {
    public static void main(String[] args) {
    //取整相关操作
        System.out.println(Math.ceil(3.2));
        System.out.println(Math.floor(3.2));
        System.out.println(Math.round(3.2));
        System.out.println(Math.round(3.2));
    //绝对值、开方、a的b次幂等操作
        System.out.println(Math.abs(-6));
        System.out.println(Math.sqrt(9));
        System.out.println(Math.pow(5,2));
        System.out.println(Math.pow(2,5));
    //Math类常用的常量
        System.out.println(Math.PI);
        System.out.println(Math.E);
    //随机数
        System.out.println(Math.random());//[0,1];
    }
}

Random类

package com.bjsxt;
import java.util.Random;
public class jj {
    public static void main(String[] args) {
        Random rand=new Random();
        //随机生成（0，1）之间的double类型的数据
        System.out.println(rand.nextDouble());
        //随机生成int类型允许范围之内的整型数据
        System.out.println(rand.nextInt());
        //随机生成（0，1）之间的float类型的数据
        System.out.println(rand.nextFloat());
        //随机生成false或者true
        System.out.println(rand.nextBoolean());
        //随机生成[0,10)之间的int类型的数据
        System.out.print(rand.nextInt(10) );
        //随机生成[20,30)之间的int类型的数据
        System.out.print(20+rand.nextInt(10));
        //随机生成[20,30]之间的int类型的数据（此种计算方法较为复杂）
        System.out.print(20+(int)(rand.nextDouble()*10));
    }
}

File类

File类用来代表文件和目录。

java.io.File类：代表文件和目录。

package com.bjsxt;

import java.io.File;
import java.io.IOException;

public class jj {
    public static void main(String[] args) throws IOException {
       /**
       File类创建文件
       */
       File f1=new File("d:/movies/功夫熊猫.mp4");//创建文件
       // File f1=new File("d:\\movie\\/功夫熊猫.mp4");
       File f2=new File("d:/movies");//创建目录

       System.out.println(System.getProperty("user.dir"));//获得项目的路径
        File f3=new File(System.getProperty("user.dir"));
       /**
       使用 File类访问文件或者目录属性
       */
        f1.createNewFile();
        //异常时向外抛出
        System.out.println("File是否存在："+f1.exists());
        System.out.println("File是否是目录："+f1.isDirectory());
        System.out.println("File是否是文件："+f1.isFile());
        System.out.println("File最后修改时间："+new Date(f1.lastModified()));
        System.out.println("File的大小："+f1.length());
        System.out.println("File的文件名："+f1.getName());
        System.out.println("File的目录路径："+f1.getPath());
    }
}

方法	说明
public boolean exists()	判断File是否存在
public boolean isDirectory()	判断File是否是目录
public boolean isFile()	判断File是否是文件
public boolean lastModified()	返回File最后修改时间
public boolean length()	返回File的大小
public boolean getName()	返回File的文件名
public boolean getPath()	返回File的目录路径

通过File对象创建空文件或者目录（在该对象所指文件或目录不存在的情况下）

方法	说明
creatNewFile()	创建新的File
delete()	删除File对应的文件
mkdir()	创建一个目录；中间某个目录缺失，则创建失败
mkdirs()	创建多个目录；中间某个目录缺失，则创建该缺失目录

File f4=new File("D:/movies/大陆/学习/编程/尚学堂/高琪");
        File f5=new File("D:/movies/编程/尚学堂/高琪");
        boolean flag1=f4.mkdirs();//目录结构中有一个不存在也没关系；创建整个目录树
        boolean flag2=f5.mkdir();//目录结构中有一个不存在，则不会创建整个目录树
        System.out.println(flag1);//true,创建成功
        System.out.println(flag2);//false,创建失败
        //    f4.delete();f4包含着“高旗”这个目录，只删除目标目录，不然D盘都没有了

枚举

枚举类型的定义包括枚举声明和枚举体。格式如下：

enum 枚举名{
枚举体（常量列表） }

创建枚举类型

enum Season{
  	SPRING,SUMMER,AUTUMN,WINTER
  	}

所有的枚举类型隐性地继承自java.lang.Enum。枚举实质上还是类！而每个被枚举的成员实质上就是一个枚举类型的实例，他们默认都是public static final修饰的。可以直接通过枚举类型名使用它们。
枚举的使用

package com.bjsxt;
import java.util.Random;
public class St {
    public static void main(String[] args) {
        //枚举遍历
        for(Week k:Week.values()){
            //values()返回的：Week[]里面包含了所有的枚举元素 这是个数组 增强循环
            System.out.println(k);
        }
        Week[] ws=Week.values();
        System.out.println(ws[0]);
        //switch语句中使用枚举
        int a=new Random().nextInt(4);//生成0，1，2，3的随机数
        switch (Season.values()[a]){
            //Season.values()[a]
            case SPRING:
                System.out.println("春天");
                break;
            case SUMMER:
                System.out.println("夏天");
                break;
            case AUTUMN:
                System.out.println("秋天");
                break;
            case WINTER:
                System.out.println("冬天");
                break;
        }
    }
    /**
     * public static final int SPRING=0;
     * public static final int SUMMER=1;
     * public static final int AUTUMN=2;
     * public static final int WINTER=3;
     */
    enum Season{
        SPRING,SUMMER,AUTUMN,WINTER
    }
    enum Week{
        星期一,星期二,星期三,星期四,星期五,星期六,星期日
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：mysql高水位表数据库高水位问题

下一篇：kubeSphere es集群 kubernetes集群安装

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯