十一.常用类

十一.常用类

1.抽象类

eg：public abstract class Animal04 {
        private int age;
        private String name;
        public abstract void eat();
        //getter,setter
}
概念：包含抽象方法的类。用abstract修饰
抽象方法：只有方法声明，没有方法体的方法，用abstract修饰
由来：当需要定义一个方法时，不明确方法的具体实现，可以将方法定义为abstract，具体实现延迟到子类
特点：
   (1)修饰符: 必须用abstract关键字修饰
              修饰符 abstract class 类名 {}, 修饰符 abstract 返回值类型 方法名 {}
   (2)抽象类不能被实例化，只能创建子类对象。(不能直接new)
   (3)抽象类子类的两个选择：
      重写父类所有抽象方法；定义成抽象类
   (4)成员特点：
      成员变量：可以有普通的成员变量；也可以有成员常量(final)
      成员方法:可以有普通方法，也可以有抽象方法。抽象类不一定有抽象方法，有抽象方法的类一定是抽象类(或接口)
      构造方法：一样有构造方法，也可以重载

2.Object类 (java.base-java.long-Object)

概念：类层次结构最顶层的基类，所有类都直接或间接的继承自Object类，即所有的类都是一个Object(对象)。
具体方法：
  1.构造方法
    Object():
      构造一个对象。所有子类对象初始化时都会优先调用该方法。
  2.成员方法：
    int hashCode():
      返回对象的哈希码值，该方法通过对象的地址值进行计算，不同对象的返回值一般不同。
    class<?> getClass():
      返回调用此方法对象的运行时类对象(调用者的字节码文件对象)。
    String toString():
      返回该对象的字符串表示(重写)。
    boolean equals():
      比较两个对象是否相等(默认情况下比较两个对象的引用即地址值，重写)

 /* Object类
 *   int hashCode():
 *   class<?> getClass():
 *   String toString():
 *   boolean equals():
 *   Java.long类下的包可以直接使用，不需要导包。
 */
public class test01 {
    public static void main(String[] args) {
        //非静态方法的调用：对象名. 的形式调用。
          //1.创建Object类的对象
        Object o1 = new Object();
        Object o2 = new Object();
          //2.测试Object类中的成员方法
            //2.1 int hashCode():
        int a1 = o1.hashCode();
        int a2 = o2.hashCode();
        System.out.println(a1);
        System.out.println(a2);
            //2.2 class<?> getClass():一个类只有一个字节码文件对象
        Class c1 = o1.getClass();
        Class c2 = o2.getClass();
        System.out.println(c1);
        System.out.println(c2);
            //2.3 String toString():默认打印地址值，不同对象的地址值不同。
            //  地址值的组成：全类名 + @ + 该对象的哈希码的无符号十六进制形式。
        String s1 = o1.toString();
        String s2 = o2.toString();
        System.out.println(s1);//java.lang.Object@1b6d3586
        System.out.println(s2);//java.lang.Object@4554617c
            //2.4 boolean equals():比较两个对象的地址值是否相等。子类会重写该方法
        boolean b1 = o1.equals(o2);
        System.out.println(b1);
    }
}

package Winter.object01;
import java.util.Objects;
/***
 * JavaBean重写Object类的方法
 * 在开发中通常需要将对象转成字符串形式进行传输，也需要对即将是有的对象进行相等判断。
 * 定义标准JavaBean类，重写toString和equals方法。
 * 1.定义标准JavaBean类
 *   1.1成员变量
 *   1.2构造方法
 *   1.3成员方法
 * 2.重写toString();
 * 3.重写equals();
 */
public class Student02 {
    //构造方法
    public Student02() {
    }
    public Student02(String id, String name, double score) {
        this.id = id;
        this.name = name;
        this.score = score;
    }
    //成员方法
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
    //成员变量
    private String id;
    private String name;
    private double score;
    //重写toString();用来将对象转为其对应的字符串形式
    @Override
    public String toString() {
        return "Student02{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
    //重写equals();用来比较两个对象是否相同
    @Override
    public boolean equals(Object o) {
        //比较地址值
        if (this == o)
            return true;
        //判断是否为同一个类型，提高程序的健壮性
        if (o == null || getClass() != o.getClass())
            return false;
        //向下转型
        Student02 student02 = (Student02) o;
        return Double.compare(student02.score, score) == 0 &&
                id.equals(student02.id) &&
                name.equals(student02.name);
    }
}

3.Scanner类 (java.base-java.util-Scanner)

概念：扫描器。能够解析字符串(String)和基本类型的数据。
构造方法：
  Scanner(InputStream):
    构造一个扫描器对象，从指定输入流中获取数据参数System.in，对应键盘录入。
  成员方法：
    hasNextXxx():
      判断是否还有下一个输入项，其中Xxx可能是任意基本数据类型，返回结果为boolean。
    nextXxx():
      获取下一个输入项，其中Xxx可能是任意基本数据类型，返回对应类型的数据。
    String nextLine():
      获取下一行数据。以换行符作为分隔符。
    String next():
      获取下一个输入项，以空白字符作为分隔符(空白字符：空格，tab，回车等)

package Winter.scanner01;
import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        //创建Scanner类的对象
        //System.in：标准的输入流，默认指向键盘
        Scanner s1 = new Scanner(System.in);
/*        //接收整数
        System.out.println("请输入一个整数：");
        //为了避免InputMismatchException，加入判断
        if (s1.hasNextInt()){
            int n1 = s1.nextInt();
            System.out.println(n1);
        }
        */
        //接收字符串类型的数据
        System.out.println("请入如一串字符：");
/*      String s2 = s1.nextLine();//结束标记是换行符
        System.out.println(s2);*/
        String s3 = s1.next();//结束标记是空白字符
        System.out.println(s3);
    }
}

