Java入土---常用类

最新推荐文章于 2024-06-17 13:56:54 发布

喝茶谢谢

最新推荐文章于 2024-06-17 13:56:54 发布

阅读量425

点赞数

分类专栏： java入土文章标签： java

本文链接：https://blog.csdn.net/weixin_49571787/article/details/123961600

版权

java入土专栏收录该内容

16 篇文章 0 订阅

订阅专栏

常用类

内部类

成员内部类
静态内部类
局部内部类
匿名内部类

内部类是在类的内部再定义一个完整的类

编译后，生成独立的字节码文件
内部类可以直接访问外部类的私有成员，而不破坏封装性。
可为外部类提供必要的内部组件。

//外部类
public class Animal{
//内部类
    class Dog{

    }
}

成员内部类

在类的内部定义，与变量实例，实例方法同级别的类。
外部类的一个实例部分，创建内部类对象，必须先创建外部类对象。
当外部类跟内部类存在重名属性时，内部类方法会优先选择内部类属性，如果想访问外部类，要用Outer.this.name;
内部类当中不定义静态成员，但可以包含静态常量final.

public class Outer{
    private String name;
    class Inner{
        private String phone;
        public void show(){
            system.out.println(name);
            system.out.println(phone);
        }

    }
}


//调用
Outer outer = new Outer();
Inner inner = outer.new Inner();
//或者
Inner inner = new Outer().new Inner();
inner.show();

静态内部类

在内部类的基础上，加一个static关键字,级别与外部类相同。但是可以被外部类使用。
可以直接创建使用，不依赖于外部类对象。
访问外部类的成员变量的时候，要创建外部类对象才能使用，因为静态成员变量级别相当于外部类。
调用时要：外部类.内部类变量名 = new 内部类.外部类();

局部内部类

定义在外部类的方法中，仅限于方法中调用。
局部变量，类，不能加访问修饰符,同时不能含有static静态修饰符。
访问外部类要加外部类.this.变量；
局部内部类访问当前方法中的局部变量时，因无法保障变量生命周期与自身相同，变量必须修饰为final。

public class Outer{
    public void show(){
        String address = "山东";
        class Inner{
            private String phone;
            public void show2(){
                system.out.println(address)
            }
        }
        Inner inner = new Inner();
        inner.show2();
    }
}

匿名内部类

是一个没有类名的局部内部类（特征与局部内部类相同）
必须继承一个父类或者实现一个接口。
是定义类，实现类，创建对象的语法合并，只能创建一个该类对象

//匿名内部类相当于在Usb类中创建一个局部内部类。
Usb usb = new Usb(){
    public void service(){
        //方法实现
    }
}

object类

所有的类都直接或间接继承object类。

getClass()方法

返回实际对象类型，用于判断两个引用中实际储存对象类型是否一致。

判断两个对象是否是一个类型

hashCode()方法

返回对象的哈希码
哈希值是根据对象地址或者字符串或数字使用hash算法计算出来的int类型的数值。
相同对象返回相同的hash值。

s1与s2hash值不相等，s1与s3相等。

toString()方法

通过调用，将一个Java对象转化成字符串表示形式，建议所有子类重写toString方法。
简写的方法越简洁，易阅读。

equals()方法

是判断两个对象地址是否相等。
默认实现是（this == obj），比较两个地址是否相同。
可以进行覆盖，比较两个对象内容是否相同。

equals重写步骤

public boolean equals(Object obj){
    //判断两个对象是否是同一个引用
    if(tihs == obj){
        return true;
    }
    if(obj == null){
        return false;
    }
    //if(this.getClass() == obj.getClass())
    //instanceof判断对象是否是某种类型
    if(obj instanceof Student){
        //强制类型转换
        Student s = (Student)obj;
        //比较属性
        if(this.name.equals(s.gerName()) && this.age == s.getAge()){
            return true;
        }
        return false;
    }
}

finalize()方法

当对象被判定为垃圾对象时，由jvm自动调用，用于标记垃圾对象，进入垃圾回收队列。
手动回收：使用System.gc();通知jvm执行垃圾回收。

包装类

基本类型存储在栈空间。
基本数据类型所对应的引用数据类型。引用数据类型具有可调用的属性跟方法。
包装类的默认值是null。

