Java中的内部类和常用类用法解读_Java

内部类和常用类

内部类

概念：在一个类的内部再定义一个完整的类

 package com.object.demo01;
 
 public class body {
     private string name;
     class header{
         //内部类也会生成一个class文件 编译之后可以生成独立的字节码文件
         //内部类可为外部类提供必要的功能组件
         public void show() {    
             system.out.println(name);   //内部类可以直接访问外部类的私有成员，而不破坏封装
         }
     }
 }

成员内部类

package com.object.demo02;
 
 //外部类
 public class outer {
     //实例变量
     private string name = "张三";
     private int age = 18;
 
     //内部类 与实例变量、实例方法同级别的类
     class inner {
         private string address = "北京";
         private string phone = "110";
 
         private string name =  "李四"; 
         
         //private static int scores = 86; 内部类不能定义静态成员
         private static final int scores = 86; //但是可以定义静态常量
         //方法
         public void show() {
             //打印外部类的属性
             system.out.println(name);   //内部类属性和外部类属性名字相同，优先打印内部类
             system.out.println(outer.this.name);    
             system.out.println(age);    //可以在age前加上outer.this这样更清晰 可读性
             //打印内部类的属性
             system.out.println(address);        //同理可以加上this.
             system.out.println(phone);          //同理加上this.
         }
     }
 }

 package com.object.demo02;
 
 public class testouter {
     public static void main(string[] args) {
         //内部类的创建必须依赖外部类对象
 //        //1.先创建一个外部类对象
 //        outer outer = new outer();
 //        //2.创建一个内部类对象
 //        outer.inner inner = outer.new inner();
 
         //一步到位
         outer.inner inner = new outer().new inner();
 
         inner.show();
     }
 }

静态内部类

不依赖内部类对象，可直接创建或通过类名访问，可声明静态成员

 package com.object.demo03;
 
 //外部类
 public class outer {
     private string name = "xxx";
     private int age = 18;
 
     //静态内部类：和外部类相同
     static class inner {    //只有内部类才可以用static修饰，正常的类不能用static
         private string address = "上海";
         private string phone = "110";
 
         //静态成员
         private static int count = 10000;
 
         public void show() {
             //如何调用外部类的属性呢
             //system.out.println(name); 不对
             outer outer = new outer();
             system.out.println(outer.name);
             system.out.println(outer.age);
             //调用静态内部类的属性和方法
             system.out.println(address);
             system.out.println(phone);
             //调用静态内部类的静态属性
             system.out.println(inner.count);
 
         }
     }
 }

package com.object.demo03;
 
 public class test {
     public static void main(string[] args) {
         //静态内部类相当于一个外部类
         //直接创建静态内部类对象
         outer.inner inner  =new outer.inner();  //没有new outer();
         //调用方法
         inner.show();
     }
 }

局部内部类

定义在外部类方法中，作用范围仅限于当前方法

package com.object.demo04;
 
 public class outer {
     private string name = "张三";
     private int age = 18;
 
     public void show() {
         //定义局部变量
         final string address = "深圳";    //局部内部类访问外部类当前方法的局部变量时，因无法保障变量的声明周期与自身相同，变量修饰必须为final
 
         //局部内部类：注意不能加任何访问修饰符
         class inner {   //在堆里 不会消失
             private string phone = "110";
             private string email = "111@qq.com";
 
            // private static int count = 0; 局部内部类里不能有静态属性，同样可以有静态常量
             
             public void show2() {
                 //访问外部类的属性 但是show被static修饰就不能访问
                 //因为static 和类一起加载 外部类属性还没加载出来
                 system.out.println(name);   //可以加上outer.this. 可读性强
                 system.out.println(age);
                 //访问内部类属性
                 system.out.println(phone);  //可以加上this.
                 system.out.println(email);  //同上
                 
                 //访问局部变量 jdk1.7要求是常量 jdk1.8自动加上final
                 system.out.println(address);
             }
         }
         
         //创建内部类对象
         inner inner = new inner();
         inner.show2();
     }
 }