4.String类 (java.base-java.long-String)

概念：字符串，每一个字符串对象都是常量。
构造方法：
  String(byte[]):
    构造一个String对象，将指定字节数组中的数据转化成字符串。
  String(char[]):
    构造一个String对象，将指定字节数组中的数据转化成字符串。
成员方法：
  boolean equals(String):
    判断当前字符串与给定字符串是否相同，区分大小写。
  boolean equalsIgnoreCase(String):
    判断当前字符串与给定字符串是否相同，不区分大小写。
  boolean startsWith(String):
    判断是否以给定字符串开头。
  boolean isEmpty():
    判断字符串是否为空。
1.获取功能：
  int length():
    获取当前字符串的长度。
  char charAt(int index):
    获取指定索引位置的字符。
  int indexOf(String):
    获取指定字符(串)第一次出现的索引。
  int lastIndexOf(String):
    获取指定字符(串)最后一次出现的索引。
  String substring(int):
    获取指定索引位置(含)之后的字符串。
  String substring(int,int):
    获取从索引start位置(含)起至索引end位置(不含)的字符串。
2.转换功能：
  byte[] getBytes():
    将字符串转换成字节数组。
  char[] toCharArray():
    将字符串转换成字符数组。
  static String valueOf(...):
    将指定类型的数据转换成字符串。
  String replace(old,new):
    将指定字符(串)替换成新的字符(串)。
  String[] split(String):
    切割字符串，返回切割后的字符串数据，原字符串不变。
  String trim():
    去掉字符串两端的空白字符。

package Winter.String01;
public class Test01 {
    public static void main(String[] args) {
        //测试构造方法
          //1.将指定的字节数组转换成字符串
        byte[] b1 = {97,98,99};
        String s1 = new String(b1);
        System.out.println(s1);
          //2.将指定的字符数组转换成字符串
        char[] c1 = {'h','e','l','l','o'};
        String s2 = new String(c1);
        System.out.println(s2);
        //优化写法
        String s3 = "abc";
        //测试成员方法
        /***
         *     boolean equals(String):
         *       判断当前字符串与给定字符串是否相同，区分大小写。
         *     boolean equalsIgnoreCase(String):
         *       判断当前字符串与给定字符串是否相同，不区分大小写。
         *     boolean startsWith(String):
         *       判断是否以给定字符串开头。
         *     boolean isEmpty():
         *       判断字符串是否为空。
         */
        String st1 = "aaa";
        String st2 = "AAA";
        boolean b01 = st1.equals(st2);
        System.out.println(b01);
        boolean b02 = st1.equalsIgnoreCase(st2);
        System.out.println(b02);
        boolean b03 = st2.startsWith("a");
        System.out.println(b03);
        String st3 = "";
        boolean b04 = st3.isEmpty();
        System.out.println(b04);
    }
}
//String类的获取功能
public class Test02 {
    public static void main(String[] args) {
        //定义一个字符串
        String s1 = "java cyl java";
        System.out.println(s1.length());
        System.out.println(s1.charAt(0));
        System.out.println(s1.indexOf('j'));
        System.out.println(s1.lastIndexOf('j'));
        System.out.println(s1.substring(12));
        System.out.println(s1.substring(5,8));
    }
}
//转换功能
public class Test03 {
    public static void main(String[] args) {
        //定义一个字符串
        String s1 = "abcdefg";
        //1.
        byte[] b1 = s1.getBytes();
        for (int i = 0; i < b1.length; i++) {
            System.out.print(b1[i]+" ");
        }
        System.out.println();
        //2.
        char[] c1 = s1.toCharArray();
        for (int i = 0; i < c1.length; i++) {
            System.out.print(c1[i]+" ");
        }
        //3.将1 2 3 转换成字符串
        System.out.println(String.valueOf(123)+1);
        String st1 = "" + 123;//实际开发，专业书写
        System.out.println(st1 + 1);//实际开发，专业书写
        String st2 = "123 123 123 123 123";
        //4.用字符4替换字符2；
        System.out.println(st2.replace('2','4'));
        //5.
        String[] st3 = st2.split(" ");
        for (int i = 0; i < st3.length; i++) {
            System.out.print(st3[i]+" ");
        }
        System.out.println();
        //6.
        String st4 = "  1  2  3  4  5  ";
        System.out.println(st4.trim());//用户输入密码时会调用
    }
}

