java进阶基础知识点

m0_59058407

已于 2023-03-19 07:16:02 修改

阅读量86

点赞数

文章标签： java 学习 jvm

于 2023-03-18 19:40:17 首次发布

本文链接：https://blog.csdn.net/m0_59058407/article/details/129641590

版权

API

是什么?

简单理解就是别人提前写好的程序(代码);我们只需要学习具体有哪些代码(类和方法),然后直接利用这些代码完成我们的需求即可;

API文档是什么

是专门针对API代码进行解释说明的一个使用参考手册;

Object类

是什么?

是所有类的超类;这里面写的所有方法,任意一个子类对象都可以调用;

toString()方法

Object为所有的孩子提供的一个专门用于转字符串的方法,如果子类不满意,可以重写!重写的时候可以利用快捷键直接生成!    alt + insert

equals()方法

Object为所有的孩子提供了一个专门比较两个对象是否"相等"的方法,比较的规则是"比较两个对象的地址值";如果子类不满意,可以重写!重写的时候可以利用快捷键直接生成!

具体实例

/*
    创建学生类
 */
public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    // 重写Object类的toSTring方法,就能让学生对象,转字符串的时候,按照我们自定义的规则展示
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        //1.比地址
        if (this == o) {
            return true;
        }
        //2.比类型
        if (!(o instanceof Student)) {
            return false;
        }
        //强制类型转换
        Student student = (Student) o;
        //3.比属性
        if (age != student.age) {
            return false;
        }
        return name != null ? name.equals(student.name) : student.name == null;
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        //创建两个学生类对象
        Student s1 = new Student("小明", 21);
        Student s2 = new Student("小李", 20);
        Student s3 = new Student("小李", 20);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

        System.out.println(s2 == s3);       //false
        System.out.println(s2.equals(s3));  // 重写后是true,重写前是false
    }
}

包装类型

是什么?

java专门针对8个基本数据类型,写的8个对应的包装类,对应关系分别是:
int ---> Integer;
char --> Character;
剩下的6个都是首字母大写;
byte--->Byte  short--->Short   long--->Long float--->Float double--->Double  boolean--->Boolean

有什么用

这些类中提供了一些方法,可以帮我们完成字符串和基本数据类型的相互转换,且包装类中也帮我们记录了这个类型的最大值和最小值;

自动装箱和自动拆箱

将包装类型的数据转基本数据类型的过程叫做拆箱,这个过程在jdk5之后就可以自动完成了,因此叫做自动拆箱;   包装--->基本
将基本数据类型转成包装类型的数据的过程叫做装箱,这个过程在jdk5之后就可以自动完成了,因此叫做自动装箱;  基本--->包装

字符串和基本数据类型的相互转换

通用套路,都是用包装类的静态方法,parseXxx  没有parseChar,如果要转字符,只能利用字符串的 charAt(索引)这个方法,根据索引,获取某个位置的字符;

/*
    练习包装类
 */
public class MyInt {
    public static void main(String[] args) {
        // 自动装箱
        Integer a = 11;
        // 自动拆箱,再装箱
        a+=3;
        System.out.println(a);
        // 自动拆箱
        int b = a;
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        // 与字符串的相互转换
        // 将b转成字符串类型
        String s = b+"";// 字符串14
        System.out.println(s + 1);// 141

        // 把s转成int类型, 通用套路,都是用包装类的静态方法,parseXxx  没有parseChar,如果要转字符,只能利用字符串的 charAt(索引)这个方法,根据索引,获取某个位置的字符
        int i = Integer.parseInt(s);// 整数14
        System.out.println(i + 1);// 15
        String s2 = "6.6";
        System.out.println(Double.parseDouble(s2) + 1.1);
    }
}

StringBuilder

是什么

是java编写的一个专门用于提升字符串拼接效率的类;

如何使用

需要利用构造方法创建对象,然后利用对象,调用方法即可完成具体的功能;

构造方法