package com.object.demo04;
 
 public class test {
     public static void main(string[] args) {
         outer outer = new outer();
 
         outer.show();
 
     }
 }

匿名内部类

没有类名的局部内部类
必须继承一个父类或者实现一个接口
优点：减少代码量
缺点：可读性较差

package com.object.demo05;
 
 //接口
 public interface usb {
     //定义一个服务方法
     void service();
 }

package com.object.demo05;

public class mouse implements usb {
    @override
    public void service() {
        system.out.println("连接成功，鼠标开始工作");

    }
}

package com.object.demo05;

public class test {
    public static void main(string[] args) {


        //创建接口类型变量
        //usb usb = new mouse();
        //usb.service();

        //局部内部类
    class fan implements usb {


        @override
        public void service() {
            system.out.println("连接成功，风扇开始工作");
        }
    }
        usb usb = new fan();
        usb.service();

    }
}

这是使用局部内部类。局部内部类只使用一次，可以用匿名内部类进行优化->

 package com.object.demo05;
 
 public class test {
     public static void main(string[] args) {
 
         //使用匿名内部类创建对象(相当于创建了一个局部内部类)
         // usb usb = new usb();  报错-接口不能实例化
         usb usb = new usb() {
             @override
             public void service() {
                 system.out.println("连接成功，风扇开始工作");
             }
         };
         usb.service();
 
         //使用匿名内部类优化
 
     }
 }

常用类

object类

在java.lang包下

超类，所有对象都继承这个类的方法

getclass()方法

返回class类型

应用：判断两个引用中实际存储对象类型是否一致

 package com.object.demo06;
 
 public class student {
     private string name;
     private int age;
     
     public student(string name, int age) {
         this.name = name;
         this.age = 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;
     }
 }

package com.object.demo06;

public class test {
    public static void main(string[] args) {
        student s1 = new student("aaa", 20);
        student s2 = new student("bbb", 22);
        //判断s1和s2是不是同一个类型
        class class1 = s1.getclass();
        class class2 = s2.getclass();

        if (class1 == class2) {
            system.out.println("s1 is the same class");
        } else {
            system.out.println("s1 is not the same class");
        }
    }
}

hashcode()方法

返回int类型

哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值

一般情况下相同对象返回相同哈希码

以上节课的代码为例

package com.object.demo06;

public class test {
    public static void main(string[] args) {
        student s1 = new student("aaa", 20);
        student s2 = new student("bbb", 22);
        
        //hashcode方法
        system.out.println(s1.hashcode());	//开辟第一块空间 
        system.out.println(s2.hashcode());	//开辟第二块空间
        student s3 = s1;
        system.out.println(s3.hashcode());	//将第一块空间赋予它
		//1、3相等，1、2不等
    }
}

tostring()方法

返回值类型string

可以根据程序需求重写该方法

package com.object.demo06;

public class test {
    public static void main(string[] args) {
        student s1 = new student("aaa", 20);
        student s2 = new student("bbb", 22);
        
        //3.tostring
        system.out.println(s1.tostring());	
        system.out.println(s2.tostring());
    }
}

得到的是@+16进制哈希值

想要看到具体的属性就要对tostring进行重写

package com.object.demo06;

public class student {
    private string name;
    private int age;

    public student(string name, int age) {
        this.name = name;
        this.age = 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;
    }
	//快捷键alt+ins
    @override
    public string tostring() {
        return "student [name=" + name + ", age=" + age + "]";
    }
}

equals()方法

返回布尔类型

package com.object.demo06;

public class test {
    public static void main(string[] args) {
        student s1 = new student("aaa", 20);
        student s2 = new student("bbb", 22);
        
        //4.equals方法：判断两个对象是否相等
        system.out.println("-----------------------------------");
        system.out.println(s1.equals(s2));

        student s4 = new student("小明",17);
        student s5 = new student("小明", 17);
        system.out.println(s4.equals(s5));  //虽然两者的属性相同，但是分别开辟了一个内存空间 false

    }
}

