内部类
成员内部类、静态内部类、局部内部类、匿名内部类
概念:在一个类的内部再定义一个完整的类
特点:
- 编译之后可生成独立的字节码文件
- 内部类可直接访问外部类私有成员,而不破坏封装
- 可为外部类提供必要的内部功能组件
//身体
public class Body {
private String name;
//头部
class Header{
//也会生成class文件 同时生成构造函数
//可以直接访问外部类私有成员
public void showName(){
System.out.println(name);
}
}
}
成员内部类
- 在类的内部定义,与实例变量、实例方法同级别的类
- 外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象
- 当外部类、内部类存在重名属性时,会优先访问内部类属性
- 成员内部类里不能定义静态成员、可以包含静态常量(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
System.out.println(Outer.this.name); // 张三
System.out.println(age);
//打印内部类中的属性
System.out.println(name); // 李四
System.out.println(address);
System.out.println(phone);
}
}
}
public class TestOuter {
public static void main(String[] args) {
// 创建外部类对象
Outer outer = new Outer();
// 创建内部类对象
Outer.Inner inner = outer.new Inner();
//一步到位
Outer.Inner inner1 = new Outer().new Inner();
inner1.show();
}
}
静态内部类
- 不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员
//外部类
public class Outer {
private String name = "张三";
private int age = 18;
//静态内部类,和外部类相同
static class Inner {
private String address = "上海";
private String phone = "110";
//静态成员
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);
}
}
//测试类
public class TestOuter {
public static void main(String[] args) {
//直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();
inner.show();
}
}
局部内部类
- 定义在外部类方法中,作用范围和创建对象范围仅限于当前方法
- 局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰为final
- 限制类的使用范围
//外部类
public class Outer {
private String name = "刘德华";
private int age = 20;
public void show() {
//定义局部变量
final String address = "深圳";
//局部内部类 注意:不可以添加任何访问修饰符
class Inner {
//局部内部类的属性
private String phone = "158";
private String email = "[email protected]";
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要求,变量必须是常量,jdk1.8 自动添加final
System.out.println(address);
}
}
//创建局部内部类对象
Inner inner = new Inner();
inner.show2();
}
}
public class TestOuter {
public static void main(String[] args) {
Outer outer = new Outer();
outer.show();
}
}
匿名内部类
- 没有类名的局部内部类(一切特征都与局部内部类相同)
- 必须继承一个父类或者实现一个接口
- 定义类、实现类、创建对象的语法合并,只能创建一个该类的对象
- 优点:减少代码量
- 缺点可读性较差
//接口
public interface USB {
//服务
void service();
}
public class Mouse implements USB{
@Override
public void service() {
System.out.println("连接电脑成功,鼠标开始工作");
}
}
public class TestUsb {
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();
}
匿名内部类
public class TestUsb {
//使用匿名内部类(相当于创建了一个局部内部类)
USB usb = new USB() {
@Override
public void service() {
System.out.println("连接电脑成功,风扇开始工作");
}
};
usb.service();
}
Object类
- 超类、基类,所有类的直接或间接父类,位于继承树的最顶层
- 任何类,如没有书写extends显示继承某个类,都默认直接继承Object类,否则为间接继承
- Object类中所定义的方法,是所有对象都具备的方法
- Object类型可以存储任何对象
- 作为参数,可接受任何对象
- 作为返回值,可返回任何对象
getClass 方法
public final Class<?> getClass(){}
- 返回引用中存储的实际对象类型
- 应用:通常用于判断两个引用中实际存储对象类型是否一致
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb", 30);
//判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2) {
System.out.println("s1和s2属于同一个类型");
} else {
System.out.println("s1和s2不属于同一个类型");
}
}
}
hashCode 方法
public int hashCode(){}
- 返回该对象的哈希码值
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值
- 一般情况下相同对象返回相同哈希码
//hashCode方法
Student s3=s1;
System.out.println(s1.hashCode());//356573597
System.out.println(s2.hashCode());//1735600054
System.out.println(s3.hashCode());//356573597
toString 方法
public String toSring(){}
- 返回该对象的字符串表示(表现形式)
- 可以根据程序需求覆盖该方法,如:展示对象各个属性值
//3. toString方法
System.out.println(s1.toString());//Demo07.Student@1540e19d
System.out.println(s2.toString());//Demo07.Student@677327b6
//原码
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
equals 方法
public boolean equals(Object obj){}
- 默认实现为(this == obj), 比较两个对象地址是否相同
- 可进行覆盖,比较两个对象的内容是否相同
//4. equals方法 判断两个对象是否相等
System.out.println(s1.equals(s2)); // false
Student s4 = new Student("小明", 17);
Student s5 = new Student("小明", 17);
System.out.println(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;
}
finalize 方法
- 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列
- 垃圾对象:没有有效引用指向此对象时,为垃圾对象
- 垃圾回收:由gc销毁垃圾对象,释放数据存储空间
- 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象
- 手动回收机制:使用**System.gc();**通知JVM执行垃圾回收
@Override
protected void finalize() throws Throwable{
sout(this.name + "对象被回收了");
}
//测试类
public class TestStudent2 {
public static void main(String[] args) {
Student s1 = new Student("aaa", 29); // 不是垃圾
Student s2 = new Student("bbb", 29); // 不是垃圾
Student s3 = new Student("ccc", 29); // 不是垃圾
Student s4 = new Student("ddd", 29); // 不是垃圾
Student s5 = new Student("eee", 29); // 不是垃圾
new Student("bbb", 30); // 是垃圾 会被回收
//回收垃圾
System.gc();
System.out.println("回收垃圾");
// 打印出 “回收垃圾
// bbb对象被回收了
}
}
包装类
- 基本数据类型所对应的引用数据类型
- Object 可统一所有数据,包装类的默认值是null
- 基本类型、局部变量存在栈空间,引用类型存放堆空间
基本数据类型 | 包装类型 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
类型转换与装箱、拆箱
-
8种包装类提供不用类型间的转换方式
-
Number父类中提供的6个共性方法
-
parseXXX( )
静态方法 -
valueOf( )
静态方法
-
-
-
注意:需保证类型兼容,否则抛出NumberFormatException异常
psvm(String[] args){
// 装箱, 基本类型 → 引用类型(对象) 栈->堆
// 基本类型
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;
// 基本类型和字符串之间转换
// 1. 基本类型转成字符串
int n1 = 100;
// 1.1 使用+号
String s1 = n1 + "";
// 1.2 使用Integer中的toString()方法
String s2 = Integer.toString(n1);
String s2 = Integer.toString(n1, x); // x为进制要求
String s3 = Integer.toBinaryString(n1);//转换成二进制
// 2. 字符串转成基本类型
String str = "150";
// 使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
// boolean 字符串形式转成基本类型,"true" ---> true 非“true ———> false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
}
整数缓冲区
- Java预先创建了256个常用的证书包装类型对象
- 在实际应用当中,对已创建的对象进行复用
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.valueOf(100);
Integer integer4 = 100;
System.out.println(integer3 == integer4);//true
Integer integer5 = 200;// 自动装箱
Integer integer6 = 200;
System.out.println(integer5==integer6);//false
//valueOf 方法
// 因为缓存区数组 [-128, 127] 在这之内地址一样
// 不在cache数组区间内 则 new Integer(i);
/*
public static Integer valueOf(int i) {
if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
return new Integer(i);
}
*/
}
String类
- 字符串是常量,创建之后不可改变
- 字符串字面值存储在字符串池中,可以共享
String s = "Hello";
产生一个对象,字符串池中存储String s = new String("Hello");
产生两个对象,堆、池各一个
public static void main(String[] args) {
//产生一个对象,字符串池中存储
String name = "hello";//"hello" 常量存储在字符串池中
//不可变性
name = "zhansgan"; // "张三"赋值给name,给字符串赋值是没有修改数据
//不是将字符串池中"hello"的值更改,而是重新在字符串池中开辟新的空间
System.out.println(name);
String name2 = "zhangsan";//指向原来字符串池中的"zhansgan"
//字符串字面值存储在字符串池中,可以共享
//演示字符串的另一种创建方式
// 产生两个对象,堆、池各一个
String str1 = new String("java");
String str2 = new String("java");
System.out.println(str1==str2);//false
}
常用方法
public class Demo11 {
public static void main(String[] args) {
// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串
String content = "java是最好的语言";
System.out.println(content.length());//10
System.out.println(content.charAt(1));//a
System.out.println(content.contains("java"));//true
// 4. toCharArray(); 返回字符串对应数组
// 5. indexOf(); 返回子字符串首次出现的位置
// 6. lastIndexOf(); 返回字符串最后一次出现的位置
char[] str = content.toCharArray();
System.out.println(str[1]);//a
System.out.println(content.toCharArray());//java是最好的语言
System.out.println(Arrays.toString(content.toCharArray()));//[j, a, v, a, 是, 最, 好, 的, 语, 言]
System.out.println(content.indexOf("ava"));//1
System.out.println(content.indexOf("ava", 4));//从索引4开始找 返回-1
System.out.println(content.lastIndexOf("java"));//0
// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str); 判断是否以str 结尾、开头
String ct = " hello world ";
System.out.println(ct.trim());//hello world
System.out.println(ct.toUpperCase());// HELLO WORLD
System.out.println(ct.toLowerCase());// hello world
System.out.println(ct.endsWith("world "));//true
System.out.println(ct.startsWith(" hello"));//true
// 10. replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分
System.out.println(ct.replace("hello", "fuck"));// fuck world
String say = "java is the best language";
String[] arr = say.split(" ");// "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
for (String s : arr) {
System.out.println(s);
}
/* 打印
java
is
the
best
language
*/
// 补充两个equals/compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2));//false
System.out.println(s1.equalsIgnoreCase(s2));// 忽略大小写比较true
// compareTo(); 两字符不同时比较字符字典序的ascii码
// 字符相同时比较长度 返回差值
String s3 = "abc";//97
String s4 = "xyzaa";//120
System.out.println(s3.compareTo(s4));//-23
String s5 = "abc";//97
String s6 = "abcxyz";//120
System.out.println(s5.compareTo(s6));//-3,比较长度
}
}
案例演示
需求:
- 已知String str = “this is a text”;
- 将str中的单词单独获取
- 将str中的text替换成practice
- 在text前面插入一个easy
- 将每个单词的首字母改为大写
public class Demo12 {
public static void main(String[] args) {
//1.将str中的单词单独获取
String str = "this is a text";
String[] arr = str.split(" ");
for (String s : arr) {
System.out.println(s);
}
//2.将str中的text替换成practice
String str2 = str.replace("text", "practice");
System.out.println(str2);//this is a practice
//3.在text前面插入一个easy
String str3 = str.replace("text", "easy text");
System.out.println(str3);//this is a easy text
//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); //substring 截取,开始脚标
System.out.print(news + " ");//This Is A Text
}
}
}
可变字符串
- StringBuffer : 可变长字符串,运行效率慢、线程安全
- StringBuilder : 可边长字符串、运行快、线程不安全
- 和String区别
- 效率比String高
- 比String节省内存
public static void main(String[] args) {
// StringBuffer 和 StringBuilder 用法一致
StringBuffer sb = new StringBuffer();
// 1. append(); 追加
sb.append("java");
System.out.println(sb.toString());//java
// 2. insert(); 添加、插入
sb.insert(0, "在第一个位置插入");
System.out.println(sb.toString());//在第一个位置插入java
// 3.replace(); 替换
sb.replace(0, 3, "hello"); // 左闭右开
System.out.println(sb.toString());//hello个位置插入java
// 4. delete(); 删除
sb.delete(0, 5); // 左闭右开
System.out.println(sb.toString());
// 5. 反转
sb.reverse();
System.out.println(sb.toString());
// 6. 清空
sb.delete(0, sb.length());
System.out.println(sb.toString());
}
时间效率分析
//开始时间
long start = System.currentTimeMillis();
String string = "";
for (int i = 0; i < 9999; i++) {
string += i+" ";
}
System.out.println(string);
long end = System.currentTimeMillis();
System.out.println("用时:"+(end-start));//用时:514
long start2 = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 9999; i++) {
sb.append(i);
}
System.out.println(sb.toString());
long end2 = System.currentTimeMillis();
System.out.println("用时:"+(end2-start2));//用时:2
BigDecimal类
- 位置
java.math
包中 - 作用 精确计算浮点数
- 创建方式
BigDecimal bd = new BigDecimal("1.0");
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1 - d2);//0.09999999999999998
//面试题
double result = (1.4 - 0.5) / 0.9;
System.out.println(result);//0.9999999999999999
//BigDecimal ,大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");//需要用字符串
BigDecimal bd2 = new BigDecimal("0.9");
// 减法
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1);//0.1
//加法
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);
//除不尽时 x填保留位数 后面为四舍五入之意
BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_EVEN);//3.33
System.out.println(r5);
}
Data类
- Date表示特定的瞬间,精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
- 时间单位:1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns
public static void main(String[] args) {
// 1 创建Date对象
//今天
Date date1 = new Date();
System.out.println(date1.toString());//Fri Jan 06 21:15:33 CST 2023
System.out.println(date1.toLocaleString());//2023-1-6 21:16:01
//昨天
Date date2 = new Date(date1.getTime()-1000*60*60*24);
System.out.println(date2.toLocaleString());//2023-1-5 21:17:08
// 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);
System.out.println(d); // 多的为1 少的为 -1
// 比较是否相等 equals()
boolean b3 = date1.equals(date2);
System.out.println(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();
System.out.println(calendar.getTime().toLocaleString());//2023-1-6 21:50:13
System.out.println(calendar.getTimeInMillis());//1673013029291
// 2. 获取时间信息
// 获取年
int year = calendar.get(Calendar.YEAR);//2023
// 获取月 从 0 - 11
int month = calendar.get(Calendar.MONTH);//0
// 日
int day = calendar.get(Calendar.DAY_OF_MONTH);//6
//小时
int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR_OF_DAY 24小时 HOUR 12小时
//分钟
int minute = calendar.get(Calendar.MINUTE);
//秒
int second = calendar.get(Calendar.SECOND);
//2023年01月6日 21:55:36
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());//2023-1-5 21:57:02
// 4. add修改时间
calendar2.add(Calendar.HOUR, 1); // x为正就加 负就减
System.out.println(calendar2.getTime().toLocaleString());//2023-1-5 22:57:40
// 5. 补充方法
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);// 月数最大天数 31
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);//1
}
SimpleDateFormat类
- SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
- 进行格式化(日期→文本)、解析(文本→日期)
- 常用的时间模式字母
字母 | 日期或时间 | 示例 |
---|---|---|
y | 年 | 2019 |
08 | 年中月份 | 08 |
d | 月中天数 | 10 |
H | 一天中小时(0-23) | 22 |
m | 分钟 | 16 |
s | 秒 | 59 |
S | 毫秒 | 356 |
public static void main(String[] args) {
// 1. 创建对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd");
// 2. 创建Date
Date date = new Date();
// 格式化date(日期→字符串)
String str = sdf.format(date);
System.out.println(str);//2023年01月06日 22:07:41
// 解析(字符串→时间)
Date date2 = null;
try {
date2 = sdf.parse("2001年2月24日 10:24:55");
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println(date2);//Sat Feb 24 10:24:55 CST 2001
}
System类
- 主要用于获取系统的属性数据和其他操作,构造方法私有的
方法名 | 说明 |
---|---|
static void arraycopy(…) | 复制数组 |
static long currentTimeMillis(); | 获取当前系统时间,返回毫秒值 |
static void gc(); | 建议jvm赶快启动垃圾回收期器回收垃圾 |
static void exit(int status); | 退出jvm 如果参数是0表示正常退出jvm 非0表示异常退出 |
public static void main(String[] args) {
//1. arraycopy 数组的复制
//src-原数组 srcPos-从哪个位置开始复制0 dest-目标数组 destPos-目标数组的位置 length-复制的长度
int[] arr = {
20, 18, 15, 8, 35, 26, 45, 90};
int[] dest = new int[8];
//System.arraycopy(src, srcPos, dest, destPos, length);
System.arraycopy(arr, 0, dest, 0, arr.length - 1);
for (int i : dest) {
System.out.print(i + " ");
}
//20 18 15 8 35 26 45 0
// Arrays.copyOf(original, newLength)
System.out.println(System.currentTimeMillis());//1673014964891
//2. currentTimeMillis()
long start = System.currentTimeMillis();
for (int i = 0; i < 999999; i++) {
for (int j = 0; j < 999999; j++) {
int result = i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("用时:"+(end-start));//用时:10
//3. gc() 垃圾回收期器回收垃圾
System.gc();
//4. exit() 退出jvm 如果参数是0表示正常退出jvm 非0表示异常退出
System.exit(0);
System.out.println("---程序结束---");
}