5.StringBuilder类和StringBuffer类

一.StringBuilder类和StringBuffer类(java.base-java.long-StringBuilder/StringBuffer)
  概念：字符串缓冲区，是可变字符序列，用于构造字符串对象。内部使用自动扩容的数组操作字符串
       数据。两个类使用相同的API。
    在实际开发中，StringBuilder的效率较高。
  构造方法：
    StringBuilder():
      构造一个空的StringBuilder容器。
    StringBuilder(String):
      构造一个StringBuilder容器，并添加指定字符串。
  成员方法：
    StringBuilder append(...):
      将任意数据添加到StringBuilder容器中，并返回自身。
    String toString():
      将当前StringBuilder容器转换成字符串。

public class Test01 {
    public static void main(String[] args) {
        //测试构造方法
          //空参构造
            //将字符串数据转换成StringBuilder类型的对象
        StringBuilder s1 = new StringBuilder("123");
          //带参构造
        StringBuilder s2 = new StringBuilder("123");
        System.out.println(s2);
        //测试成员方法
          //将多个字符串拼接成新的字符串
        StringBuilder s3 = new StringBuilder();
        s3.append("610528");
        s3.append("2000");
        s3.append("0628");
        String s4 = s3.toString();
        System.out.println(s4);
    }
}

6.Date类

一.Date类(java.base-java.util-Date)
  概念：指日期和日历类，用于操作日期相关信息。
  构造方法：
    Date():
      构造一个日期对象，当前系统时间，精确到毫秒。(1秒 = 1000毫秒)
    Date(long):
      构造一个日期对象，时间为自某时刻起，至指定参数的毫秒数。
  成员方法：
    long getTime():
      将日期对象转换为对应的毫秒值。
二.Calender类(抽象类，java.base-java.util-Calendar)
  成员方法：
    static Calendar getInstance():
      根据当前系统的时区和语言环境获取日历对象。(通过类名.直接调用)
    int get(int field):
      返回给定日历字段的值。
    void set(int field, int value):
      将给定的日历字段设置为指定的值。

package Winter.date01;
import java.util.Date;
//测试date类
public class Test01 {
    public static void main(String[] args) {
        //测试空参构造
        Date d1 = new Date();//使用util包
        System.out.println(d1);
          //获取当前系统时间的毫秒值
        System.out.println(d1.getTime());

          //创建一个指定时间
        Date d2 = new Date(292929292929l);//传入long类型的值
        System.out.println(d2);
    }
}
//测试Calender类
public class Test02 {
    public static void main(String[] args) {
        Calendar c1 = Calendar.getInstance();//抽象类:类名.
        System.out.println(c1);//Java中表示月份是从0至11
        //获取年月日的信息
/*        int year = c1.get(Calendar.YEAR);
        int month = c1.get(Calendar.MONTH);
        int day = c1.get(Calendar.DATE);
        System.out.println(year+"年"+(month+1)+"月"+day+"日");*/
        //设置时间
        c1.set(2000,5,28);
        int year = c1.get(Calendar.YEAR);
        int month = c1.get(Calendar.MONTH);
        int day = c1.get(Calendar.DATE);
        System.out.println(year+"年"+(month+1)+"月"+day+"日");
    }
}

7.基本类型的包装类

一.基本类型的包装类(java.base-java.long-包装类)
  1.概述：基本数据类型不是对象，所以Java针对基本类型提供了对应的包装类，以对象形式来使用。
         int和char类型数据的包装类分别是Integer和Character，其余均是首字母大写。
         基本类型         包装类(引用类型)
         byte                Byte
         short               Short
         long                Long
         float               Float
         double              Double
         Boolean             Boolean
  2.装箱：eg：将基本类型转为包装类型(对象类型)
  3.拆箱：eg：将包装类型(对象类型)转为基本类型
  4.成员方法：
    static 基本类型 parseInt(String):
      将字符串类型的数据转换成对应的基本类型(int类型；通过类名.直接调用。)

package Winter.date01;
/***
 * 3.测试基本类型的包装类
 * 注意：除了Character类以外，其他7种包装类都有parseXxx()方法。
 *      字符串转char类型数据，可以通过：String类中
 *      toCharArray();和charAt();
 */
public class Test03 {
    public static void main(String[] args) {
        int a = 1;
        //装箱
          //将基本类型的数据转换成引用类型的数据
        Integer i = new Integer(1);
        //拆箱
        int b = i.intValue();
          //优化写法
        Integer i1 = 20;//自动装箱
        int b1 = i1;//自动拆箱
        System.out.println(i);
        System.out.println(b);
        //成员方法的调用
        int b2 = Integer.parseInt("1001");
        short s = Short.parseShort("111");
    }
}