包装类对应

这样可以将栈空间的数据存放到堆空间中。

类型转换与装箱与拆箱

装箱：将基本类型转化为引用类型
拆箱：将引用类型转化为基本类型

拆箱可以调用Number类的方法

byteValue()
doubleValue()
floatValue()
intValue()
longValue()
shortValue()

装箱通过包装类的构造类型来进行转换。

//装箱
int num1 = 13;
Integer integer = new Integer(num1);
//拆箱
int num2 = integer.intValue(); 

//jbk1.5之后支持自动装箱。
int age = 13;
Integer integer4 = age;
//自动拆箱
int age2 = integer4;

基本类型转化字符串

int n1;
String s = Integer.toString(n1);

字符串转化为基本类型

String str = "123";
int num = Integer.parseInt(str);

Boolean字符串转基本类型。
“true” -> true,非"true" -> false

String str = "true";
boolean b1 = Boolean.parseBoolean(str);

Integer缓冲区

Integer类型在堆空间内会有-128-127的缓存，在-128-127之内时，是直接从堆空间内调用，而超过127后，才会重新创建空间来存储值。

String类

字符串是常量，创建后不可改变
字符串值是存储在字符串池中，可以共享。


String name = "hello";//hello会存储在字符串池中
name = "zhangsan";//在字符串池中开辟新空间，name指向新的zhangsan。
String name2 = "zhangsan";//name2与name指向同一个字符串，地址相同。
//对象的方式创建。
String s = new String("zhangsan");//会在栈里创建name，堆里创建“zhangsan”，方法池里也创建“zhangsan”，堆中的zhangsan指向方法池中的对象。

常用方法

length(),获取字符串长度，空格也算一个字符。
charAt(int index),返回某个位置字符串
contains(String),判断是否含有某个子字符串。
toCharArray();返回字符串对应的数组
indexOf(String str);返回子字符串首次出现的位置
lastIndexOf(String str);返回字符串最后出现的位置
trim();去掉字符串前后的空格
toUpperCase();把小写转化成大写
toLowerCase();大写转化成小写
endWith(str);判断是否已str结尾
starWith(str);判断是否以str开头。
replace();用新的字符或字符串替换旧的字符或字符串
split();对字符串进行拆分
equals();对两个字符串进行比较，equalslsIgnoreCase()忽略大小写。
compareTo();比较大小

可变字符串

StringBuffer:可变长字符串，运行效率慢，线程不安全。
StringBuilder:可变长字符串，运行效率快，线程不安全。

方法：

append()追加
insert()添加
replace()替换
delete()删除
delete(0,sb.length())清空

StringBuilder sb = new StringBuilder();
sb.append("asdas");//z追加字符串
sb.insert(0,"我在组前面");//在指定位置添加字符串。
sb.replace(head,last,str);//把指定区域内的字符串替换
sb.delete(head,last);//指定位置的字符删除

与string的区别：

效率高，节省内存

System类

系统类，主要提供系统的属性和方法

System类无构造方法，只有定义成静态方法，直接用类名调用，system的属性和方法都是静态的

例如
system.out.println();
就是调用system当中的println方法

//src：原数组，srcpos：复制开始位置，dest:目标数组，destPos:目标数组位置，length:复制长度
System.arraycopy(src,srcPos,dest,destPost,length)

System.exit(0);  //强制退出程序
long a = System.currentTimeMillis();//返回一个毫秒值，是当前世界时与1970年1月1日午夜之间的差，可以用作计时器。

Date类

大部分方法已经被Calendar类所取代。
Date提供时间与日期的支持

Date d = new Date();//返回系统日期与时间
Date d1 = new Date(2020 - 1900,6-1,1);//获取指定时间
long s = d.getTime();//获取距离1970年毫秒数

Calendar类

Calendar类是一个被保护的类，无法通过new来创建对象。

Calendar calendar = Calendar.getInstance();//创建calendar对象
System.out.println(calendar.getTime());//打印时间

