内部类（Inner Class）
什么是内部类
-
概念：在一个类的内部在定义一个完整的类。
- 例
class Outer{ class Inner{ } } -
特点：
- 编译之后可生成独立的字节码文件。
- 内部类可直接访问外部类的私有成员，而不破坏封装。
- 可为外部类提供必要的内部功能组件。
成员内部类
-
在类的内部定义，与实例变量、实例方法同级别的类。
-
外部类的实例部分，创建内部类对象时，必须依赖外部类对象。
- Outer out = new Outer();
- Inner in = out.new Inner();
-
当外部类、内部类存在重名属性时，会优先访问内部类属性。
-
成员内部类不能定义静态成员。
-
实例：
// 外部类 public class Outer { // 实例变量 private String name = "张三"; private int age = 20; // 内部类 class Inner{ private String address = "山西"; private String Phone = "110"; // 和外部类的属性名字相同 private String name = "李四"; // 成员内部类是不能包含静态成员的 // private static String country = "123"; // 但是成员内部类可以包含静态常量 private static final String country = "123"; // 方法 public void show(){ // 如果当外部类、内部类存在重名属性时，会优先访问内部类属性 System.out.println(name); // 打印外部类的属性,内部类属性和外部类属性名字相同 外部类.this.外部类属性 System.out.println(Outer.this.name); System.out.println(Outer.this.age); // 打印内部类的属性 System.out.println(this.address); System.out.println(this.Phone); } } } public static void main(String[] args) { // 创建外部类对象 // Outer out = new Outer(); // 创建内部类对象 // Outer.Inner in = out.new Inner(); // 一步到位 与 以上 输出相同 Outer.Inner in = new Outer().new Inner(); in.show(); }
静态内部类
-
不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
-
只能直接访问外部类的静态成员（实例成员需实例化外部类对象）。
- Outer.Inner inner = new Outer.Inner();
- Outer.Inner.show();
-
实例：
// 外部类 public class StaticOuter { private String name = "张三"; private int age = 20; // 静态内部类：的级别和外部类相同 // 只有静态内部类才能用static修饰，正常的类是不能用static的 static class StaticInner{ private String address = "阳泉"; private String phone = "120"; // 静态成员 private static int count = 1000; public void show(){ // 怎样调用外部类的属性呢？ // 先创建外部类对象 StaticOuter so = new StaticOuter(); // 调用外部类对象属性 System.out.println(so.name); System.out.println(so.age); // 调用静态内部类的属性和方法 System.out.println(address); System.out.println(phone); // 调用静态类内部类的静态属性 System.out.println(StaticInner.count); } } } public class StaticOuterTest { public static void main(String[] args) { // 直接创建静态内部类对象 StaticOuter.StaticInner sosi = new StaticOuter.StaticInner(); // 调用方法 sosi.show(); } }
局部内部类
-
定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
-
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
-
限制类的适用范围。
-
实例：
public class LocalOuter { private String name = "张三"; private int age = 10; public void show(){ // 定义局部变量 String address = "杭州"; // 局部内部类：注意不添加任何访问修饰符 class LocalInner{ // 局部内部类的属性 private String phone = "1384224"; private String email = "2625008924@qq.com"; // 局部内部类也是不能包括静态的 public void show2(){ // 访问外部类的属性 System.out.println(LocalOuter.this.name); System.out.println(LocalOuter.this.age); // 访问内部类的属性 System.out.println(this.email); System.out.println(this.phone); // 访问局部变量：注意 jdk1.7以前变量必须是常量final,jdk1.8以后自动添加final System.out.println(address); } } // 创建局部内部类对象 LocalInner li = new LocalInner(); li.show2(); } } public class LocalOuterTest { public static void main(String[] args) { LocalOuter lo = new LocalOuter(); lo.show(); } }
匿名内部类
-
没有类名的局部内部类（一切特征都与局部内部类相同）。
-
必须继承一个父类或者实现一个接口。
-
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
-
优点：减少代码量。
-
缺点：可读性较差。
-
实例：
// 接口 public interface USB{ void serivce();// 服务方法 } public class TestUSB{ public static void main(String[] args){ // 创建接口类型的变量 /*USB u = new Mouse(); u.service();*/ // 局部内部类 /*class Fan implements USB{ @Override public void service(){ System.out.pritln("连接电脑成功，风扇开始工作了……")； } } // 使用局部内部类创建对象 USB u = new Fan(); u.service();*/ // 使用匿名内部类来优化(相当于创建了一个局部内部类) USB u = new USB(){ @Override public void service(){ System.out.pritln("连接电脑成功，风扇开始工作了……")； } }; u.service(); } } public class Mouse implements USB{ @Override public void service(){ System.out.println("连接电脑成功，鼠标开始工作了……"); } }
Object类
- 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
- 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
- Object类中所定义的方法，是所有对象都具备的方法。
- Object类型可以储存任何对象。
- 作为参数，可接受任何对象。
- 作为返回值，可返回任何对象。
getClass() 方法
-
public final Class<?> getClass(){}
-
返回引用中储存的实际对象类型。
-
应用：通常用于判断两个引用中实际储存对象类型是否一致。
-
实例：
public class Student{ private String name; private int 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; } public AnonymityOuter(){ } public AnonymityOuter(String name, int age) { super(); this.name = name; this.age = age; } } public class TestStudent{ public static void main(String[] args){ Student s1 = new Student("aaa",20); Student s2 = new Student("bbb",20); // 判断s1和s2是不是同一个类型 Class class1 = s1.getClass(); Class class2 = s2.getClass(); if(class1==class2){ System.out.println("s1和s2属于同一个类型"); }else{ System.out.println("s1和s2不属于同一个类型"); } } } // 输出：s1和s2属于同一个类型
hashCode()方法
-
public int hashCode () {}
-
返回该对象的哈希码值。
-
哈希值根据对象的地址或字符串或数组使用hash算法计算出来的int类型的数值。
-
一般情况下相同对象返回相同哈希码。
-
实例：
public class Student{ private String name; private int 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; } public AnonymityOuter(){} public AnonymityOuter(String name, int age) { super(); this.name = name; this.age = age; } } public class TestStudent{ public static void main(String[] args){ Student s1 = new Student("aaa",20); Student s2 = new Student("bbb",20); // hashCode方法 // 两个输出肯定是不一样的 System.out.println(s1.hashCode()); System.out.println(s2.hashCode()); // 这里s3三的输出与s1一样 Student s3 = s1; System.out.println(s3.hashCode()); } }
toString()方法
-
public String toString(){}
-
返回该对象的符串表示（表现形式）。
-
可以根据程序需求覆盖该方法，如：展示对象各个属性值。
-
实例：
public class Student{ private String name; private int 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; } public AnonymityOuter(){} public AnonymityOuter(String name, int age) { super(); this.name = name; this.age = age; } // 在这里重写toString方法() 如果不重写会输出十六进制 可以看到方法的路径 @Override public String toString(){ return "Student [name="+ name +"，age="+ age +"]"; } } public class TestStudent{ public static void main(String[] args){ Student s1 = new Student("aaa",20); Student s2 = new Student("bbb",20); // toString方法 System.out.println(s1.toString());// Student [name=aaa，age=20] System.out.println(s2.toString());// Student [name=bbb，age=20] } }
equals()方法
-
public boolean equals(Object obj){}
-
默认实现为（this == obj），比较两个对象地址是否相同。
-
可进行覆盖，比较两个对象的内容是否相同。
-
实例：
public class Student{ private String name; private int 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; } public AnonymityOuter(){} public AnonymityOuter(String name, int age) { super(); this.name = name; this.age = age; } } public class TestStudent{ public static void main(String[] args){ Student s1 = new Student("aaa",20); Student s2 = new Student("bbb",20); // equals方法，判断两个对象是否相等 System.out.println(s1.equals(s2));// false Student s3 = new Student("张三",18); Student s4 = new Student("张三",18); System.out.println(s3.equals(s4));// false /* 这里因为它是在堆中创建的，每个的地址都不一样，所以equals比较出来的都是false */ } }
equals()方法覆盖步骤
-
比较两个引用是否指向同一个对象。如果是就直接返回true了
-
判断obj是否为null。
-
判断两个引用指向的实际对象类型是否一致。
-
强制类型转换。
-
依次比较各个属性值是否相同。
-
实例：（实现方法覆盖，判断两个对象的内容是否相同）
public class Student{ private String name; private int 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; } public AnonymityOuter(){} public AnonymityOuter(String name, int age) { super(); this.name = name; this.age = age; } // 重写equals方法 @Override public boolean equals(Object obj){ // 1、判断两个对象是否是另一个引用 if(this == obj){ return true; } // 2、判断obj是否null if(obj == null){ return false; } // 3、判断是否是同一个类型 //(this.getClass() == obj.getClass()){} // instanceof 它可以判断对象是否是某种类型 if(obj instanceof Student){ // 4、强制类型转换 Student s = (Student)obj; // 5、比较 字符串类型比较用equals if(this.name.equals(s.getName())&&this.age==s.getAge()){ return true; } } return false; } } public class TestStudent{ public static void main(String[] args){ Student s1 = new Student("aaa",20); Student s2 = new Student("bbb",20); // equals方法，判断两个对象是否相等 System.out.println(s1.equals(s2));// false Student s3 = new Student("张三",18); Student s4 = new Student("张三",18); System.out.println(s3.equals(s4));// 重写之前false 经过重写为true } }
finalize()方法
-
当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
-
垃圾对象：没有有效引用指向此对象时，为垃圾对象。
-
垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
-
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
-
手动回收机制：使用System.gc()：通知JVM执行垃圾回收。
-
实例：
public class Student { private String name; private int 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; } public Student(){ } public Student(String name, int age) { this.name = name; this.age = age; } @Override protected void finalize() throws Throwable { System.out.println(this.name+"对象被回收了"); } } public class ObjZong { public static void main(String[] args) { System.out.println("------------finalize------------"); // Student s6 = new Student("李四",20); // Student s7 = new Student("王五",21); // Student s8 = new Student("赵六",22); new Student("李四",20); new Student("王五",21); new Student("赵六",22); System.gc(); System.out.println("回收"); } } /* 输出： 回收 赵六对象被回收了 王五对象被回收了 李四对象被回收了 */
包装类
什么是包装类
-
基本数据类型所对应的引用数据类型。
-
Object可统一所有数据，包装类的默认值是null。
-
Java是一个面向对象的编程语言，但是Java中的八种基本数据类型却是不面向对象的，为了使用方便和解决这个不足，在设计类时为每个基本数据类型设计类一个对应的类进行代表，这样八种基本数据类型对应的类统称为包装类（Wrapper Class），包装类均位于java.lang包。
-
为了使用方便Java中将8种基本数据类型进行了封装
boolean ——>Boolean
char——>Character
byte——>Byte
long——>Long
int——>Integer
float——>Float
double——>Double
short——>Short
类型转换和装箱、拆箱
-
8种包装类提供不同类型间的转换方式：
- Number父类中提供的六个共性方法。
// 类型转换：装箱，基本类型转换或引用类型的过程 // 基本类型 int num1 = 18; // 使用Integer类创建对象 Integer integer1 = new Integer(num1); Integer integer2 = Integer.valueOf(num1); // 类型转型：拆箱，引用类型转成基本类型 Integer integer3 = new Integer(100); int num2 = integer3.intValue(); // JDK1.5之后，提供自动装箱和拆箱 int age = 30; // 自动装箱 Integer integer4 = age; // 自动拆箱 int age2 = integer4;
整数缓冲区（Integer）
-
Java预先创建了256个常用的整数包装类型对象。
-
在实际应用当中，对已创建的对象进行复用。
-
实例：
Integer i1 = new Integer(100); Integer i2 = new Integer(100); System.out.println(i1==i2); // 这里Integer的长度是-128到127之间 Integer i3 = Integer.valueOf(100); Integer i4 = Integer.valueOf(100); System.out.println(i3==i4); // 超出这个长度 Integer会自动创建一个对象 new Integer i5 = Integer.valueOf(200); Integer i6 = Integer.valueOf(200); // 所以i5就不等于i6 System.out.println(i5==i6);
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xdEpEw7p-1615550418791)(D:\学习\tupian\Integer\i.png)]](https://i-blog.csdnimg.cn/blog_migrate/a0bea06538356fcc70f4c7efc81446bd.png#pic_center)
String
- 字符串是常亮，创建之后不可改变。
- 字符串字面值储存在字符串池中，可以共享。
- String s = “Hello”;产生一个对象，字符串池中储存
- String s = new String(“Hello”);//产生两个对象，堆、池各储存一个。
String name = "zhangsan";
name = "李四";
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-42iVala6-1615550418794)(D:\学习\tupian\String\swt.png)]
-
以上，我们给一个String类型赋值，在字符串池中就会生成一个值。这时我们再给同一个String类型赋另一个值“李四”。
刚才的“zhangsan”并不会从字符串池中消失，而是在字符串池中新建一个“李四”。
栈中的String类型就会断开对“shangsan”的连接转而连接“李四”。
如果再次给这个String类型赋值“zhangsan”的话，会现在字符串池中判断有没有这个值，有就连接，没有就新建。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F2dPc3rM-1615550418799)(D:\学习\tupian\String\swt2.png)]](https://i-blog.csdnimg.cn/blog_migrate/e1b9d71a2da43cb0503f9fc9d7b0b464.png#pic_center)
-
通过上图我们发现两个String类型的值是一样的，相对比的输出结果却是false。
那是因为new出来的对象是指向堆的，每new一下堆都会创建一个对象，他们的地址不同，“==”对比的是地址而不是值，所以才会输出false。
所以字符串类型对比我们一般使用“equals”。
常用方法
-
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做拆分
-
compareTo(); 比较大小
-
实例：
String name = "zhangsan"; name = "李四"; String n1 = new String("王五"); String n2 = new String("王五"); System.out.println(n1==n2);// 输出false System.out.println(n1.equals(n2)); System.out.println("------------------------------"); // public int length(); 返回字符串的长度。 // public char charAt(int index); 根据下标获取字符。 // public boolean contains(String str); 判断当前字符串中是否包含str。 String contents = "One Piece;One Piece;One Piece"; System.out.println(contents.length());// 返回字符串的长度 System.out.println(contents.charAt(0));// 根据下标位置返回值 第一位 System.out.println(contents.charAt(contents.length()-1));// 最后一位 System.out.println(contents.contains("O"));// 查看字符串中有没有这个值 // public char[] toCharArray(); 将字符串转换成数组。 // public int indexOf(String str); 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1. // public int lastIndexOf(String str); 查找字符串在当前字符串中最后一次出现的下标索引。 System.out.println(Arrays.toString(contents.toCharArray()));// 将字符串转换成数组 System.out.println(contents.indexOf("One"));// 寻找字符第一次出现的位置 System.out.println(contents.indexOf("One",3)); // 从下标第几位找字符第一次出现的位置 System.out.println(contents.lastIndexOf("One"));// 寻找字符最后出现的位置 // public String trim(); 去掉字符串前后的空格。 // public String toUpperCase(); 将小写转成大写 toLowerCase() 将大写转换为小写 // public boolean endsWith(String str); 判断字符串是否以str结尾 startsWith(String str)判断字符串是否以str开头 String cont = " Hello World "; System.out.println(cont.trim());// 去掉字符串前后的空格 System.out.println(cont.toUpperCase());// 将小写转成大写 System.out.println(cont.toLowerCase());// 将大写转换为小写 String wj = "java.jpg"; System.out.println(wj.endsWith("jpg"));// 判断字符串是否以str结尾 System.out.println(wj.startsWith("java"));// 判断字符串是否以str开头 System.out.println("===========replace替换============="); String con = "罗小黑战记"; System.out.println(con.replace("黑","白")); System.out.println("===========split根据……分割============="); String str = "你是 谁啊？ 哈哈 想起来了。。。嗯！好"; String[] s = str.split("[ ？。！]+"); // split分割出是数组类型 所以要用数组类型接收 for (String s1:// 遍历 s 数组 s) { System.out.println(s1); } System.out.println("===========compareTo()比较大小============="); String ch1 = "abc"; String ch2 = "xyz"; System.out.println(ch1.compareTo(ch2));// compareTo比较大小只比较第一位 输出 -23 String ch3 = "abc"; String ch4 = "axy"; System.out.println(ch3.compareTo(ch4));// 如果第一位相同就比较第二位的大小 输出 -23 String ch6 = "abc"; String ch7 = "abcxyzzz"; System.out.println(ch6.compareTo(ch7));// 如果只是这种情况，那么比的就是字符串的长度大小 输出 -5 // equalsIgnoreCase 除去大小写比值 String r1 = "abc"; String r2 = "ABC"; System.out.println(r1.equalsIgnoreCase(r2));
案例演示
-
需求：
- 已知String str = “this is a text”;
- 1.将str中的单词单独获取出来
- 2.将str中的text替换为practice
- 3.在text前面插入一个easy
- 4.将每个单词的首字母改为大写
String str = "this is a text"; // 1.将str中的单词单独获取出来 String[] s = str.split("[ ]"); for (String s1:s) { System.out.println(s1); } // 2.将str中的text替换为practice System.out.println(str.replace("text","practice")); // 3.在text前面插入一个easy System.out.println(str.replace("text","easy text")); // 4.将每个单词的首字母改为大写 for (int i = 0; i < s.length; i++) { char c = s[i].charAt(0); char c1 = Character.toUpperCase(c); String news = c1+s[i].substring(1); System.out.println(news); }
可变字符串
-
StringBuffer：可变长的字符串，JDK1.0提供，运行效率慢、线程安全。
-
StringBuilder：可变长字符串，JDK1.5提供，运行效率快、线程不安全。，
-
实例：
// StringBuilder和StringBuffer的用法一样，只不过StringBuilder更快，StringBuffer安全 // 单线程推荐StringBuilder StringBuffer sb = new StringBuffer(); // 在字符串的最后追加字符串 sb.append("来日方长"); System.out.println(sb.toString()); sb.append("，何惧车遥马慢"); System.out.println(sb.toString()); // 在下标0添加字符串 sb.insert(0,"呵呵"); System.out.println(sb.toString()); // 替换下标0-2的字符串 sb.replace(0,2,"笑谈："); System.out.println(sb.toString()); // 删除下标0-3的字符串 sb.delete(0,3); System.out.println(sb.toString()); // 删除所有 sb.delete(0,sb.length()); System.out.ntln(sb.length());[]
BigDecimal的使用
- 思考：一下程序输出结果是多少？
public class TestBigDecimal{
public static void main(String[] args){
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2);
}
}
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dERWC3WT-1615550418804)(D:\学习\tupian\bigdecimal\de.png)]](https://i-blog.csdnimg.cn/blog_migrate/95038bab3e36a6bcb8ccd2cfe01f695b.png#pic_center)
-
位置：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(BigDecimal bd,int scal,RoundingMode mode)
- 参数scal：指定精确到小数点后几位。
- 参数mode：
- 指定小数部分的取舍模式，通常采用四舍五入的模式
- 取值为BigDecimal.ROUND_HALF_UP
-
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2);
// 面试题
double result = (1.4-0.5)/0.9;
System.out.pritln(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);
// 因为10除以3会有余数，所以我们这里加了int scal,RoundingMode mode两个参数
BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3")
,2,BigDecimal
.ROUND_HALF_UP);
Date
- Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。
- 时间单位
- 1秒 = 1000毫秒
- 1毫秒 = 1000微秒
- 1微秒 = 1000纳秒
// 今天
// toString()将此 Date对象转换为 String的形式
// 不过转换出来的日期格式部分人可能不容易接收
// 所以我们就使用date的另一个方法toLocaleString() 虽然已禁用 但是日期的格式更容易接收
Date date1 = new Date();
System.out.println("使用toString()方法显示当前的时间："+date1.toString());
System.out.println("使用roLocaleString()方法显示当前的时间"+date1.toLocaleString());
System.out.println();
// 昨天
// getTime()返回自1970年1月1日以来，由此 Date对象表示的00:00:00 GMT的毫秒数。
Date date2 = new Date(date1.getTime()-(60*60*24*1000));
System.out.println("昨天，现在的时间"+date2.toLocaleString());
// after()测试此日期是否在指定日期之后。
boolean b1 = date1.after(date2);
System.out.println(b1);
// before()测试此日期是否在指定日期之前。
boolean b2 = date2.before(date1);
System.out.println(b2);
// 比较 compareTo()
// 比较两个日期进行订购。相等返回0，大于返回1，小于返回-1.
int d = date2.compareTo(date1);
System.out.println(d);
// 比较是否相等 equals()
boolean b3 = date1.equals(date2);
System.out.println(b3);
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wfd8q2cT-1615550418807)(D:\学习\tupian\date\da.png)]](https://i-blog.csdnimg.cn/blog_migrate/64f2b3956f17fb4ed2e827a200d66a17.png#pic_center)
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-Calendar Date getTime() 返回一个Date表示此日历的时间。Calendar-Date void add(int field,int amount) 按照日历的规则，给指定字段添加或减少时间量 long getTimeInMillies() 毫秒为单位返回该日历的时间值 -
实例：
// 创建Calendar对象 // getInstance()使用默认时区和区域设置获取日历 Calendar calendar = Calendar.getInstance(); // getTime()返回一个 Date表示此物体 Calendar的时间值（毫秒从偏移 Epoch “）。 System.out.println(calendar.getTime().toLocaleString()); // getTimeInMillis() 以毫秒为单位返回此日历的时间值 System.out.println("以毫秒为单位返回此日历的时间值："+calendar.getTimeInMillis()); // 获取时间信息 // 获取年 int year = calendar.get(Calendar.YEAR); // 月 int month = calendar.get(Calendar.MONTH); // 日 int day = calendar.get(Calendar.DAY_OF_MONTH); // 小时 int hour = calendar.get(Calendar.HOUR_OF_DAY); // 分钟 int minute = calendar.get(Calendar.MINUTE); // 秒 int second = calendar.get(Calendar.SECOND); System.out.println("获取年、月、日、时、分、秒："+year+"年"+(month+1)+"月"+day+"日"+hour+";"+minute+":"+second); // 修改时间 Calendar calendar2 = Calendar.getInstance(); // DAY_OF_MONTH get字段编号和 set本月的日期 calendar2.set(Calendar.DAY_OF_MONTH,5); System.out.println(calendar2.getTime().toLocaleString()); // add方法修改时间 根据日历的规则，将指定的时间量添加或减去给定的日历字段。 // HOUR：get和 set字段编号， get上午或下午的小时。 calendar2.add(Calendar.HOUR,-2); System.out.println(calendar2.getTime().toLocaleString()); // 补充方法 // getActualMaximum：给定此 Calendar的时间值，返回指定日历字段可能具有的 Calendar 。 int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH); int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZygKt2gc-1615550418810)(D:\学习\tupian\calendar\cc.png)]](https://i-blog.csdnimg.cn/blog_migrate/f95d9eb21143131f3ff88b98f3f0cb84.png#pic_center)
SimpleDateFormat
-
SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
-
进行格式化（日期 —> 文本）、解析（文本 —> 日期）。
-
常用的时间模式字母
字母 日期或时间 示例 y 年 2020 M 年中月份 08 d 月中天数 10 H 1天中小时数（0-23） 22 m 分钟 16 s 秒 59 S 毫秒 367 -
示例：
// 1创建SimpleDateFormat对象 y 年 M 月 // SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 2创建Date Date date = new Date(); // 格式化date(把日期转成字符串) String str = sdf.format(date); System.out.println(str); // 解析（把字符串转成日期）[你的日期格式必须和上面的一样] Date date2 = sdf.parse("1990-05-01"); System.out.println(date2.toLocaleString());![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UNKoJKVv-1615550418813)(D:\学习\tupian\SimpleDateFormat\simple.png)]](https://i-blog.csdnimg.cn/blog_migrate/de03eadd7face80f40c0a8ad76673cd4.png#pic_center)
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd"); // 如果parse里的字符串格式和SimpleDateFormat里的格式不一样的时候 Date date3 = sdf1.parse("1990/05/01"); // 你的输出就会报错 System.out.println(date3.toLocaleString()); /* * Exception in thread "main" java.text.ParseException: Unparseable date: "1990/05/01" * at java.text.DateFormat.parse(DateFormat.java:366) * at simpleDateFormat.SimpleDateFormat_Test.main(SimpleDateFormat_Test.java:18) * */![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LCvf986S-1615550418816)(D:\学习\tupian\SimpleDateFormat\try.png)]](https://i-blog.csdnimg.cn/blog_migrate/9310964443db734c5412b0aab41acfb3.png#pic_center)
System类
-
System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。
方法名 说明 static void arrayoopy(…) 复制数组 static long currentTimeMillis(); 获取当前系统时间，返回的是毫秒值 static void gc(); 建议JVM赶快启动垃圾回器回收垃圾 static void exit(int status); 退出jvm，如果参数是0表示正常退出jvm，非表示异常退出jvm。 -
实例：
// arraycopy,数组的复制 /* src：原数组 srcPos：从哪个位置开始复制 dest：目标数组 destPos：目标数组的位置 length：复制的长度 */ int[] arr = {20,18,15,8,35,26,45,90} int[] dest = new int[8]; System.arraycopy(arr,4,dest,4,4); for(int i = 0;i < dest.length;i++){ System.out.println(dest[i]); } // Arrays.copyOf(original,newLength);内部代码用的就是System.arraycopy System.out.println(System.currentTimeMillis()); long start = System.currentTimeis(); for(int i = -9999999;i < 99999999;i++){ for(int j = -9999999;j<99999999;j++){ int result = i+j; } } long end = System.currentTimeMillis(); System.out.println("用时："+(end-start)); // System.gc();告诉垃圾回收器回收 // 退出jvm System.exit(0); System.out.println("---退出jvm后这个输出语句就不会输出了---")
总结
- 内部类：
- 在一个类的内部再定义一个完整的类。
- 成员内部类、静态内部类、局部内部类、匿名内部类
- Object类：
- 所有类的直接或间接父类，可储存任何对象。
- 包装类：
- 基本数据类型所对应的引用数据类型，可以使Object统一所有数据。
- String类：
- 字符串是常亮，创建之后不可改变，字面值保存在字符串池中，可以共享。
- BigDecimal：
- 可精确计算浮点数。
- Date
- 特定时间
- Calendar
- 日历
- SimpleDateFormat
- 格式化时间
- System
- 系统类
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
