文章目录
一、内部类
成员内部类、静态内部类、局部内部类、匿名内部类
1)成员内部类
概念:在一个类的内部再定义一个类
例如:
class Outward{
class Innner{
}
}
java文件经过编译后会生成字节码文件也就是 .class文件,上面的代码编译后会生成Outward.class文件
内部类编译之后也会生成 .class文件以外部类名$内部类名组成
上面的代码编译后会生成OutwardInner.class文件
如果想引用内部类对象需要先创建外部类对象
内部类依存于外部类 :
创建外部类对象
Outward outward= new Outward ();
创建内部类
Inner inner= Outward.new Inner();
通过外部类直接创建:
Outward outward = new Outward().new Inner();
需要注意当内部类与外部类属性重名时,内部类优先级更高
内部成员类不能定义静态成员,但可以包含静态常量:
class Outward {
class Inner{
private static final String name;
private static String name;//会报错
}
}
2).静态内部类
不依赖外部类对象,可以直接创建或通过类名访问
class Outward{
static class Innner{
//静态内部类可包含静态变量
private static String name;
}
}
//引用静态内部类对象
Outward.Innner Innner= new Outward.Innner();
只有内部类使用static修饰
3)局部内部类
定义在外部类方法中,作用范围仅限与当前方法
class Outward{
private String name = "小明";
public String show(){
//注意:局部内部类不能加任何修饰符
class Inner{
private int age = 18;
}
}
}
局部内部类的生命周期随着方法执行完毕而结束,访问外部类当前方法中的局部变量时,因无法保证变量的生命周期与自身相同,变量必须修饰为final
4)匿名内部类
没有类名的局部内部类
必须继承一个父类或实现一个接口
class Outward{
public String show(){
class Inner implements interface{
}
}
}
二.Object类
超类,基类,所有类的直接或间接父类,位于继承树的最顶层
任何类,如果没有书写extends显式继承某个类,都默认直接继承Object类,否则为间接继承
Object类所定义的所有方法,是所有对象都具备的方法
Object类型可以储存任何对象
作为参数,可以接收任何对象,作为返回值,可以返回任何对象
Object类的常用方法:
getClass()方法:
public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用:通常用来判断两个引用中实际存储对象类型是否一致
User user1 = new User("张三",18);
User user2 = new User("李四",20);
//判断user1和user2是否为同一个类型
Class class1 = user1.getClass();
Class class2 = user2.getClass();
if(class1 = class2){//进入if 输出为true
System.out.print("true");
}else{
System.out.print("false");
}
hashCode()方法:
Public int hashCode(){}
返回该对象的哈希码值
哈希码值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
一般情况下相同对象返回相同哈希码
User user1 = new User("张三",18);
User user2 = new User("李四",20);
User user3 = user1;
//返回false(地址不同)
System.out.print(user1.hashCode() == user2.hashCode());
//返回true
System.out.print(user1.hashCode() == user3.hashCode());
toString()方法
public String toString(){}
返回该对象的字符串表示(表现形式)
可以根据程序需求覆盖(重写)该方法,如:展示对象各个属性值
User user1 = new User("张三",18);
user1.toString();//返回全类名+哈希值
//重写toString()
public String toString(){
return "name="+name+"age="+age;
}
//在次调用会返回属性值
equals()方法
public boolean equals(Object obj){
(this == obj)
}
默认实现为(this == obj),比较两个对象地址是否相同
可进行覆盖,比较两个对象内容是否相等
User user1 = new User("张三",18);
User user2 = new User("李四",20);
user1.equals(user2);//返回false(地址不同)
重写equals()
@Override
public boolean equals(Object obj){
//1.判断两个对象是否同一个引用
if(this == obj){
return true;
}
//2.判断obj是否为空
if(obj == null){
return false;
}
//3.判断是否为同一类型
/**if(this.getClass() == obj.getClass()){
}*/
//instanceof 判断对象是否是某种类型
if(obj instanceof User){
//4.强制类型转换
User u = (User)obj;
//5.比较属性
if(this.name.equals(u.getName() && this.age==obj.getAge)){
return true;
}
}
}
finalize()方法
当对象为判定为垃圾对象时,由JVM自动调用此方法,用于标记垃圾对象,进入回收队列
java有垃圾回收机制,不需要程序员手动调用
垃圾回收机制:JVM内存耗尽,一次性回收所有垃圾对象
手动回收机制:使用System.gc();通知JVM执行垃圾回收
重写该方法便于观察:
@Override
protected void finalize() throws Throwzble{
System.out.println(this.name+"被回收");
}
User user1 = new User("张三",18);
User user2 = new User("李四",20);
user3 = new User("王五",18);
user4 = new User("赵六",20);
//回收垃圾
System.gc();
三.包装类
java提供了八大基础数据类型:byte short int long double flout boolean char,但是这些基础类型没有属性或方法,也就是说只能用来进行一些基本的逻辑判断
在需要进行复杂操作时就需要用到包装类,每个基本类型都对应一个引用类型:
基本类型 | 引用类型 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
Object 可统一所有数据,包装类的默认值是null
装箱与拆箱的概念:
基本类型转换为引用类型叫做装箱,引用类型转换为基本类型叫做拆箱
基本类型存放在栈中 引用类型存放在堆中 基本类型指向堆中的引用类型的引用
//装箱
int int1 = 66;
Integer integer1 = new Integer(int1);
Integer integer2 = Integer.valueOf(int1);
//拆箱
Integer integer3 = new Integer(66);
int num2 = integer3.intValue();
//jdk1.5之后,java提供了自动装箱拆箱
int a= 30;
// 自动装箱
Integer b= a;
// 自动拆箱
int c= b;
基本类型和字符串之间转换, .parseXXX()方法
//String类型转boolean,只有"true"会转为true其他任何字符串都会转为false
String str1 = "true";
String str2 = "joajoaijcnv";
if(Boolean.parseBoolean(str1)){
//输出true
System.out.print("true");
//输出false
System.out.print(Boolean.parseBoolean(str2));
}
// 基本类型转成字符串
int n1 = 100;
// 使用+号
String s1 = n1 + "";
// 2 使用Integer中的toString()方法
String s2 = Integer.toString(n1);
String s2 = Integer.toString(n1, x); // x为进制要求
// 字符串转成基本类型
String str = "150";
// 使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
// boolean 字符串形式转成基本类型,"true" ---> true 非“true ———> false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
思考题
psvm(String[] args){
// 面试题
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
sout(integer1 == integer2); // false 地址不同
Integer a = 100;
Integer b = 100;
sout(a == b); // true
//new Integer(100) 相当于调用构造 Integer.valueOf(100);
Integer integer3 = new Integer(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] 在这之内地址一样
}
Java预先创建了256个常用的整数包装类型对象
在实际应用当中,对已创建的对象进行复用
String
String是常量,创建后不可改变,字符串字面值储存在字符串池中,可以共享
程序在运行过程中有三块重要的空间:堆(存放对象),栈(基本类型数据),方法区(字符串)
//String的不可变性,当给创建的String类型再次赋值时,会在字符串池中开辟一块新的空间,指向另一个引用
String name = "张三";
name = "李四";
//String的共享,当创建String对象时,回到字符串池中寻找是否有相同的值,如果有就将新的对象指向这个引用
String name1 = "zhangsan";
String name2 = "zhangsan";
//不同的创建方式,开辟空间的方式也不一样
String s = "Hello";//产生一个对象,字符串池中存储 栈指向方法区的引用
String s = new String("Hello"); //产生两个对象,堆、池各一个 栈指向堆的引用
常用方法
// 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操作题
已知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);
}
}
可变字符串StringBuffer StringBuilder
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 类
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类中的大部分方法都已经被Calendar类中的方法所取代
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()
提供了获取或设置各种日历字段的方法
构造方法 protected Calendar(); 由于是protected 所以无法直接创建
Calendar类常用方法:
方法名 | 作用 |
---|---|
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
是一个以与语言环境有关的方式来格式化和解析日期的具体类
进行格式化(日期→文本)、解析(文本→日期)
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)
}
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)
}