1. StringBuilder()                  构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。 
2. StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。

成员方法

1.append(任意类型的数据)  将指定的任意数据追加到此字符序列;
2.reverse()             将此字符序列进行反转;
3.length()              返回长度(字符数);
4.String toString()     返回此序列中数据的字符串表示形式;

public class MyStringBuilder {
    public static void main(String[] args) {
        //使用空参数的构造方法创建sb对象
        StringBuilder sb = new StringBuilder();
        //拼接任意类型的数据
        sb.append(22);
        sb.append('a');
        sb.append(6.6);
        sb.append("你好");
        System.out.println(sb);
        //反转
        sb.reverse();
        System.out.println(sb);
        System.out.println(sb.length());
    }
}

运行结果:
	22a6.6你好
	好你6.6a22
	8

String和StringBuilder的相互转换

1. 当需要进行字符串拼接,反转的操作的时候,需要将String转成StringBuilder完成;
2. 当需要进行字符串内容的比较的时候,需要将StringBuilder转成String;

链式编程

链式编程,就是使用方法返回的对象继续调用方法,这就是链式编程!
前提:
方法必须返回对象!!!

public class MyStringBuilder2 {
    public static void main(String[] args) {
        // 使用append和reverse方法,返回的都是本身对象
        StringBuilder sb = new StringBuilder();
        StringBuilder s1 = sb.append("11");
        StringBuilder s2 = sb.append("22");
        System.out.println(sb == s1);
        System.out.println(s1 == s2);
        System.out.println(s2);
        // 链式编程,就是使用方法返回的对象继续调用方法,这就是链式编程!
        System.out.println(sb.append(33).reverse().append(66).toString());
    }
}

运行结果:
	true
	true
	1122
	33221166
        
/*
    需求:
        键盘输入一个字符串,请使用程序判断这个字符串是否是对称字符串!
 */
public class MyTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串:");
        String s = sc.next();
        // 1: 将s转成一个 STringBuilder对象, 利用带参数的构造方法可以完成将字符串转sb的过程
        StringBuilder sb = new StringBuilder(s);
        // 2: 利用sb对象的反转的方法,将老字符串的内容进行反转
        sb.reverse();
        // 3: 比较反转前和反转后的字符串内容是否一样即可,注意: 必须将sb转成String然后才能利用equals方法进行比较!!!
        if(s.equals(sb.toString())){
            System.out.println(s+"是一个对称字符串");
        }else {
            System.out.println(s+"不是一个对称字符串");
        }
    }
}

System类

是什么

是java提前写好的一个专门表示系统的工具类;里面都是静态方法,可以直接使用类名调用;

有什么作用

System.currentTimeMillis()     可以获取当前系统时间的毫秒值形式;
可以用于测试程序的性能;(在代码执行之前获取一个时间节点,代码执行之后,再获取一个时间节点,使用两个时间节点的差就是程序运行时间)

public class MySys {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());
        System.out.println(System.currentTimeMillis());
        System.out.println(System.currentTimeMillis());
        System.out.println(System.currentTimeMillis());
        System.out.println(System.currentTimeMillis());
    }
}

Data

是什么

是java编写的用于描述时间瞬间的类;任意一个Date类型的对象,都是一个时间瞬间对象;
利用带毫秒值的构造方法或空参数的构造方法可以直接创建对象;

常用方法

1. getTime()   获取当前时间对象对应的毫秒值;
2. toLocaleString()  转本地日期格式字符串;

/*
    练习日期对象(JDK7)
 */
public class MyDate {
    public static void main(String[] args) {
        // 1: 获取当前时间对象
        Date d = new Date();
        System.out.println(d);
        // 2: 直接将日期对象转成本地格式的字符串
        String s = d.toLocaleString();
        System.out.println(s);
        // 3: 获取时间对象对应的毫秒值
        System.out.println(d.getTime());
        System.out.println(System.currentTimeMillis());
        // 4: 获取时间原点对象
        Date d2 = new Date(0);
        System.out.println(d2.toLocaleString()); 
    }
}