要让属性相同返回true就要对equals进行重写

 @override
     public boolean equals(object obj) {
         //1.判断两个对象是否是同一个引用
         if (this == obj) {
             return true;
         }
         //2.判断obj是否为null
         if (obj == null) {
             return false;
         }
         //3.判断是否为同一个类型
 //        if(this.getclass() == obj.getclass()) {
 //            return true;
 //        }
         if (obj instanceof student) {    //instanceof判断对象是否是某种类型
             //4.强制类型转换
             student s = (student) obj;
             //5.比较属性
             if (this.name.equals(s.getname()) && this.age == s.getage()) {
                 return true;
             }
         }
         return false;
     }

finalize()方法

该方法一般情况下，程序员不会调用

当对象被判定为垃圾对象时，由jvm自动调用此方法，用以标记垃圾对象，进入回收队列
垃圾对象：没有有效引用指向此对象时，为垃圾对象
垃圾回收：由gc销毁垃圾对象，释放数据存储空间
自动回收机制：jvm的内存耗尽，释放数据存储空间
手动回收机制：使用system.gc()，通知jvm执行垃圾回收

@override
     protected void finalize() throws throwable {
         system.out.println(this.name +"对象被回收了");
     } //对finalize方法进行重写

 package com.object.demo06;
 
 public class test2 {
     public static void main(string[] args) {
         student s1 = new student("aaa", 20);
         new student("bbb", 20);
 
         //回收垃圾
         system.gc();
         system.out.println("回收垃圾"); //aaa正常，bbb被回收
     }
 }

包装类

基本数据所对应的引用数据类型

基本数据类型	包装类
boolean	boolean
byte	byte
char	character
short	short
int	integer
long	long
float	float
double	double

类型转换与装箱拆箱

栈里面的对象拿到堆里面：装箱
堆里面的对象拿到栈里面：拆箱

package com.object.demo07;

public class test {
    public static void main(string[] args) {
        //类型转换：装箱：基本类型转成引用类型的过程
        int num1 = 18;  //基本类型 栈
        //使用integer类创建对象 下面两种方式都行
        integer integer1 = new integer(num1);
        integer integer2 = integer.valueof(num1);
        system.out.println("装箱");
        system.out.println(integer1);
        system.out.println(integer2);


        //类型转换：拆箱：引用类型转成基本类型
        integer integer3 = new integer(100);
        int num2 = integer3.intvalue();
        system.out.println("拆箱");
        system.out.println(num2);

        //jdk1.5以后，提供自动装箱和拆箱
        int age = 18;
        //自动装箱
        integer integer4 =age;
        system.out.println("自动装箱");
        system.out.println(integer4);
        //自动拆箱
        int age2 =  integer4;
        system.out.println("自动拆箱");
        system.out.println(age2);


    }
}

基本类型转换

package com.object.demo07;

public class test {
    public static void main(string[] args) {
        
        //基本类型转成字符串
        int n1 = 15;
        //1.使用+号
        string s1 = n1 + "";
        //2.使用integer中的tostring()方法
        string s2 = integer.tostring(n1);
        string s3 = integer.tostring(n1,16);    //tostring重载方法，将它转成指定进制
        system.out.println(s1);
        system.out.println(s2);
        system.out.println(s3);

        //字符串转成基本类型
        string str = "150";
        //使用integer.parsexxx();
        int n2 = integer.parseint(str);
        system.out.println(n2);

        //boolean字符串形式转成基本类型，"true"-->true,只要这个字符串不是true就是false
        string str2 = "true";
        boolean b1 = boolean.parseboolean(str2);
        system.out.println(b1);

    }
}

整数缓冲区

java预先创建了256个常用的整数包装类型对象integer

我们接下来从一个程序来加深这句话的理解

package com.object.demo07;


