当前位置 : 主页 > 编程语言 > 其它开发 >

Java入土---常用类

来源:互联网 收集:自由互联 发布时间:2022-05-30
常用类内部类 成员内部类 静态内部类 局部内部类 匿名内部类 内部类是在类的内部再定义一个完整的类 编译后,生成独立的字节码文件 内部类可以直接访问外部类的私有成员,而不破
常用类 内部类
  • 成员内部类
  • 静态内部类
  • 局部内部类
  • 匿名内部类

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

  1. 编译后,生成独立的字节码文件
  2. 内部类可以直接访问外部类的私有成员,而不破坏封装性。
  3. 可为外部类提供必要的内部组件。
//外部类
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;
    }
}
单例模式

使用场景

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

步骤

  1. 定义一个属性,保存当前类的静态对象。
  2. 构造方法私有
  3. 创建一个静态get方法返回单例对象
上一篇:那个自研ERP的公司现在怎么样了?
下一篇:没有了
网友评论