Java内部类 常用类，局部内部类只使用一次
分享于 点击 30892 次 点评：276
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("程序结束"); //上一行代码已经结束了程序，这行代码不会执行
}
}
用户点评