public class test2 {
    public static void main(string[] args) {
        //面试题
        integer integer1 = new integer(100);
        integer integer2 = new integer(100);
        system.out.println(integer1 == integer2);   //引用类型在堆内存开辟了两个不同空间 false

        integer integer3 = 100; //自动装箱  即integer integer3 = integer.valueof(100) 后续同理
        integer integer4 = integer.valueof(100); //自动装箱
        system.out.println(integer3 == integer4);
        //integer3,integer4都是引用类型，答案也是false吗？ 结果是true

        integer integer5 = 200;
        integer integer6 = 200;
        system.out.println(integer5 == integer6);
        //这三行和上面三行几乎没差别 结果却相反 是false
    }
}

自动装箱是使用integer.valueof()

问题就出在这个方法，ctrl+鼠标看valueof()源码

public static integer valueof(int i) {
        if (i >= integercache.low && i <= integercache.high)
            return integercache.cache[i + (-integercache.low)];
        return new integer(i);
    }

low= -128,high = 127;

		integer integer3 = 100; 
        integer integer4 = 100; 
        system.out.println(integer3 == integer4);	//true

100在-128~127 返回cache[] 数组

数组在缓冲区中有256个位置，将100这个值取地址给integer3和integer4,两者地址相同，所以返回true

		integer integer5 = 200;
        integer integer6 = 200;
        system.out.println(integer5 == integer6);	//false

200不在-128~127 return new integer(i); 和integer1,2一样，在堆内存开辟新空间

string类

string概述

字符串是常量，创建之后不消失
字符串字面量存储在字符串池中，可以共享

package com.object.demo07;

public class test3 {
    public static void main(string[] args) {
        string name = "hello";  //"hello" 存储在常量池中
        system.out.println(name.hashcode());    //假如hashcode是x
        name = "zhangsan";    //"zhangsan"赋值给name 给字符串赋值时，并没有在原字符串上修改数据，而是重新开辟一块空间
        string name2 = "zhangsan";

        system.out.println(name.hashcode());    //hashcode是y “zhangsan”字符串常量可以共享
        system.out.println(name2.hashcode());   //hashcode是y
        
    }
}

string常用方法

public int length(): 返回字符串长度
public char charat(int index): 根据下标获取字符
public boolean contains(string str):判断当前字符串中是否包含str

package com.object.demo07;

public class test3 {
    public static void main(string[] args) {
        //字符串方法的使用
        //length();返回字符串的长度
        //charat(int index);返回某个位置的字符
        //contains(string str);判断是否是某个子字符串

        string content = "java是世界上最好的编程语言";
        system.out.println(content.length());   //15
        system.out.println(content.charat(0));  //第一个字符
        system.out.println(content.charat(content.length()-1)); //最后一个字符
        system.out.println(content.contains("java"));
        system.out.println(content.contains("php"));


    }
}

public char[] tochararray():将字符串转换成数组
public int indexof(string str):查找str首次出现的下标，存在，返回该下标，不存在，返回-1
public int lastindexof(string str):查找字符串在当前字符串中最后一次出现的下标

package com.object.demo07;

import java.util.arrays;

public class test3 {
    public static void main(string[] args) {
        
        //字符串方法的使用
        //tochararray();返回字符串对应的数组
        //indexof();返回子字符串出现的位置
        //lastindexof();返回字符串最后一次出现的位置
		string content = "java是世界上最好的java编程语言,java真香";

        system.out.println(content.tochararray());
        system.out.println(arrays.tostring(content.tochararray())); //把这个数组当字符串输出出来
        system.out.println(content.indexof("java"));    //0
        system.out.println(content.indexof("java", 4)); //找第二个java,从角标为4开始找，但是最终结果还是以第一个字符为0
        system.out.println(content.lastindexof("java"));    //找最后一个java


    }
}

public string trim():去掉字符串前后的空格
public string touppercase():将小写转成大写
public string tolowercase():将大写转成小写
public boolean endswith(string str):判断字符串是否以str结尾
public boolean startswith(string str):判断字符串是否以str开头

package com.object.demo07;

import java.util.arrays;