int year =calendar.get(Calendar.YEAR);//获取年
int month = calendar.get(Calendar.MONTH);//获取月，从0-11；
int day = 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);//秒
//修改时间
Calendar calendar2 = Calendar.getInstance();
calendar.set(Calendar.DAY_OF_MONTH,5);
//add方法修改时间
calendar2.add(Calendar.HOUR,1);//加一个小时；
//获取时间的最大值；
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH)//获取该月的最大天数。

DateFormat类

日期的格式化显示


Date date = new Date();//获取时间对象
DateFormat df1 = DateFormat.getDateInstance();// 获取工具类对象
String time1 = df1.format(date);//获取格式化字符串，time1返回一个集体的日期。

DateFormat df2 = DateFormat.getDateTimeInstance();
String time2 = df2.format(date);//返回一个详细的日期及时间

SimpleDateFormat类

提供了日期与字符串的转换


String day = "2020/04/03 22:32:31";
SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date d1 = df.parse(day)//将字符串转化为Date类型的日期

//日期转字符串
Date d2 = new Date();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd===HH:mm:ss");
String s = df.format(d2)//将日期转化为字符串

y是年
M是月
d是日
H是小时
m是分
s是秒

Math类

是一个是数学类

Math.abs(a),求绝对值
Math.sqrt(a),求平方根
Math.max(),求最大值
Math.min(),求最小值
Math.round(num,2),对浮点数进行四舍五入
Math.random(),获取0-1的随机数

Random类

提供对随机数的支持

//创建random对象
Random rand = new Random();
int r1 = rand.nextInt(100);//获得一个0-100的随机整数
double r2 = rand.nexDouble();//获得一个double类型的随机数
//可以用循环来获取好多
//有范围的1000-1100,只需在r1上加1000；

BigInteger类

表示大整数类，封装了大整数中常见的数学运算。
使用字符串来表示大整数。

BigInteger b1 = new BigInteger("6666666666");
BigInteger b2 = new BigInteger("6666666666");
b1.add(b2);//加法
b1.subtract(b2);//减法
b1.multiply(b2);//乘法
b1.divide(b2);//除法，结果是整数
b1.remainder(b2);//取余

BigDecimal类

对大的小数进行计算。


BigDecimal b1 = new BigDecimal("15.3");
BigDecimal b2 = new BigDecimal("3.0");
b1.add(b2);//加法
b1.subtract(b2);//减法
b1.multiply(b2);//乘法
b1.divide(b2,5,BigDecimal.ROUND_HALF_UP);//除法,保留五位小数

对象克隆

在类中使用Cloneable接口，实现克隆的方法

Timer定时器

需要与TimerTask类结合使用，定时执行任务。

//创建timer对象
Timer t1 = new Timer();//定义一个Timer对象，控制定时任务的执行方式
TimerTask task = new TimerTask(){//定义定义任务的内容
    public void run(){
        //定时执行的内容
    }
}；
t1.schedule(task,3000)//3000毫秒后执行，固定时间后执行
//===================================
t1.schedule(task,new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").prase(具体的时间，格式是上面定义的))//在具体的时间执行
//====================================
t1.schedule(task,3000)
//在固定的时间间隔重复执行
t1.schedule(task,2000,3000)//两秒后开始执行，每三秒执行一次

枚举类

使用enum来修饰类，变成枚举类

public enum SeasonEnum {
    SPRING("春天"),SUMMER("夏天"),FALL("秋天"),WINTER("冬天");
    
    private final String name;
    
    private SeasonEnum(String name)
    {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

单例模式

使用场景

要求生产唯一序列号
计数器
连接数据库的对象

步骤

定义一个属性，保存当前类的静态对象。
构造方法私有
创建一个静态get方法返回单例对象

喝茶谢谢

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java入土---常用类

常用类内部类成员内部类静态内部类局部内部类匿名内部类内部类是在类的内部再定义一个完整的类编译后，生成独立的字节码文件内部类可以直接访问外部类的私有成员，而不破坏封装性。可为外部类提供必要的内部组件。//外部类public class Animal{//内部类 class Dog{ }}成员内部类在类的内部定义，与变量实例，实例方法同级别的类。外部类的一个实例部分，创建内部类对象，必须先创建外部类对象。当外部类跟内部类存在重名属性时，内部类方法会
复制链接

扫一扫