常用类
内部类
成员内部类、静态内部类、局部内部类、匿名内部类
概念：在一个类的内部再定义一个完整的类
特点：
- 编译之后可生成独立的字节码文件
- 内部类可直接访问外部类私有成员，而不破坏封装
- 可为外部类提供必要的内部功能组件
Outer$Inner.class Outer.class
// 身体
class Body{
// 头部
class Header{
// 也会生成class文件
}
}
- 在类的内部定义，与实例变量、实例方法同级别的类
- 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
- 当外部类、内部类存在重名属性时，会优先访问内部类属性
- 成员内部类里不能定义静态成员、可以包含静态常量(final)
成员内部类
// 外部类
public class Outer{
//实例变量
private String name = "张三";
private int age = 20;
//内部类
class Inner{
private String address = "北京";
private String phone = "110";
private String name = "李四";
//方法
public void show(){
//打印外部类属性 此时有重名属性name
sout(Outer.this.name); // 张三
sout(age);
//打印内部类中的属性
sout(name); // 李四
sout(address);
sout(phone);
}
}
}
// 测试类
public class Test{
psvm(String[] args){
// 创建外部类对象
Outer outer = new Outer();
// 创建内部类对象
Inner inner = outer.new Inner();
//一步到位
Inner inner = new Outer(.new Inner();
inner.show();
}
}
静态内部类
- 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
// 外部类
public class Outer{
//实例变量
private String name = "xxx";
private int age = 20;
// 静态内部类，和外部类相同
static class Inner{
private String address = "上海";
private String phone = "111";
// 静态成员
private static int count = 1000;
//方法
public void show(){
// 调用外部类的属性
// 1. 先创建外部类对象
Outer outer = new Outer();
// 2. 调用外部类对象的属性
sout(outer.name);
sout(outer.age);
// 调用静态内部类的属性和方法
sout(address);
sout(phone);
// 调用静态内部类的静态属性
sout(Inner.count);
}
}
}
// 测试类
public class Test{
psvm(String[] args){
// 直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();
inner.show();
}
}
局部内部类
- 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
- 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
- 限制类的使用范围
// 外部类
public class Outer{
//实例变量
private String name = "刘德华";
private int age = 35;
//方法
public void show(){
// 定义局部变量
String address = "sz";
// 局部内部类：注意不能加任何访问修饰符
class Inner{
private String phone = "11234";
private String email = "ldh@qq.com";
public void show2(){
// 访问外部类的属性
sout(name); // 相当于 Outer.this.name
sout(age);
// 访问内部类的属性
匿名内部类
-
没有类名的局部内部类（一切特征都与局部内部类相同）
-
必须继承一个父类或者实现一个接口
-
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
-
优点：减少代码量
-
缺点可读性较差
public static void main(String[] args) { //局部内部类 // class Fan implements Usb{ // @Override // public void service() { // System.out.println("风扇开始工作了"); // } // } // Usb usb=new Fan(); // usb.service(); //匿名内部类（相当于创建了一个局部内部类） Usb usb1 = new Usb() { @Override public void service() { System.out.println("风扇开始工作了。。。"); } }; usb1.service(); //上下两种方式本质相同 } }
$1为匿名内部类名字
Object类
- 超类、基类，所有类的直接或间接父类，位于继承树的最顶层
- 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
- Object类中所定义的方法，是所有对象都具备的方法
- Object类型可以存储任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象
getClass()方法
-
public final Class<?> getClass(){} -
返回引用中存储的实际对象类型
-
应用：通常用于判断两个引用中实际存储对象类型是否一致
Student s1 = new Student("张三", 18); Student s2 = new Student("李四", 22); Class s1Class = s1.getClass(); Class s2Class = s2.getClass(); //判断s1s2是否相等……
hashCode()方法
public int hashCode(){}- 返回该对象的哈希码值
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值
- 一般情况下相同对象返回相同哈希码
s1.hashCode();
s2.hashCode();
// 自然不同
Student s3 = s1; // 此时s3的hashCode与s1相同
需要注意两个对象hashCode相同时，equals不一定相同。
toString()方法
public String toSring(){}- 返回该对象的字符串表示（表现形式）
- 可以根据程序需求覆盖该方法，如：展示对象各个属性值
sout(s1.toString()); // 直接打印包+类名+哈希值
// 重写 alt + enter + s
@override
public String toString(){
return "Student [name = " + name + ", age = " + age + "]";
}
打印结果为：
包.类名.哈希值（十六进制形式）
equals()方法
public boolean equals(Object obj){}- 默认实现为(this == obj), 比较两个对象地址是否相同
- 可进行覆盖，比较两个对象的内容是否相同
///判断两个对象是否相等
sout(s1.equals(s2)); // false
Student s4 = new Strudent("小明", 17);
Student s5 = new Strudent("小明", 17);
sout(s4.equals(s5)); // false 堆中地址不同
// 重写 改变其比较内容
/*
步骤 1. 比较两个应用是否指向同一个对象
2. 判断obj是否为null
3. 判断两个引用只想的实际对象类型是否一致
4. 强制类型转换
5. 依次比较各个属性值是否相同
*/
@override
public boolean equals(Object obj){
// 1.
if(this == obj){
return true;
}
// 2.
if(obj == null){
return false;
}
// 3.
// if(this.getClass() == obj.getClass()){
//
// }
// instanceof 判断对象是否是某种类型
if(obj instanceof Student){
// 4.强制类型转换
Student s = (Student)obj;
// 5. 比较属性
if(this.name.equals(s.getName()) && this.age == s.getAge()){
return true;
}
}
return false;
}
fanalize()方法
- 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
- 垃圾对象：没有有效引用指向此对象时，为垃圾对象
- 垃圾回收：由gc销毁垃圾对象，释放数据存储空间
- 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
- 手动回收机制：使用
System.gc();通知JVM执行垃圾回收
@Override
protected void finalize() throws Throwable{
sout(this.name + "对象被回收了");
}
psvm(String[] args){
Student s1 = new Student("aaa", 29); // 不是垃圾
new Student("bbb", 30); // 是垃圾 会被回收
//回收垃圾
System.gc();
sout("回收垃圾");
// 打印出 “回收垃圾
// aaa对象被回收了”
}
包装类
基本数据类型所对应的引用数据类型。
| 基本数据类型 | 包装类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
Integer、Byte、Float、Double、Short、Long都属于Number类的子类，Numbe类本身提供了一系列的返回以上6中基本数据类型的操作。
Character和Boolean属于Object的直接子类。
类型转换与装箱、拆箱
- 8种包装类提供不用类型间的转换方式
- Number父类中提供的6个共性方法
-
parseXXX( )静态方法 -
valueOf( )静态方法
- 注意：需保证类型兼容，否则抛出NumberFormatException异常
//基本类型
int num1=100;
//封箱
Integer i2=new Integer(num1);
Integer i3=Integer.valueOf(num1);
//拆箱
int num4=i2.intValue();
//jdk1.5版本后提供自动封装，本质上还是valueOf和intValue
Integer i5=50;
int num6=i5;
//基本数据类型与字符串的转换
//使用+或Integer中的toString基本数据类型转化为字符串
int number1=15;
String str1=number1+"";
String str2=Integer.toString(number1);
String str3=Integer.toString(number1,16);//后面的数字为进制
Integer缓冲区
- Java预先创建了256个常用的证书包装类型对象
- 在实际应用当中，对已创建的对象进行复用
valueOf代码如上，其中low=-127，h=128，当传递的数在这个范围内时返回Integer缓冲区中的对象
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
sout(integer1 == integer2); // false
Integer integer3 = new Integer(100);// 自动装箱
// 相当于调用 Integer.valueOf(100);
Integer integer4 = new Integer(100);
sout(integer3 == integer4); // true
Integer integer5 = new Integer(200);// 自动装箱
Integer integer6 = new Integer(200);
sout(integer5 == integer6); // false
String类
- 字符串是常量，创建之后不可改变
- 字符串字面值存储在字符串池中，可以共享
-
String s = "Hello";产生一个对象，字符串池中存储 -
String s = new String("Hello");产生两个对象，堆、池各一个
// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串
String content="java是最好的编程语言，java";
System.out.println(content.length());//17
System.out.println(content.charAt(5));//最
System.out.println(content.contains("java"));//true
// 4. toCharArray(); 返回字符串对应数组
// 5. indexOf(); 返回子字符串首次出现的位置
// 6. lastIndexOf(); 返回字符串最后一次出现的位置
System.out.println(content.toCharArray());
System.out.println(content.indexOf("的"));//7
System.out.println(content.indexOf("java", 4));//表示从下标4开始找，结果13
System.out.println(content.lastIndexOf("java"));//13
// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str); 判断是否以str 结尾、开头
String str=" java 最好的编程语言 ";
System.out.println(str.trim());
System.out.println(str.toUpperCase());
System.out.println(content.startsWith("java"));//true
// 10. replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分
String say = "java is the best language";
String[] arr = say.split(" "); // "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
System.out.println((arr.length));//5
for(String string : arr){
System.out.println((string));
}
//打印出
//java
//is
//the
//best
//language
// 补充两个equals,compareTo()比较大小
String s1 = "hello";
String s2 = "HELLO";
System.out.println((s1.equalsIgnoreCase(s2)));//忽略大小写比较大小
// compareTo(); 两字符不同时比较字符字典序的ascii码
// 字符相同时比较长度 返回差值
String s3="helloworld";
String s4="all";
System.out.println(s1.compareTo(s3));//比较长度，输出-5
System.out.println(s1.compareTo(s4));//比较a和h的ascii码差值，输出7
System.out.println(s4.compareTo(s1));//输出-7
可变字符串
- StringBuffer : 可变长字符串，运行效率慢、线程安全（线程同步）
- StringBuilder : 可边长字符串、运行快、线程不安全（不保证线程同步）
效率都比String高且节省内存
psvm(String[] args){
// StringBuffer 和 StringBuilder 用法一致
StringBuffer sb = new StringBuffer();
// 1. append(); 追加
sb.append("java no1");
// 2. insert(); 添加、插入
sb.insert(0, "在第一个位置插入");
// 3.replace(); 替换
sb.replace(0, 9, str); // 左闭右开
// 4. delete(); 删除
sb.delete(0, 5); // 左闭右开
// 5. 清空
sb.delete(0, sb.length());
}
BigDecimal类
- 位置
java.math包中 - 作用 精确计算浮点数
- 创建方式
BigDecimal bd = new BigDecimal("1.0");
BigDecimal bd1 = new BigDecimal("1.0"); // 需用字符串
BigDecimal bd2 = new BigDecimal("0.9");
// 减法
BigDecimal r1 = bd1.subtract(bd2);
sout(r1); // 0.1
// 加法
BigDecimal r2 = bd1.add(bd2);
//乘法
BigDecimal r3 = bd1.multiply(bd2);
// 除法
BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"), x, BigDecimal.ROUND_HALF_UP);
//除不尽时 x填保留位数 后面为四舍五入之意
- 除法: divide (BigDecimal bd,int scal, RoundingMode mode)
- 参数scal :指定精确到小数点后几位。
- 参数mode :指定小数部分的取舍模式,通常采用四舍五入的模式，取值为BigDecimal.ROUND_HALF_UP。
日期类
Date类
Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
时间单位：1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns
psvm(String[] args){
// 1 创建Date对象
Date date1 = new Date();
sout(date1.toString()); //WED Sept 02 22:25:23 CST 2020
sout(date1.toLocaleString()); // 已过时 但也能用 2020-9-2
// 创建昨天的
Date date2 = new Date(date1.getTime() - (60*60*24*1000));
sout(date2.toLocaleString());
// 2 方法after before
boolean b1 = date.after(date2);
sout(b1); //true
boolean b2 = date1.before(date2);
sout(b2); //false
// 比较compareTo();
int d = date1.compareTo(date1);
sout(d); // 多的为1 少的为 -1
// 比较是否相等 equals()
boolean b3 = date1.equals(date2);
sout(b3); // false
}
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() | 毫秒为单位返回该日历的时间值 |
public static void main(String[] args) {
// 1. 创建 Calendar 对象
Calendar calendar = Calendar.getInstance();
sout(calendar.getTime().toLocaleString());//转换为Date对象打印时间
// 2. 获取时间信息
// 获取年
int year = calendar.get(Calendar.YEAR);
// 获取月 从 0 - 11，因此输出时月份要+1
int month = calendar.get(Calendar.MONTH);
// 日
int month = 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);
// 3. 修改时间
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH, x);
// 4. add修改时间
calendar2.add(Calendar.HOUR, x); // x为正就加 负就减
// 5. 补充方法
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);// 月数最大天数
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
}
SimpleDateFormat类
- SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
- 进行格式化（日期→文本）、解析（文本→日期）
- 常用的时间模式字母
| 字母 | 日期或时间 | 示例 |
|---|---|---|
| y | 年 | 2019 |
| 08 | 年中月份 | 08 |
| d | 月中天数 | 10 |
| H | 一天中小时（0-23） | 22 |
| m | 分钟 | 16 |
| s | 秒 | 59 |
| S | 毫秒 | 356 |
psvm(String[] args){
// 1. 创建对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");//表示用什么模式显示时间
// 2. 创建Date
Date date = new Date();
// 格式化date（日期→字符串）
String str = sdf.format(date);
sout(str);
// 解析（字符串→时间）
Date date2 = sdf.parse("1948/03/12");//需要抛出异常
sout(date2);
}
System类
主要用于获取系统的属性数据和其他操作，构造方法私有的
| 方法名 | 说明 |
|---|---|
| static void arraycopy(...) | 复制数组 |
| static long currentTimeMillis(); | 获取当前系统时间，返回毫秒值 |
| static void gc(); | 建议jvm赶快启动垃圾回收期器回收垃圾 |
| static void exit(int status); | 退出jvm 如果参数是0表示正常退出jvm 非0表示异常退出 |
psvm(String[] args){
//arraycopy 复制
//src-原数组 srcPos-从哪个位置开始复制0 dest-目标数组 destPos-目标数组的位置 length-复制的长度
int[] arr = {20, 18, 39, 3};
int[] dest = new int [4];
System.arraycopy(src, srcPos, dest, destPos, length);
sout(arr, 4, dest, 4, 4)
// Arrays.copyOf(original, newLength)
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
