常用类
内部类
1.成员内部类
概念：在一个类的内部再定义一个完整的类，与实例变量，实例方法同级别。
public class Outer{
class Inner{
}
}
特点：
-
编译之后可生成独立的字节码文件。
-
内部类可直接访问外部类的私有成员方法，而不破坏封装。
-
可为外部类提供必要的内部功能组件。
-
当外部类，内部类存在重名属性时，会优先访问内部类属性。
-
成员内部类不能定义静态成员。
package com.study.test1; //外部类 public class OuterTest { //实例变量 private String name = "张三"; private int age = 20; //内部类 class Inner{ private String address = "北京"; private String phone = "110"; private String name = "莉丝"; //private static final相当于常量，成员内部类不能定义静态成员 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(address); System.out.println(phone); } } public static void main(String[] args) { //1. 创建外部类对象 // Outer outer = new Outer(); //2. 创建内部类对象 // Inner inner = outer.new Inner(); //一步到位 Inner inner = new Outer().new Inner(); inner.show(); } }
2.静态内部类
不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。相当外部类
package com.study.test1;
//外部类
public class Outer {
//实例变量
private String name = "LiLi";
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();
//调用外部类对象的属性
System.out.println(outer.name);
System.out.println(outer.age);
//调用静态内部类的属性和方法
System.out.println(address);
System.out.println(phone);
//调用静态内部类的静态属性
System.out.println(Inner.count);
}
}
public static void main(String[] args) {
//1. 直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();
//2. 调用方法
inner.show();
}
}
3.局部内部类
- 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
- 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
- 限制类的使用范围。
package com.study.test3;
//外部类
public class Outer {
private String name = "刘德华";
private int age = 35;
public void show(){
//定义局部变量
final String address = "深圳";
//局部内部类:注意不能加任何访问修饰符
class Inner{
private String phone = "12333333333";
private String email = "liydehua@163.com";
//private final static int count = 2000;
public void show2(){
//访问外部类的属性
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
//访问内部类的属性
System.out.println(this.phone);
System.out.println(this.email);
//访问局部变量,jdk1.7要求，变量必须是常量final, jdk1.8自动添加final
System.out.println(address);
}
}
//创建局部内部类对象
Inner inner = new Inner();
inner.show2();
}
public static void main(String[] args) {
Outer outer = new Outer();
outer.show();
}
}
4.匿名内部类
- 没有类名的局部内部类（一切特征都与局部内部类相同）。
- 必须继承一个父类或者实现一个接口。
- 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
- 优点：减少代码量。
- 缺点：可读性较差。
package com.study.test3;
//接口
public interface Usb {
//服务
void service();
}
package com.study.test3;
public class UsbTest {
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();
// 使用匿名内部类优化(相当于创建了一个局部内部类)
Usb usb = new Usb() {
@Override
public void service() {
System.out.println("连接电脑成功，鼠标开始工作！");
}
};
usb.service();
}
}
Object类
-
超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
-
任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
-
Object类中所定义的方法，是所有对象都具备的方法。
-
Object类型可以存储任何对象。
- 作为参数，可接受任何对象。 - 作为返回值，可返回任何对象。
Object类常用方法
1.getClass()方法
public final Class<?> getClass(){}
- 返回引用中存储的实际对象类型。
- 应用：通常用于判断两个引用中实际存储对象类型是否一致。
package com.study.test3;
public class Student {
private String name;
private int age;
public Student() {
}
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;
}
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和s2属于同一个类型！");
}else {
System.out.println("s1和s2不属于同一个类型！");
}
}
}
2.hashCode()方法
- public int hashCode(){}
- 返回该对象的哈希值
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来int类型的数值。
- 一般情况下相同对象返回相同哈希码。
//hashCode方法
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
Student s3 = s1;
System.out.println(s3.hashCode());
3.toString()方法
- public String toString(){}
- 返回该对象的字符串表示（表现形式）
- 可以根据程序需求覆盖该方法，如：展示对象各个属性值。
4.equals()方法
- public boolean equals(Object obj){}
- 默认实现为（this == obj),比较两个对象地址是否相同。
- 可进行覆盖，比较两个对象的内容是否相同。
- 比较两个引用是否指向同一个对象
- 判断obj是否null
- 判断两个引用指向的实际对象类型是否一致
- 强制类型转换
- 依次比较各个属性值是否相同
@Override
public boolean equals(Object obj) {
//1. 判断两个对象是否是同一个引用
if(obj == this){
return true;
}
//2. 判断obj是否为null
if(null == obj){
return false;
}
//3. 判断是否是同一个类型
// if(this.getClass() == obj.getClass()){
//
// }
// instanceof 判断对象是否是某种类型
if(obj instanceof Student){
// 4.强制类型转换
Student s = (Student) obj;
//比较属性
if(this.name.equals(s.getName()) && this.age == s.getAge()){
return true;
}
}
return false;
}
5.finalize()方法
- 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
- 垃圾对象：没有有效引用指向此对象时，为垃圾对象。
- 垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
- 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
- 手动回收机制：使用System.gc();通知JVM执行垃圾回收。
包装类
- 基本数据类型所对应的引用数据类型（通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。）。
| 基本数据类型 | 包装类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
装箱和拆箱的概念
在Java5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。
public class Demo {
public static void main(String[] args) {
//int num = 10;
//类型转换：装箱，基本数据类型转成引用数据类型的过程
//基本数据类型
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 = 30;
// 自动装箱
Integer integer4 = age;
System.out.println("自动装箱");
System.out.println(integer4);
// 自动拆箱
int age2 = integer4;
System.out.println("自动拆箱");
System.out.println(age2);
}
}
自动装箱池（整数缓冲区）
在Integer类的内部提供了自动装箱池技术，将-128到127之间的整数已经装箱完毕，当程序中使用该范围之间的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率。
public class Demo2 {
public static void main(String[] args) {
//面试题
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1 == integer2); //比较的是地址false
System.out.println("--------------------------------------");
Integer integer3 = Integer.valueOf(100);
Integer integer4 = Integer.valueOf(100);
System.out.println(integer3 == integer4); //true
System.out.println("-------------------------------------------");
Integer integer5 = Integer.valueOf(200);
Integer integer6 = Integer.valueOf(200);
System.out.println(integer5 == integer6); //false
}
}
基本数据类型和字符串之间的转换
//2.字符串转成基本数据类型
String str = "150";
//使用Integr.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);
String类
- 字符串是常量，创建后不可改变。
- 字符串字面值存储在字符串池中，可以共享。
- String s = “Hello”;产生一个对象，字符串池中存储。
- String s = new String(“hello”); //产生两个对象，堆、池各存储一个。
public class Demo3 {
public static void main(String[] args) {
String name = "hello"; //"hello" 常量存储在字符池中，
name = "zhangsan";//"zhangsan"赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟了一个新的数据区
String name2 = "zhangsan";
//演示字符串的另一种创建方式，new String();
String str = new String("java"); //开辟了两个空间一个在字符池中一个在堆中 浪费空间
String str2 = new String("java");
System.out.println(str == str2); //地址 false
System.out.println(str.equals(str2)); //数据内容 true
}
}
常用方法
- 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做拆分。
可变字符串
- StringBuffer: 可变长字符串， JDK1.0提供， 运行效率慢、线程安全。
- StringBuilder: 可变长字符串，JDK5.0提供，运行效率快、线程不安全。
package com.study.test3;
/**
* StringBuffer和StringBuilder的使用
* 和String区别（1）效率比String节省内存
*/
public class Demo4 {
public static void main(String[] args) {
StringBuffer s = new StringBuffer();
//1 append();追加
s.append("java世界第一");
System.out.println(s.toString()); //java世界第一
s.append("java真爱！");
System.out.println(s.toString()); //java世界第一java真爱！
//2. insert(); 添加
s.insert(0, "我在最前面！");
System.out.println(s.toString()); // 我在最前面！java世界第一java真爱！
//3. replace(); 替换顾前不顾尾
s.replace(0, 4, "hello");
System.out.println(s.toString()); // hello面！java世界第一java真爱！
//4. delete(); 删除
s.delete(0, 7);
System.out.println(s.toString()); // java世界第一java真爱！
System.out.println("--------------------------");
//清空
s.delete(0, s.length());
System.out.println(s.toString());
}
}
BigDecimal类
- 精确计算浮点数
Date类
- Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。
package com.study.test3;
import java.util.Date;
public class Demo5 {
public static void main(String[] args) {
//1. 创建Date对象
Date date1 = new Date();
System.out.println(date1.toString()); // Sun Jun 27 16:57:51 CST 2021
System.out.println(date1.toLocaleString()); // 2021-6-27 16:57:51
//昨天 毫秒数 60*60*24*1000
Date date2 = new Date(date1.getTime() - (60*60*24*1000));
System.out.println(date2.toLocaleString()); //2021-6-26 16:57:51
//2方法 after before
boolean b1 = date1.after(date2);
System.out.println(b1); // true
boolean b2 = date1.before(date2);
System.out.println(b2); // false
//比较compareTo();
int d = date1.compareTo(date2); // 1
System.out.println(d);
// 比较是否相等equals()
boolean b3 = date1.equals(date2);
System.out.println(b3);
}
}
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() | 毫秒为单位返回该日历的时间值 |
SimpleDateFormat类
- SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
- 进行格式化（日期 ——> 文本）、解析（文本——> 日期）。
- 常用的时间模式字母
| 字母 | 日期或时间 | 示例 |
|---|---|---|
| y | 年 | 2019 |
| M | 年中月份 | 08 |
| d | 月中天数 | 10 |
| H | 1天中小时数（0-23） | 22 |
| m | 分钟 | 16 |
| s | 秒 | 59 |
| S | 毫秒 | 367 |
package com.study.test3;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Format {
public static void main(String[] args) throws ParseException {
//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); // 2021/06/27
//解析 （把字符串转成日期）
Date date2 = sdf.parse("1999/05/01");
System.out.println(date2); //Sat May 01 00:00:00 CST 1999
}
}
System类
- System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。
| 方法名 | 说明 |
|---|---|
| static void arraycopy(…) | 复制数组 |
| static long currentTimeMillis(); | 获取当前系统时间，返回的是毫秒值 |
| static void gc(); | 建议JVM赶快启动垃圾回收器回收垃圾 |
| static void exit(int status); | 退回jvm，如果参数是0表示正常退出jvm,非0表示异常退出 |
package com.study.test3;
public class Demo6 {
public static void main(String[] args) {
// arraycopy: 数组的复制
// src: 源数组
// srcPos: 从那个位置开始复制0
//dest:目标数组
//destPos: 目标数组的位置
//length: 复制的长度
int[] arr = {20, 18, 15, 8, 35, 26, 45, 90};
int[] dest = new int[8];
System.arraycopy(arr, 0, dest, 0, arr.length);
for (int i = 0; i < dest.length; i++){
System.out.println(dest[i]);
}
System.out.println("-------------------------------------");
//Arrays.copyOf(original, newLength)
System.out.println(System.currentTimeMillis());
long start = System.currentTimeMillis();
for (int i = -999999; i < 999999; i++){
for (int j = -999999; j < 999999; j++){
int result = i + j;
}
}
// 2获取毫秒数
long end = System.currentTimeMillis();
System.out.println("用时：" +(end - start));
new Student("qqq", 19);
new Student("www", 19);
new Student("eee", 19);
//3回收垃圾
System.gc(); //告诉垃圾回收期回收
//4推出jvm
System.exit(0);
System.out.println("程序结束了.....");
}
}
总结
-
内部类:
在一个类的内部再定义一个完整的类。
成员内部类、静态内部类、局部内部类、匿名内部类。
-
Object 类：
所有类的直接或间接父类，可存储任何对象。
-
包装类：
基本数据类型所对应的引用数据类型，可以使Object统一所有数据。
-
String类：
字符串使常量，创建之后不可改变，字面值保存在字符串池中，可以共享。
-
BigDecimal:
可精确计算浮点数。
-
Date
特定时间
-
Calendar
日历
-
SimpleDateFormat
格式时间
-
System
系统类
4464
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
