一. 内部类
成员内部类、静态内部类、局部内部类、匿名内部类
内部类概念:在一个类的内部再定义一个完整的类
特点:
编译之后可生成独立的字节码文件
内部类可直接访问外部类私有成员,而不破坏封装
可为外部类提供必要的内部功能组件
// 身体
class Body{
// 头部
class Header{
// 也会生成class文件
}
}
1.成员内部类
1.在类的内部定义,与实例变量、实例方法同级别的类
2.外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象
3.当外部类、内部类存在重名属性时,会优先访问内部类属性
4.成员内部类里不能定义静态成员、可以包含静态常量(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();
}
}
2.静态内部类
不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员
// 外部类
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();
}
}
3.局部内部类
1.定义在外部类方法中,作用范围和创建对象范围仅限于当前方法
2.局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰为final
3.限制类的使用范围
// 外部类
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);
// 访问内部类的属性
sout(this.phone);
sout(this.email);
// 访问局部变量 jdk1.7要求必须常量final、jdk1.8自动添加final
}
}
// 创建局部内部类对象
Inner inner = new Inner();
inner.show2();
}
}
// 测试类
public class Test{
psvm(String[] args){
// 创建外部类对象
Outer outer = new Outer();
outer.show();
}
}
4.匿名内部类
1.没有类名的局部内部类(一切特征都与局部内部类相同)
2.必须继承一个父类或者实现一个接口
3.定义类、实现类、创建对象的语法合并,只能创建一个该类的对象
优点:减少代码量
缺点:可读性较差
二. Object类
1.超类、基类,所有类的直接或间接父类,位于继承树的最顶层
2.任何类,如没有书写extends显示继承某个类,都默认直接继承Object类,否则为间接继承
3.Object类中所定义的方法,是所有对象都具备的方法
4.Object类型可以存储任何对象
4.1.作为参数,可接受任何对象
4.2.作为返回值,可返回任何对象
1.getClass方法
public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用:通常用于判断两个引用中实际存储对象类型是否一致
// 判断s1 和 s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
// getClass返回 class类型
2.hashCode方法
public int hashCode(){}
返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值
一般情况下相同对象返回相同哈希码
s1.hashCode();
s2.hashCode();
// 自然不同
Student s3 = s1; // 此时s3的hashCode与s1相同
3.toSring方法
public String toSring(){}
返回该对象的字符串表示(表现形式)
可以根据程序需求覆盖该方法,如:展示对象各个属性值
sout(s1.toString()); // 直接打印包+类名+哈希值
// 重写 alt + enter + s
@override
public String toString(){
return "Student [name = " + name + ", age = " + age + "]";
}
4.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;
}
5.finalize
1.当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列
2.垃圾对象:没有有效引用指向此对象时,为垃圾对象
3.垃圾回收:由gc销毁垃圾对象,释放数据存储空间
4.自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象
5.手动回收机制:使用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对象被回收了”
}
三.包装类
基本数据类型所对应的引用数据类型
Object 可统一所有数据,包装类的默认值是null
基本数据类型 | 包装类型 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
1.8种包装类提供不用类型间的转换方式
Number父类中提供的6个共性方法
2. parseXXX( )静态方法
3. 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为进制要求
// 2. 字符串转成基本类型
String str = "150";
// 使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
// boolean 字符串形式转成基本类型,"true" ---> true 非“true ———> false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
}
2.自动装箱和拆箱
Java有自动装箱(autoboxing)和自动拆箱(autounboxing)功能。
自动装箱:基本类型的数据处于需要对象的环境中,会自动转为对象。装箱:转为对象类型。
自动拆箱:每当需要一个值的时候,对象会自动转成基本数据类型。拆箱:转为基本数据类型。
由于是自动的,所以在讲包装类中的上述代码不需要了,比如没有必要显式调用intValue()。这个功能是否实行是由编译器决定的。
Integer i = 100;//自动装箱
// 等价于下行的代码:
Integer i = Integer.valueOf(100);//调用的是valueOf(100),而不是new Integer(100)
Integer i = 100;
int j = i;//自动拆箱
// 等价于下行的代码:
int j = i.intValue();
注:包装类在自动装箱时为了提高效率,对于-128~127之间的值会进行缓存处理。超过范围后,对象之间不能再使用==进行数值的比较,而是使用equals方法。
// 【测试】超过-128-128范围,对象,不能再使用==进行数值的比较,而是使用equals方法
public class Test3 {
public static void main(String[] args) {
Integer in1 = -128;
Integer in2 = -128;
System.out.println(in1 == in2);//true 因为123在缓存范围内
System.out.println(in1.equals(in2));//true
Integer in3 = 1234;
Integer in4 = 1234;
System.out.println(in3 == in4);//false 因为1234不在缓存范围内
System.out.println(in3.equals(in4));//true
}
}
3.整数缓冲区
Java预先创建了256个常用的证书包装类型对象
在实际应用当中,对已创建的对象进行复用
psvm(String[] args){
// 面试题
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
// 因为缓存区数组 [-128, 127] 在这之内地址一样
}
四.String类
字符串是常量,创建之后不可改变
字符串字面值存储在字符串池中,可以共享
String s = "Hello";产生一个对象,字符串池中存储
String s = new String("Hello"); 产生两个对象,堆、池各一个
使用string类的一个注意事项:编译器在遇到字符串常量拼接的时候,进行了优化,会在编译期间就完成了字符串的拼接。
String类常用函数小概括:
// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串
String content = "java是最好的语言, java no1";
sout(content.length()); // 10
sout(content.charAt(content.length() - 1)); // 言
sout(content.contains("java")); // true
// 4. toCharArray(); 返回字符串对应数组
// 5. indexOf(); 返回子字符串首次出现的位置
// 6. lastIndexOf(); 返回字符串最后一次出现的位置
sout(content.toCharArray());
sout(content.indexOf"java")); // 0
sout(content.indexOf("java", 4)); // 从索引4开始找 返回12
sout(content.lastIndexOf("java")); // 12
// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str); 判断是否以str 结尾、开头
String ct = " hello world ";
sout(ct.trim()); // "hello world"
sout(ct.toUpperCase()); // HELLO WORLD
sout(ct.toLowerCase()); // hello world
sout(ct.endWith("world")); // true
sout(ct.startWith("hello")) // true
// 10. replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分
sout(content.replace("java", "php")); // php是最好的语言, php no1
String say = "java is the best language";
String[] arr = arr.say.split(" "); // "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
sout(arr.length); // 5
for(String string : arr){
sout(string);
}
// 打印出
//java
//is
//the
//best
//language
// 补充两个equals/compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
sout(s1.equalsIgnoreCase(s2));// 忽略大小写比较true
// compareTo(); 两字符不同时比较字符字典序的ascii码
// 字符相同时比较长度 返回差值
案例演示
需求:
已知String str = "this is a text";
将str中的单词单独获取
将str中的text替换成practice
在text前面插入一个easy
将每个单词的首字母改为大写
psvm(String[] args){
String str = "this is a text";
// 2.
String[] arr = str.split(" ");
for(String s : arr){
sout(s);
}
// 3.
String str2 = str.replace("text", "practice");
// 4.
String str3 = str.replace("text", "easy text");
// 5.
for(int i = 0; i < arr.length; i ++){
char first = arr[i].charAt(0);
char upperfirst = Character.toUpperCase(first);
String new = upperfirst + arr[i].substring(1);
}
}
可变字符串
1.StringBuffer : 可变长字符串,运行效率慢、线程安全
2.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填保留位数 后面为四舍五入之意
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类
1.Calendar提供了获取或设置各种日历字段的方法
2.构造方法 protected Calendar(); 由于是protected 所以无法直接创建
3.其他方法
方法名 | 说明 |
---|---|
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() | 毫秒为单位返回该日历的时间值 |
psvm(String[] args){
// 1. 创建 Calendar 对象
Calendar calendar = Calendar.getInstance();
sout(calendar.getTime().toLocaleString());
// 2. 获取时间信息
// 获取年
int year = calendar.get(Calendar.YEAR);
// 获取月 从 0 - 11
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类
1.SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
2.进行格式化(日期→文本)、解析(文本→日期)
3.常用的时间模式字母
字母 | 日期或时间 | 示例 |
---|---|---|
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)
}