一、内部类
内部类的分类
什么是内部类
- 概念:在一个类的内部再定义一个完整的类。
- 特点:
- 编译之后可生成独立的字节码文件
- 内部类可直接访问外部类的私有成员,而不破坏封装。
- 可为外部类提供必要的内部功能组件。
package commonclass.Demo01;
//身体
public class body {
private String name;
//头部
class Header{
public void show(){
System.out.println(name);
}
}
}
成员内部类
- 在类的内部定义,与实例变量、实例方法同级别的类。
- 外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象。
Outer out = new Outer()
Inner in = outer.new Inner()
- 当外部类、内部类存在重名属性时,会优先访问内部类属性.
- 成员内部类里不能定义静态成员.但可以定义静态常量。
package commonclass.Demo02;
//外部类
public class Outer {
//实例变量
private String name="张三";
private int age = 20;
//内部类
class Inner{
private String address="北京";
private int phone=110;
private String name="李四";
//成员内部类不能定义静态成员,但可以定义静态常量
private static final String country="中国";
//方法
public void show(){
//打印外部类的属性,内部类属性和外部类得到属性名字相同Outer.this
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
//当外部类、内部类存在重名属性时,会优先访问内部类属性。
System.out.println(name);
//打印内部类中的属性
System.out.println(this.address);
System.out.println(this.phone);
}
}
}
package commonclass.Demo02;
public class TextOuter {
public static void main(String[] args) {
//1.创建外部类对象
Outer outer = new Outer();
//2.创建内部类对象
Outer.Inner inner = outer.new Inner();
//一步到位
Outer.Inner inner2=new Outer().new Inner();
inner.show();
}
}
静态内部类
- 不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员。
- 只能直接访问外部类的静态成员(实例成员需实例化外部类对象)。
Outer.Inner inner = new Outer.Inner()
Outer.Inner.show()
package commonclass.Demo03;
public class Outer {
private String name="xxx";
private int age=18;
//静态内部类:级别和外部类相同
static class Inner{
private String address="上海";
private String phone="111";
//静态成员
private static int count=1000;
public void show(){
//调用外部类的属性
//1.先创建外部类对象
Outer outer = new Outer();
//2.调用外部类对象的属性
System.out.println(outer.name);
System.out.println(outer.age);
//调用静态内部类的方法和属性
System.out.println(address);
System.out.println(phone);
//调用静态内部类的静态属性
System.out.println(Inner.count);
}
}
}
package commonclass.Demo03;
public class TextOuter {
public static void main(String[] args) {
//直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();
//调用方法
inner.show();
}
}
局部内部类
- 定义在外部类方法中,作用范围和创建对象范围仅限于当前方法。
- 局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰为final。
- 限制类的使用范围。
package commonclass.Demo04;
public class Outer {
private String name="刘德华";
private int age=35;
public void show(){
//定义局部变量
final String address="深圳";//final可以省略
//局部内部类:注意不能加任何访问修饰符
class Inner{
//局部内部类的属性
private String phone="123456789";
private String email="123456789@qq.com";
//局部内部类不能定义静态成员,但可以定义静态常量
private static final String country="中国";
public void show2(){
//访问外部类的属性
System.out.println(Outer.this.name);//Outer.this.可以省略
System.out.println(Outer.this.age);//Outer.this.可以省略
//访问外部类的属性
System.out.println(this.phone);//this.可以省略
System.out.println(this.email);//this.可以省略
//访问局部变量,jdk1.7要求:变量必须是常量fianl,jdk1.8自动添加fianl
//address在方法里面,用完就消失了,而Inner不会消失,因此必须为常量。
System.out.println(address);
}
}
//创建局部内部类对象
Inner inner = new Inner();
inner.show2();
}
}
package commonclass.Demo04;
public class TextOuter {
public static void main(String[] args) {
Outer outer = new Outer();
outer.show();
}
}
匿名内部类
- 没有类名的局部内部类(一切特征都与局部内部类相同)。
- 必须继承一个父类或者实现一个接口。
- 定义类、实现类、创建对象的语法合并,只能创建一个该类的对象。
- 优点:减少代码量。
- 缺点可读性较差。
package commonclass.Demo05;
//接口
public interface Usb {
//服务
void service();
}
package commonclass.Demo05;
public class Mouse implements Usb{
@Override
public void service() {
System.out.println("连接电脑成功,鼠标开始工作了。。。");
}
}
package commonclass.Demo05;
public class UsbText {
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 commonclass.Demo05;
public class UsbText2 {
public static void main(String[] args) {
//使用匿名内部类优化(相当于创建了一个局部内部类)
Usb usb = new Usb(){
@Override
public void service() {
System.out.println("连接电脑成功,风扇开始转了。。。");
}
};
usb.service();
}
}
二、Object类
- 超类、基类,所有类的直接或间接父类,位于继承树的最顶层.
- 任何类,如没有书写extends显示继承某个类,都默认直接继承Object类,否则为间接继承.
- Object类中所定义的方法,是所有对象都具备的方法.
- Object类型可以存储任何对象.
- 作为参数,可接受任何对象.
- 作为返回值,可返回任何对象.
getClass()方法
public final Class<?> getClass(){}
- 返回引用中存储的实际对象类型.
- 应用:通常用于判断两个引用中实际存储对象类型是否一致.
hashCode()方法
public int hashCode(){}
- 返回该对象的哈希码值。
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值。
- 一般情况下相同对象返回相同哈希码。
toString()方法
public String toSring(){}
- 返回该对象的字符串表示(表现形式)。
- 可以根据程序需求覆盖该方法,如:展示对象各个属性值。
equals()方法
public boolean equals(Object obj){}
- 默认实现为(this == obj), 比较两个对象地址是否相同.
- 可进行覆盖,比较两个对象的内容是否相同.
finalize()方法
- 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列。
- 垃圾对象:没有有效引用指向此对象时,为垃圾对象。
- 垃圾回收:由GC销毁垃圾对象,释放数据存储空间。
- 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象。
- 手动回收机制:使用
System.gc();
通知JVM执行垃圾回收。
代码
package commonclass.Demo06;
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
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()){}
//intanceof 判断对象是否是某种类型
if (obj instanceof Student){
//4.强制转换类型
Student s=(Student)obj;
//5.比较熟悉
if (this.name.equals(s.getName())&&this.age==s.getAge()){ //字符串的比较用equals
return true;
}
}
return false;
}
@Override
protected void finalize() throws Throwable {
System.out.println(this.name+"垃圾被回收了");
}
}
package commonclass.Demo06;
public class StudentText {
public static void main(String[] args) {
//1.getClass方法
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和s2属于同一个类型");
}else{
System.out.println("s1和s2不属于同一个类型");
}
System.out.println("=================================");
//2.hashCode方法
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
Student s3=s1;
System.out.println(s3.hashCode());
System.out.println("=================================");
//3.toString方法
System.out.println(s1.toString());
System.out.println(s2.toString());
System.out.println("=================================");
//4.equals方法:判断两个对象是否相等
System.out.println(s1.equals(s2));
Student s4 = new Student("小明",17);
Student s5 = new Student("小明",17);
System.out.println(s4.equals(s5));
}
}
package commonclass.Demo06;
public class StudentText2 {
public static void main(String[] args) {
Student s1 = new Student("aaa",20);
Student s2 = new Student("bbb",20);
Student s3 = new Student("ccc",20);
Student s4 = new Student("ddd",20);
Student s5 = new Student("eee",20);
new Student("aaa",20);
new Student("bbb",20);
new Student("ccc",20);
new Student("ddd",20);
new Student("eee",20);
//垃圾回收
System.gc();
System.out.println("回收垃圾");
}
}
三、包装类
什么是包装类?
- 基本数据类型所对应的引用数据类型。
- Object 可统一所有数据,包装类的默认值是null。
包装类对应
类型转换与装箱、拆箱
- 8种包装类提供不用类型间的转换方式:
- Number父类中提供的6个共性方法。
parseXXX( )
静态方法。valueOf( )
静态方法。
- 注意:需保证类型兼容,否则抛出NumberFormatException异常。
代码
package commonclass.Demo07;
public class Demo01 {
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);
//JDK之后,提供自动装箱和拆箱
int age=30;
//自动装箱
Integer integer4=age;
System.out.println("自动装箱");
System.out.println(integer4);
//自动拆箱
int age2=integer4;
System.out.println("自动拆箱");
System.out.println(age2);
System.out.println("==========================================");
//基本类型和字符串之间的转换
//1.基本类型转换成字符串
int n1=255;
//1.1 使用+号
String s1=n1+" ";
//1.2 使用Integer中的toString方法
String s2=Integer.toString(n1,16); //改写成16进制
System.out.println(s1);
System.out.println(s2);
//2.字符串转成基本类型
String str="150";
//使用Integer.parsexxx();
int n2=Integer.parseInt(str);
System.out.println(n2);
//boolean字符串形式转成基本类型。"true"-->true 非"true"-->false
String str2="true";
String str3="tuer";
boolean b1=Boolean.parseBoolean(str2);
boolean b2=Boolean.parseBoolean(str3);
System.out.println(b1);
System.out.println(b2);
}
}
整数缓冲区
- Java预先创建了256个常用的证书包装类型对象。
- 在实际应用当中,对已创建的对象进行复用。
package commonclass.Demo07;
public class Demo02 {
public static void main(String[] args) {
//面试题
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1==integer2);
Integer integer3=100; //自动装箱Integer.valueOf
//相当于:Integer integer3=Integer.valueOf(100);
Integer integer4=100;
//相当于:Integer integer4=Integer.valueOf(100);
System.out.println(integer3==integer4);//true
Integer integer5=200; //自动装箱
//相当于:Integer integer5=Integer.valueOf(200);
Integer integer6=200;
//相当于:Integer integer6=Integer.valueOf(200);
System.out.println(integer5==integer6);//flase
/*
第一个:在堆里面他们新建了两个地址,地址不同,为false。
第二个:自动装箱相当于用了Integer.valueOf,在class文件中可查看,调用的为堆中缓存区数组中的同一个地址,为true。
第三个:也自动装箱相当于用了Integer.valueOf,在class文件中可查看,但是超出了缓存区数组 [-128, 127]的范围,会新建一个地址,为false。
*/
}
}
四、String类
- 字符串是常量,创建之后不可改变.
- 字符串字面值存储在字符串池中,可以共享.
String s = "Hello";
产生一个对象,字符串池中存储.String s = new String("Hello");
产生两个对象,堆、池各一个.
常用方法
public int length()
:返回字符串的长度。public char charAt(int index)
:根据下标获取字符.public boolean contains(String str)
:判断当前字符串是否包含str。public char[] toCharArray
:将字符串转换成数组。public int indexOf(String str)
:查找str首次出现的下标,存在,则返回该下标;不存在,则返回-1.public int lastIndexOf(String str)
:查找字符串在当前字符串最后一次出现的下标索引。public String trim()
:去掉字符串前后的空格。public String toUpperCase()
:将小写转成大写。public boolean endWith(String str)
:判断字符串是否以str结尾。public String replace(char oldChar,char newChar)
:将旧的字符串替换成新字符串。public String[] split(String str)
:根据str做拆分。
代码
package commonclass.Demo07;
import java.util.Arrays;
public class Demo03 {
public static void main(String[] args) {
String name="hello";//"hello"常量储存在字符串池中
name="zhangsan";//"张三"赋值给name变量,给字符串赋值时,并没有更改数据,而是重新开辟一个空间。
String name1="zhangsan";
//演示字符串的另一种创建方式,new String();
String str = new String("java");
String str2 = new String("java");
System.out.println(str==str2);
System.out.println(str.equals(str2));
System.out.println("==================================");
//字符串方法的使用
//1.length();返回字符串的长度
//2.charAt(int index);返回某个位置的字符
//3.contains(String str);判断是否保安某个字符串
String content="Java是世界上最好的Java编程语言,Java真香!";
System.out.println(content.length());
System.out.println(content.charAt(content.length()-1));
System.out.println(content.contains("Java"));
System.out.println(content.contains("php"));
System.out.println("=================================");
//字符串方法的使用
//4.toCharArray();返回字符串对应的数组
//5.indexOf();返回字符串首次出现的位置
//6.lastIndexOf();返回字符串最后一次出现的位置
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("Java"));
System.out.println(content.indexOf("Java",4));//从第几个字符开始
System.out.println(content.lastIndexOf("Java"));
System.out.println("=================================");
//7.trim();去掉字符串前后的空格
//8.toUpperCase;把小写转成大写。//toLowerCase;把大写转成小写。
//9.endWith(str);判断是否以str结尾。//startWith(str);判断是否以str开头。
String content2=" hello world ";
System.out.println(content2.trim());
System.out.println(content2.toUpperCase());
System.out.println(content2.toLowerCase());
String filename="hello.world";
System.out.println(filename.endsWith(".world"));
System.out.println(filename.startsWith("hello"));
System.out.println("==================================");
//10.replace(char old,char new); 用新的字符或字符串换旧的字符或字符串
//11.split;对字符串进行拆分
System.out.println(content.replace("Java","php"));
String say="java is the best programing language,java zhenxiang";
String[] arr=say.split("[ ,]+");//能拆分多个空格或者逗号。
System.out.println(arr.length);
for (String string : arr) {
System.out.println(string);
}
System.out.println("====================================");
//补充两个方法equals、compareTo();比较大小
String s1="hello";
String s2="HELLO";
System.out.println(s1.equalsIgnoreCase(s2));//忽视大小写
String s3="adc";//97
String s4="xyzqwe";//120
System.out.println(s3.compareTo(s4));//比较第一个字母的位置,97-120=-23.第一个字母相同的话,比较第二个字母。
String s5="adc";
String s6="adcqwe";
System.out.println(s5.compareTo(s6));//这种情况比较字符的长度 : 3-6=-3
}
}
案例演示
需求:
- 已知String str = “this is a text”;
- 将str中的单词单独获取
- 将str中的text替换成practice
- 在text前面插入一个easy
- 将每个单词的首字母改为大写
package commonclass.Demo07;
public class Demo04 {
public static void main(String[] args) {
String str = "this is a text";
//1.将str中的单词单独获取出来
String[] arr = str.split(" ");
for (String s : arr) {
System.out.println(s);
}
System.out.println("==============================");
//2.将str中的text替换成practice
String str2 = str.replace("text","practice");
System.out.println(str2);
System.out.println("==============================");
//3.在text前面插入一个easy
String str3 = str.replace("text","easy text");
System.out.println(str3);
System.out.println("==============================");
//4.将每个单词的首字母改为大写
for (int i = 0; i < arr.length; i++) {
char first = arr[i].charAt(0);
//把第一个字符换成大写
char upperfirst = Character.toUpperCase(first);
String news=upperfirst+arr[i].substring(1);//从第几个数开始截取
System.out.print(news+" ");
}
}
}
可变字符串
-
StringBuffer : 可变长字符串,运行效率慢、线程安全.
-
StringBuilder : 可边长字符串、运行快、线程不安全.
-
效率都比String高且节省内存.
package commonclass.Demo07;
/*
StringBuuffer和StringBuilder的使用:
和String的区别:
1.效率比String高
2.比String节省内存
*/
public class Demo05 {
public static void main(String[] args) {
//StringBuffer sb = new StringBuffer();
StringBuilder sb = new StringBuilder();
//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,5,"hello");
System.out.println(sb.toString());
//4. delete();删除
sb.delete(0,5);
System.out.println(sb.toString());
//清空
sb.delete(0,sb.length());
System.out.println(sb.length());
}
}
package commonclass.Demo07;
//验证StringBuilder效率比String高
public class Demo06 {
public static void main(String[] args) {
//开始时间
long start = System.currentTimeMillis();
String string = "";
for (int i = 0; i <99999 ; i++) {
string+=i;
}
System.out.println(string);
long end = System.currentTimeMillis();
System.out.println("用时:"+(end-start));
long start2 = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 99999; i++) {
sb.append(i);
}
System.out.println(sb.toString());
long end2 = System.currentTimeMillis();
System.out.println("用时:"+(end2-start2));
}
}
五、BigDecimal类
-
位置
java.math
包中 -
作用 精确计算浮点数
-
创建方式
BigDecimal bd = new BigDecimal("1.0");
-
方法:
BigDecimal add(BigDecimal bd)
加BigDecimal subtract(BigDecimal bd)
减BigDecimal multiply(BigDecimal bd)
乘BigDecimal divide(BigDecimal bd)
除
-
除法:
divide(BigDeciaml bd,int scal, RoundingMode mode)
-
参数scal:指定精确到小数点后几位。
-
参数mode:
- 指定小数部分的取舍模式,通常采用四舍五入的模式.
- 取值为
BigDeciaml.ROUND_HALF_UP.
package commonclass.Demo07;
import java.math.BigDecimal;
public class Demo07 {
public static void main(String[] args) {
double d1=1.0;
double d2=0.9;
System.out.println(d1-d2);//double类型储存的是一个近似值
//面试题
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");
//减法
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1);
//加法
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2);
//乘法
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3);
//除法
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));
System.out.println(r4);
BigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
//保留两位小数,并且四舍五入。
System.out.println(r5);
}
}
六、时间类型
Date类
-
Date表示特定的瞬间,精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
-
时间单位:
- 1秒=1000毫秒;
- 1毫秒=1000微秒
- 1微秒=1000纳秒
package commonclass.Demo08;
import java.util.Date;
public class Demo01 {
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()-(60*60*24*1000));
System.out.println(date2.toLocaleString());
//2.方法after before
boolean b1 = date1.after(date2);
boolean b2 = date2.after(date1);
System.out.println(b1);
System.out.println(b2);
//比较compareTo();
int d3 = date1.compareTo(date2);
System.out.println(d3);
//比较是否相等equals()
boolean d4 = date1.equals(date2);
System.out.println(d4);
}
}
Calendar类
- Calendar提供了获取或设置各种日历字段的方法.
- 构造方法
protected Calendar():
由于是protected ,所以无法直接创建该对象. - 其他方法:
方法名 | 说明 |
---|---|
static Calendar getInstance() | 使用默认时区和区域获取日历 |
void set(int year, int month, int date, int hourofday, int minute, int second) | 设置日历的年、月、日、时、分、秒 |
int get(int field) | 返回给定日历字段的值。字段比如年、月、日 |
void setTime(Date date) | 用给定的date设置此日历时间 |
Date getTime() | 返回一个date表示此日历的时间 |
void add(int field, int amount) | 按照日历的规则,给指定字段添加或减少时间量 |
long getTimeInMilles() | 毫秒为单位返回该日历的时间值 |
package commonclass.Demo08;
import java.util.Calendar;
public class Demo02 {
public static void main(String[] args) {
//1.创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());
System.out.println(calendar.getTimeInMillis());
//2.获取时间信息
//获取年
int year = calendar.get(Calendar.YEAR);
//月
int month = calendar.get(Calendar.MONTH);
//日
int day = calendar.get(Calendar.DAY_OF_MONTH);//也可以写Date
//小时
int hour = calendar.get(Calendar.HOUR_OF_DAY);//24小时
int hour2 = calendar.get(Calendar.HOUR);//12小时
//分钟
int minute = calendar.get(Calendar.MINUTE);
//秒
int second = calendar.get(Calendar.SECOND);
System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second+";");
//3.修改时间
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH,5);
System.out.println(calendar2.getTime().toLocaleString());
//4.add方法修改时间
calendar2.add(Calendar.HOUR,-1);
System.out.println(calendar2.getTime().toLocaleString());
//5.补充方法
calendar2.add(Calendar.MONTH,3);
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max);
System.out.println(min);
}
}
SimpleDateFormat
- SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类.
- 进行格式化(日期→文本)、解析(文本→日期).
- 常用的时间模式字母.
字母 | 日期或时间 | 示例 |
---|---|---|
y | 年 | 2019 |
M | 年中月份 | 08 |
d | 月中天数 | 10 |
H | 一天中小时(0-23) | 22 |
m | 分钟 | 16 |
s | 秒 | 59 |
S | 毫秒 | 356 |
package commonclass.Demo08;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo03 {
public static void main(String[] args) throws ParseException {
//1.创建SimpleDateFormat对象y年m月
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年mm月dd日 HH-mm-ss");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/mm/dd");
//2.创建Date
Date date = new Date();
//3.格式化date(把日期转成字符串)
String str = sdf.format(date);
System.out.println(str);
//解析(把字符串转成日期)
Date date2 = sdf2.parse("1990/05/01");
System.out.println(date2);
}
}
七、System类
- System类是系统类,主要用于获取系统的属性数据和其他操作,构造方法私有的。
方法名 | 说明 |
---|---|
static void arraycopy(…) | 复制数组 |
static long currentTimeMillis(); | 获取当前系统时间,返回毫秒值 |
static void gc(); | 建议JVM赶快启动垃圾回收期器回收垃圾 |
static void exit(int status); | 退出jvm 如果参数是0表示正常退出jvm ,非0表示异常退出jvm。 |
package commonclass.Demo08;
import java.util.Arrays;
public class Demo04 {
public static void main(String[] args) {
//1.arraycopy:数组的复制
//src:原数组
//srcPos:从哪个位置开始复制
//dest:目标数组
//destPos:目标数组的位置
//length:复制的长度
int[] arr = {1,2,3,4,5,6,7};
int[] dest = new int[7];
System.arraycopy(arr,4,dest,4,3);
for (int i = 0; i <dest.length ; i++) {
System.out.println(dest[i]);
}
//Arrays.copyOf(arr,7);
//2.获取毫秒数
System.out.println("============================");
System.out.println(System.currentTimeMillis());
long start = System.currentTimeMillis();
for (int i = -7777777; i <7777777 ; i++) {
for (int j = 0-7777777; j <7777777 ; j++) {
int s=i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("用时:"+(end-start));
//3.回收垃圾
System.out.println("===================================");
new Student("aaa",17);
new Student("bbb",17);
new Student("ccc",17);
System.gc();//告诉垃圾回收器回收
//4.退出JVM
System.out.println("程序快结束了。。。");
System.exit(0);
System.out.println("程序结束了。。。");
}
}
package commonclass.Demo08;
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
protected void finalize() throws Throwable {
System.out.println("回收了"+name+" "+age);
}
}
八、总结
-
内部类
- 在一个类的内部再定义一个完整的类。
- 成员内部类、静态内部类、局部内部类、匿名内部类。
-
Object类:
- 所有类的直接或间接父类,可储存任何对象。
-
包装类:
- 基本数据类型所对应的引用数据类型,可以使Object统一所有数据。
-
String类:
- 字符串是常量,创建之后不可改变,字面值保存在字符串池中,可以共享。
-
BigDeciaml:
- 可精确计算浮点数
-
Date
- 特定时间
-
Calendar
- 日历
-
SimpleDateFormat
- 格式化时间
-
System
- 系统类