public class test3 {
    public static void main(string[] args) {
      
        //字符串方法的使用
        //trim();去掉字符串前后的空格
        //touppercase(); 把小写转成大写
        //tolowercase(); 把大写转成小写
        //endswith(str); 判断是否以str结尾，startswith(str);判断是否以str开头

        string content2 = " hello   world   ";
        system.out.println(content2.trim());
        system.out.println(content2.touppercase());
        system.out.println(content2.tolowercase());
        string filename = "hello.java";
        system.out.println(filename.endswith(".java"));
        system.out.println(filename.startswith("hello"));

    }
}

public string replace(char oldchar, char newchar):将旧字符串替换成新字符串
public string split[] split(string str):根据str做拆分

package com.object.demo07;

import java.util.arrays;

public class test3 {
    public static void main(string[] args) {
        
        //字符串方法的使用
        //replace(char old, char new);用新的字符串替换旧的字符串
        //split();对字符串进行拆分
        system.out.println(content.replace("java", "php"));
        string say = "java is the best programming language";
        string[] arr = say.split(" ");
        system.out.println(arr.length); //6,拆分成6个字符串
        for (string s : arr) {
            system.out.println(s);
        }
        string say1 = "java is the best programming language,java xiang";
       //想要把字符串空格和逗号去掉来分割
        string[] arr1 = say1.split("[ ,]");
        for (string s : arr1) {
            system.out.println(s);
        }
        string say2 = "java is the best      programming language,java xiang";
        //想要多个空格也能去除
        string[] arr2 = say2.split("[ ,]+");
        for (string s : arr2) {
            system.out.println(s);
        }
        system.out.println("--------------------------");
        //补充两个方法equals; compareto();
        string s1 = "hello";
        string s2 = "hello";
        system.out.println(s1.equals(s2));  //false
        system.out.println(s1.equalsignorecase(s2));    //忽视大小写 true

        string s3 = "abc";  //a是97
        string s4 = "xyz";  //x是120
        system.out.println(s3.compareto(s4));   //两个字符串首个字符的ascii码值相减 -23,首个相同就减下一个以此类推

        string s5 = "abc";
        string s6 = "abcxyz";
        system.out.println(s5.compareto(s6));   //s5刚好在s6里面的前面，则比较长度 -3
    }
}

案例分析

package com.object.demo07;

//案例演示
//已知string str =  "this is a text";
/*
* 将str中的单词单独获取出来
* 将str中的text替换为practice
* 在text前面插入一个easy
* 将每个单词的首字母改为大写

* */
public class test4 {
    public static void main(string[] args) {
        string str = "this is a text";
        //将str中的单词单独获取出来
        string[] arr = str.split(" ");
        for(string str1 : arr) {
            system.out.println(str1);
        }

        //将str中的text替换为practice
       string s1 = str.replace("text", "practice");

        //在text前面插入一个easy
        string s2 = str.replace("text", "easy text");

        //将每个单词的首字母改为大写
for(int i = 0; i < arr.length; i++) {
    char first = arr[i].charat(0);
    char upperfirst = character.touppercase(first);
    string s3 = upperfirst+arr[i].substring(1);


}

    }

}

stringbuffer和stringbuilder

stringbuffer:可变长字符串，运行效率慢，线程安全多线程用
stringbuilder:可变长字符串，运行效率快，线程不安全单线程用

效率比string高，比string更节省内存

stringbuffer和stringbuilder方法通用，常见方法如下

package com.object.demo08;

public class demo01 {
    public static void main(string[] args) {
        stringbuffer sb = new stringbuffer();
        //1.append(); 追加
        sb.append("java世界第一");
        system.out.println(sb.tostring());
        sb.append("java真香");
        system.out.println(sb.tostring());
        //2.insert(); 添加
        sb.insert(0,"我在最前面");
        system.out.println(sb.tostring());
        //3.replace();
        sb.replace(0, 4, "hello");  //含头不含尾 面字还留着
        system.out.println(sb.tostring());
        //4.delete(); 删除
        sb.delete(0, 6);
        system.out.println(sb.tostring());
        //5.reverse(); 翻转
        sb.reverse();
        system.out.println(sb.tostring());
        //清空
        sb.delete(0, sb.length());
        system.out.println(sb.length());

    }
}