SimpleDateFormat类

是什么

是一个专门负责将字符串和Date类型的对象进行相互转换的工具类,且该工具类创建对象的时候,需要指定一个格式,如果不指定,将按照默认格式进行转换;

如何指定具体的格式呢

y  ----> 年份信息,写1个和写4个效果一样,但是如果写两个,就仅显示年份的后两位;
M  ----> 月份信息,写1个按实际月份显示;如果写两个,就强制显示两位,如果不够两位,自动在前面补0;
d  ----> 一月中的第几天,写1个按实际信息显示;如果写两个,就强制显示两位,如果不够两位,自动在前面补0;
H  ----> 24小时计时法的方式显示小时;写1个按实际信息显示;如果写两个,就强制显示两位,如果不够两位,自动在前面补0;
m  ----> 分钟;写1个按实际信息显示;如果写两个,就强制显示两位,如果不够两位,自动在前面补0;
s  ----> 秒钟;写1个按实际信息显示;如果写两个,就强制显示两位,如果不够两位,自动在前面补0;
E  ----> 星期
    
    常见的组合:
yyyy-MM-dd HH:mm:ss

如何创建工具对象

SimpleDateFormat(String pattern) 用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。

常用方法

格式化(format)
	从日期到字符串,这个过程称为格式化;对应的方法是:  format(日期对象)
解析(parse)
	从字符串到日期对象,这个过程称为解析;对应的方法是: parse(字符串);

public class MySDF {
    public static void main(String[] args) throws ParseException {
        //创建一个日期格式化的工具对象
        SimpleDateFormat sdf = new SimpleDateFormat("y年M月d日 HH点mm分ss秒 E");
        //获取当前时间对象
        Date d = new Date();
        //格式化成字符串
        String s = sdf.format(d);
        System.out.println(s);
        //创建第二个格式化工具类对象
//        SimpleDateFormat sdf2 = new SimpleDateFormat("y年M月d日 HH点mm分ss秒 E");
        //将一个字符串转换成日期对象
        Date parse = sdf.parse(s);
        System.out.println(parse);
    }
  
运行结果:
      2023年3月18日 19点24分08秒 周六
	  Sat Mar 18 19:24:08 CST 2023

简单练习

/*
    判断小贾和小皮是否成功的参与了秒杀活动
 */
public class Test02 {
    public static void main(String[] args) throws ParseException {
        // 1: 定义4个字符串时间,分别表示小贾,小皮,活动开始和结束时间
        String jia = "2023-01-01 00:02:00";
        String pi = "2023-01-01 00:13:00";
        String start = "2023-01-01 00:00:00";
        String end = "2023-01-01 00:10:00";
        // 2: 解析成4个日期对象,并分别获取对应的毫秒值
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        long jt = sdf.parse(jia).getTime();
        long pt = sdf.parse(pi).getTime();
        long st = sdf.parse(start).getTime();
        long et = sdf.parse(end).getTime();
        // 3: 判断
        System.out.println(jt>=st&&jt<=et?"小贾参与秒杀成功!":"小贾参与秒杀失败!");
        System.out.println(pt>=st&&pt<=et?"小皮参与秒杀成功!":"小皮参与秒杀失败!");
    }
}

JDK8新增的日期类

为什么要新增日期类

因为JDK7以前表示日期时间没有问题,但是对日期时间进行"推移"运算的时候,很不方便,所以新增了JDK8的日期对象,专门解决了这一类的需求,且将日期的精度进一步提升到纳秒级别了;
新增的日期类有:
	LocalTime  仅包含时分秒,不包含年月日的信息;
	LocalDate 仅包含年月日,不包含时分秒的信息;
	LocalDateTime  既包含年月日又包含时分秒信息;
	上面三个类的使用方式一模一样,仅仅是包含的信息不同而已!
如何使用
	所有的对象的获取都直接使用静态方法!!!

常用方法

static LocalDateTime now() 	从默认时区中的系统时钟获取当前日期时间。   
static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute) 以指定的年月日时分创建日期对象
getxxx()  获取对应的信息,可以获取年,月,日,小时,分钟...
withXxx(数据)  修改信息;
plusXxx(数据)  推移时间;