package com.object.demo08;

public class demo02 {
    public static void main(string[] args) {
        //验证效率stringbuilder高于string
        long starttime = system.currenttimemillis();    //开始时间
        string string = "";
        for (int i = 0; i < 999; i++) {
            string += i;    //字符串的拼接
        }
       
        system.out.println(string.tostring());
        long endtime = system.currenttimemillis();
        system.out.println("用时"+ (endtime - starttime));

    }
}

package com.object.demo08;

public class demo02 {
    public static void main(string[] args) {
        //验证效率stringbuilder高于string
        long starttime = system.currenttimemillis();    //开始时间
        
        stringbuilder builder = new stringbuilder();
        for (int i = 0; i < 999; i++) {
            builder.append(i);
        }
        system.out.println(builder.tostring());
        long endtime = system.currenttimemillis();
        system.out.println("用时"+ (endtime - starttime));
    }
}

bigdecimal

位置：java.math包中
作用：精确计算浮点数
创建方法：bigdecimal bd = new bigdecimal("1.0");

package com.object.demo08;

import java.math.bigdecimal;

public class demo03 {
    public static void main(string[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        system.out.println(d1 - d2);
        //输出结果0.0999999999...
        //很多实际应用中需要精确计算，而double是近似值存储，需要借助bigdecimal
        double result = (1.4 - 0.5) / 0.9;
        system.out.println(result);


        //bigdecimal,大的浮点数精确计算
        bigdecimal bd1 = new bigdecimal("1.0"); //要用字符串
        bigdecimal bd2 = new bigdecimal("0.9");
        system.out.println(bd1.subtract(bd2));  //减法
        system.out.println(bd1.add(bd2));   //加法
        system.out.println(bd1.multiply(bd2));  //乘法

        bigdecimal result1 = new bigdecimal("1.4").subtract(new bigdecimal("0.5")).divide(new bigdecimal("0.9"));
        system.out.println(result1);

        //除不尽情况
        //bigdecimal r = new bigdecimal("10").divide(new bigdecimal("3"));    //出现异常
        bigdecimal r = new bigdecimal("10").divide(new bigdecimal("3"), 2, bigdecimal.round_half_up);   //保留两位小数，四舍五入
        system.out.println(r);


    }

}

date类

date表示特定的瞬间，精确到毫秒。date中大部分方法已经被calendar类中方法取代

package com.object.demo08;

import java.util.date;

public class demo04 {
    public static void main(string[] args) {

        //1.创建date对象
        //今天
        date date1 = new date();
        system.out.println(date1.tostring());   //打印当前时间 用空格连接
        system.out.println(date1.tolocalestring()); //打印当前时间 用-连接，已过时

        //昨天
        date date2 = new date(date1.gettime() - 24 * 60 * 60 * 1000);
        system.out.println(date2.tostring());
        //方法 after before
       boolean b1= date1.after(date2);
        system.out.println(b1);
        boolean b2= date1.before(date2);
        system.out.println(b2);

        //比较 compareto();
        int d = date1.compareto(date2); //比较两者的毫秒值 毫秒值相减 正数返回1，负数返回-1
        system.out.println(d);

        //比较数相等 equals
        boolean b3 = date1.equals(date2);
        system.out.println(b3);
        
    }
}

calendar类

package com.object.demo08;

import java.util.calendar;

public class demo05 {
    public static void main(string[] args) {
        //创建calendar对象
        calendar calendar = calendar.getinstance(); //calendar是protected不能直接new
        system.out.println(calendar.tostring());    //打印的东西特别多，不是我们想要看到的形式
        system.out.println(calendar.gettime().tostring());  //把calendar转成date类
        system.out.println(calendar.gettimeinmillis());
        //获取时间信息
        //获取年
        int year = calendar.get(calendar.year); //也可以把calendar.year写成1，这样的话可读性差
        system.out.println(year);
        //获取月 从0-11，0代表一月
        int month = calendar.get(calendar.month);
        system.out.println(month);
        //获取日
        int day = calendar.get(calendar.day_of_month);
        system.out.println(day);
        //获取小时
        int hour = calendar.get(calendar.hour_of_day);  //24小时制
        int hour2 = calendar.get(calendar.hour);    //12小时制
        system.out.println(hour);
        system.out.println(hour2);
        //获取分钟
        int minute = calendar.get(calendar.minute);
        system.out.println(minute);
        //获取秒
        int second = calendar.get(calendar.second);
        system.out.println(second);

        system.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);