案例代码

/*
    练习JDK8的日期对象
 */
public class MyLocal {
    public static void main(String[] args) {
        // 1: 获取当前时间对象
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        // 2: 以出生日期为对象
        LocalDateTime of = LocalDateTime.of(2000, 11, 11, 11, 11);
        System.out.println(of);

        // 3: 修改日期对象,会得到一个新的日期对象,必须通过新的日期对象,才能看到修改后的效果,老对象 of不变
        LocalDateTime of2 = of.withYear(1998);
        System.out.println(of);
        System.out.println(of2);

        // 4: 出生后的7天是哪一天
        LocalDateTime of3 = of2.plusDays(7);
        System.out.println(of3);

        // 5: 直接面向对象比大小
        System.out.println(of3.isAfter(of2));

        System.out.println(of3.getDayOfWeek());
       // System.out.println(value);
    }
}

DateTimeFormater类

是什么

是一个专门为JDK8的日期提供格式化和解析的工具类;

获取方式

static DateTimeFormatter ofPattern(String pattern) 使用指定的模式创建格式化程序。

常见方法

解析是静态方法,可以直接使用日期类调用,传递要解析的字符串和格式化工具对象即可;
static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter)  
格式化是成员方法,直接使用日期对象调用这个方法,传递一个格式化工具对象,即可得到一个字符串;
String format(DateTimeFormatter formatter)

/*
    JDK8的日期格式化工具对象
 */
public class MyFormater {
    public static void main(String[] args) {
        // 1: 获取一个仅包含年月日的日期对象
        LocalDate now = LocalDate.now();
        // 获取一个格式化工具对象
        DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
        // 面向日期对象,调用format方法,传递格式化工具
        String s = now.format(format);
        System.out.println(s);
        // 解析的时候,直接利用日期类的静态方法即可
        LocalDate d = LocalDate.parse("1998年02月03日", format);
        System.out.println(d);
    }
}

Period类

是java在JDK8的时候,专门针对日期间隔编写的一个类;(粗粒度的时间段对象,只能精确到天)

有什么用

直接利用静态方法 between传递两个 LocalDate对象即可获取一个日期间隔对象;
static Period between(LocalDate startDateInclusive, LocalDate endDateExclusive)

常用方法

getxxx方法获取信息;

/*
    练习粗粒度的时间间隔对象
 */
public class MyPeriod {
    public static void main(String[] args) {
        // 1: 获取两个仅包含年月日的日期对象
        LocalDate d1 = LocalDate.of(1998, 2, 3);
        LocalDate d2 = LocalDate.of(2001, 4, 13);
        // 2: 利用静态方法获取日期间隔对象
        Period p = Period.between(d1, d2);
        // 3: 面向对象,获取信息
        System.out.println(p.getYears());
        System.out.println(p.getMonths());
        System.out.println(p.getDays());
        System.out.println(p.toTotalMonths());
    }
}

Duration类

是什么

是一个细粒度的日期间隔对象,可以使用静态方法between传递两个带毫秒值的日期对象就可以获取日期间隔对象了;

常用方法

getxxx方法获取信息;
toDays(); 获取两个日期间隔的总天数

/*
    细粒度的间隔对象
 */
public class MyDur {
    public static void main(String[] args) {
        // 1: 获取带年月日时分秒的日期对象
        LocalDateTime t1 = LocalDateTime.of(1988,11,11,11,11,11);
        LocalDateTime now = LocalDateTime.now();
        Duration d = Duration.between(t1, now);
        // get可以获取信息
        long l = d.toDays();
        System.out.println(l);
    }
}