        //修改时间
        calendar calendar2 = calendar.getinstance();
        calendar2.set(calendar.day_of_month, 5);    //修改日
        system.out.println(calendar2.gettime().tolocalestring());

        //add修改时间
        calendar2.add(calendar.hour, 1);
        system.out.println(calendar2.gettime().tolocalestring());
        calendar2.add(calendar.hour, -1);   //减少时间
        system.out.println(calendar2.gettime().tolocalestring());

        //补充
        int max = calendar2.getactualmaximum(calendar.day_of_month);  //获取月的最大天
        system.out.println(max);
        int min = calendar2.getactualminimum(calendar.day_of_month);  //获取月的最小天
        system.out.println(min);
    }
}

simpledateformat类

将日期转成特定格式

 package com.object.demo08;
 
 import java.text.parseexception;
 import java.text.simpledateformat;
 import java.util.date;
 
 public class demo06 {
     public static void main(string[] args) throws parseexception {
         //创建simpledateformat对象 y年 m月 d日 h时 m分 s秒
         simpledateformat sdf = new simpledateformat("yyyy-mm-dd hh:mm:ss");
 
         //创建一个date
         date date = new date();
 
         //格式化date 把日期转化成字符串
         system.out.println(sdf.format(date));
 
         //解析 把字符串转成日期
         date date2 = sdf.parse("2025-5-11 12:00:00");   //格式和上面的pattern一样
         system.out.println(date2);
 
     }
 }

system类

主要用于互殴去系统的属性数据和其他操作，构造方法私有

 package com.object.demo08;
 
 public class student {
     private string name;
     private int age;
 
     public student(string name, int age) {
         this.name = name;
         this.age = age;
     }
 
     public student() {
 
     }
 
     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;
     }
 
     @override
     public string tostring() {
         return "student{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
     }
 
     @override
     protected void finalize() throws throwable {
         system.out.println("回收了"+name+" "+age);
     }
 }

 package com.object.demo08;
 
 public class demo07 {
     public static void main(string[] args) {
         //不用创建system对象
         //arraycopy(); 参数：src,srcpos(指的是src的下标),dest,destpos,length
         int[] arr = {1,2,3,4,5,6,7,8,9};
         int[] dest = new int[8];
         system.arraycopy(arr,0,dest,0,8);
         for (int i = 0; i < dest.length; i++) {
             system.out.println(dest[i]);
         }
 
         //currenttimemillis(),获取当前系统时间，返回毫秒值 可以用来计算代码的执行时间
         system.out.println(system.currenttimemillis());
 
         long start = system.currenttimemillis();
         for (int i = 0; i < 9999; i++) {
             for (int j = 0; j < 9999; j++) {
                 int result = i+j;
             }
         }
         long end = system.currenttimemillis();
         system.out.println("用时"+(end - start));
 
 
         //system.gc(); 回收垃圾
 
         new student("aaa", 19);
         new student("bbb", 20);
         student s3 = new student("ccc", 21);
 
         system.gc();
 
         //exit(); 退出jvm
         system.exit(0);
         system.out.println("程序结束"); //上一行代码已经结束了程序，这行代码不会执行
 
     }
 }

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持代码网。

Java中的内部类和常用类用法解读

2025年05月12日 • Java •我要评论