Live2D

常用类

如何学习本小节?

根据步骤查找API文档使用对应功能:

  1. 查找类

  2. 查看模块名

  3. 查看包名

  4. 查看构造方法

  5. 找到符合需要的方法

  6. 根据构造方法创建对象并使用

代码知识:多练习

记住常用类、包、模块的作用记住常用类的常用方法(重点)


java常用工具--API

  1. java中组件的层次结构:

模块(module)-包(package)-类或接口(class/interface)

  1. 常用类在API文档里的java.base里找到

顶层父类:Object

构造方法:Object():构造一个对象,所要的子类对象初始化都会优先调用该方法。

成员方法:hashCode() getClass() toString() equals()

int hashCode() :返回对象的哈希码值,该方法通过对象的地址值进行计算,不同对象的返回值一般不同

Class<?> getClass() :返回调用此方法对象的运行时类对象(调用者的字节码文件对象)

String toString() :返回该对象的字符串表示

boolean equals():返回其它某个对象是否与此对象“相等”。默认情况下比较两个对象的引用,建议重写

public class Test {
   public static void main(String[] args) {
        //非静态方法的调用方式是 对象名.的形式。需要new一个对象
       //1.创建一个Object类型对象
       Object o1 = new Object();
       Object o2 = new Object();
       //2.测试Object类中的成员方法
       // int hashCode():返回对象的哈希码值,不同对象的哈希码值不同
        int obj1 = o1.hashCode();
       int obj2 = o2.hashCode();
       System.out.println(obj1);
       System.out.println(obj2);
       System.out.println("==========================");
       //Class<?> getClass() :返回调用者的字节码文件对象,一个类中只有一个字节码文件对象
       Class clazz1 = o1.getClass();
       Class clazz2 = o2.getClass();
       System.out.println(clazz1);
       System.out.println(clazz2);
       System.out.println("========================");
       // String   toString() :返回该对象的字符串表示,默认打印的是地址值,每个对象的地址值不同
       //         地址值组成:全类名+@+对象的哈希码的无符号十六进制表示组成
       String str1 = o1.toString();
       String str2 = o2.toString();
       System.out.println(str1);
       System.out.println(str2);
       System.out.println("=============================");
       // boolean equals():返回其它某个对象是否与此对象“相等”,默认的比较地址值,无意义,子类一般会重写这个方法。
       boolean b1 = o1.equals(o2);
       System.out.println(b1);
  }
}

JavaBean重写Object类的方法

需求∶开发中通常需要将对象转成字符串形式进行传输,也需要对即将使用的对象进行相等判断。定义标准

JavaBean类,重写toString和equals方法。

步骤:

  • 定义标准Java Bean类Student,属性:

id,name,score

  • 重写toString() :

该对象的字符串表现形式,一般都是包含所有属性值且具有一定的格式的字符串

  • 重写equals() :

可以通过关键属性( id)来确定该类的两个对象是否相同,可以比较所有属性值

  • 在测试类中创建Student对象并使用

//Student类
public class Student {
   //成员变量
   private int id;
   private String name;
   private int score;
   //构造方法
   public Student() {
  }

   public Student(int id, String name, int score) {
       this.id = id;
       this.name = name;
       this.score = score;
  }
   //成员方法
   public int getId() {
       return id;
  }

   public void setId(int id) {
       this.id = id;
  }

   public String getName() {
       return name;
  }

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

   public int getScore() {
       return score;
  }

   public void setScore(int score) {
       this.score = score;
  }
   //toString() 用来将对象转换成字符串形式(重写)

   @Override
   public String toString() {
       return "Student{" +
               "id=" + id +
               ", name='" + name + '\'' +
               ", score=" + score +
               '}';
  }

   //equal() 用来比较两个对象是否相等
   /*//自定义重写equals()方法
   //假设id属性值相同,两个就是同一个的对象
   public boolean equals(Object obj){//s1.equals(s2)
       //this 谁调用谁就是, s1
       //obj               s2
       //向下转型
       Student s2 = (Student)obj;
       return this.id==s2.id;//多态的弊端
   }*/
   //通过快捷键生成,记住步骤,理解

   @Override
   public boolean equals(Object o) {//s1.equals(s2)
       //this   s1
       //o     s2
       //比较两个对象的地址值是否相同,提高效率
       //补充:如果if语句控制的语句只有一行{}可以省略不写
       if (this == o)
           return true;
       //判断是比较两个对象是否是同一类型,提高程序健壮性
       if (o == null || getClass() != o.getClass())
           return false;
       //向下转型
       Student student = (Student) o;

       if (id != student.id)
           return false;
       if (score != student.score)
           return false;
       return name.equals(student.name);
  }

   @Override
   public int hashCode() {
       int result = id;
       result = 31 * result + name.hashCode();
       result = 31 * result + score;
       return result;
  }
}
//Test测试类
/*
定义标准Java Bean类
Student学生类
属性:
id(学号),name(姓名),score(成绩)
*/
public class Test {
   public static void main(String[] args) {
       //测试toString()方法
       //创建Student对象
       Student s1 = new Student(1,"小明",99);
       //直接输出语句打印对象默认调用了toString方法
       System.out.println(s1);
       System.out.println(s1.toString());
       //测试equals()方法
       Student s2 =new Student(1,"小明",99);
       boolean b1 = s1.equals(s2);
       System.out.println(b1);
  }

}

控制台录入:Scanner

在java.base--java.util---Scanner里

构造方法:Scanner(InputStream):构造一个扫描器对象,从指定输入流中获取数据参数System.in,对应键盘录入。

成员方法:

hasNextXxx() :

判断是否还有下一个输入项,其中Xxx可能是任意基本数据类型,返回结果为布尔类型

nextXxx() :

获取下一个输入项,其中Xxx可能是任意基本数据类型,返回对应类型的数据

String nextLine() :

获取下一行数据。以换行符作为分隔符。

String next()

获取下一个输入项,以空白字符作为分隔符空白字符:空格. tab、回车等

import java.util.Scanner;

public class Test {
   /*
注意:
在实际开发中,应用最多的方法是:
nextInt():接受整数
nextLine():接受字符串
  */
   public static void main(String[] args) {
      //创建Scanner对象(注意导包)
       //System.in标准的输入流,默认指向键盘
       Scanner sc = new Scanner(System.in);
       /*System.out.println("请输入一个整数:");
       //接受整数
       //判断输入的是否为整数
       if (sc.hasNextInt()){
           int num = sc.nextInt();
           System.out.println("输入的整数是:"+num);
       }*/
        //接受字符串类型的
       System.out.println("请输入一个字符串:");
//       String num = sc.next();//结束标志是空白字符(空格,tab,换行符)
       String num = sc.nextLine();//结束标志:换行符
       System.out.println("num:"+num);
       sc.close();
  }

}

字符串处理:String

在java.base--java.lang---String里

构造方法:String(byte[]) :构造一个String对象,将指定字节数组中的数据转化成字符串

String(char[]) :构造一个String对象,将指定字符数组中的数据转化成字符串

String类:判断的方法

成员方法:

boolean equals(String) :判断当前字符串与给定字符串是否相同,区分大小写

boolean equalsIgnoreCase(String) :判断当前字符串与给定字符串是否相同,不区分大小写

boolean startsWith(String) :判断是否以给定字符串开头

boolean isEmpty():判断字符串是否为空


public class Test {
   public static void main(String[] args) {
       //测试构造方法
       //1.String(byte[]) :将指定字节数组中的数据转化成字符串
       byte[] byt={98,99,100};
       String st1 = new String(byt);
       System.out.println(st1);
       //String(char[]) :将指定字符数组中的数据转化成字符串
       char[] ch = {'a','b','c'};
       String str2 = new String(ch);
       System.out.println(str2);
       //在实际开发中,String类非常常用,于是对String语法做了优化,省去了new
       //String s1= "abc";
       System.out.println("==============================");
       //测试 成员方法
      //boolean equals(String) :判断当前字符串与给定字符串是否相同,区分大小写
       String s2 = "abc";
       String s3 = "ABC";
       boolean b1 = s2.equals(s3);
       System.out.println("equals():"+b1);
       //boolean equalsIgnoreCase(String) :判断当前字符串与给定字符串是否相同,不区分大小写
  boolean b2 = s2.equalsIgnoreCase(s3);
       System.out.println("equalsIgnoreCase():"+b2);
       //boolean startsWith(String) :判断是否以给定字符串开头
       //判断s2是否以a开头
       boolean b3 = s2.startsWith("a");
       System.out.println("startsWith():"+b3);
       //boolean isEmpty():判断字符串是否为空
       //判断s2是否为空
       boolean b4 = s2.isEmpty();
       System.out.println("isEmpty():"+b4);
  }

}

String类:获取的方法

成员方法: int length() :获取当前字符串的长度

char charAt(int index) :获取指定索引位置的字符

int indexOf(String) :获取指定字符(串)第一次出现的索引

int lastIndexOf(String) :获取指定字符(串)最后一次出现的索引String

substring(int) :获取指定索引位置(含)之后的字符串

String substring(int, int) :获取从索引start位置(含)起至索引end位置(不含)的字符串

/*成员方法:String类
       int length() :获取当前字符串的长度
       char charAt(int index) :获取指定索引位置的字符
       int indexOf(String) :获取指定字符(串)第一次出现的索引
       int lastIndexOf(String) :获取指定字符(串)最后一次出现的索引String
       substring(int) :获取指定索引位置(含)之后的字符串
       String substring(int, int) :获取从索引start位置(含)起至索引end位置(不含)的字符串*/
public class Test1 {
   public static void main(String[] args) {
     //创建String字符串
       String s1 = "Hello";
       //int length() :获取当前字符串的长度
       int a =s1.length();
       System.out.println("length():"+a);
       //char charAt(int index) :获取指定索引位置的字符
       //获取s1中索引位置为3的字符
       char ch = s1.charAt(3);
       System.out.println("charAt(3):"+ch);
       //int indexOf(String) :获取指定字符(串)第一次出现的索引
       int b = s1.indexOf('l');
       System.out.println("indexOf():"+b);
       //int lastIndexOf(String) :获取指定字符(串)最后一次出现的索引String
       int c = s1.lastIndexOf("l");
       System.out.println("lastIndexOf():"+c);
       //substring(int) :获取指定索引位置(含)之后的字符串
       String s2 = s1.substring(1);
       System.out.println("substring(1):"+s2);
       //String substring(int, int) :获取从索引start位置(含)起至索引end位置(不含)的字符串
   String s3 = s1.substring(1,3);
       System.out.println("substring(1,3)"+s3);
  }
}

String类:转换功能

成员方法: byte[] getBytes() :将字符串转换成字节数组

char[] toCharArray() :将字符串转换成字符数组

static String valueOf(..) :将指定类型数据转换成字符串

String replace(old, new) :将指定字符(串)替换成新的字符(串)

String[l split(String) :切割字符串,返回切割后的字符串数据,原字符串不变

String trim() :去掉字符串两端的空白字符

/*
byte[] getBytes() :将字符串转换成字节数组
char[] toCharArray() :将字符串转换成字符数组
static String valueOf(..) :将指定类型数据转换成字符串
String replace(old, new) :将指定字符(串)替换成新的字符(串)
String[l split(String) :切割字符串,返回切割后的字符串数据,原字符串不变
String trim() :去掉字符串两端的空白字符*/
public class Test2 {
   public static void main(String[] args) {
       //创建一个字符串
       String s1 = "abc";
       //byte[] getBytes() :将字符串转换成字节数组
       byte[] b1 = s1.getBytes();
       //遍历字节数组
       for (int i = 0; i <b1.length ; i++) {
           System.out.println(b1[i]);
      }
       System.out.println("----------------------");
       //char[] toCharArray() :将字符串转换成字符数组
       char[] ch = s1.toCharArray();
       for (int i = 0; i < ch.length; i++) {
           System.out.println(ch[i]);
      }
       System.out.println("--------------------");
       //static String valueOf(..) :将指定类型数据转换成字符串
       //整数123-->字符"123"
       String s2 = String.valueOf(123);
       System.out.println(s2+4);//1234
       //在实际开发中,上述代码以下面代码替代
       String s4 =""+123;
       System.out.println(s4+4);
       System.out.println("----------------------");
       //String replace(old, new) :将指定字符(串)替换成新的字符(串)
       String s5 = "abc abc abc";
       //'d'去替换s5中的‘b’,
       System.out.println(s5.replace('b','d'));
       System.out.println("======================");
       //String[l split(String) :切割字符串,返回切割后的字符串数据,原字符串不变
       //把字符串s5按空格切割
       String[] s6 = s5.split(" ");
       for (int i = 0; i < s6.length; i++) {
           System.out.println(s6[i]);
      }
       System.out.println("===================");
       //String trim() :去掉字符串两端的空白字符
       String s7 = " a b c ";
       System.out.println(s7.trim());
  }
}

字符串处理:StringBuilder和StringBuffer

在java.base--java.lang---StringBuilder和StringBuffer里

简介

可变字符序列,用于构造字符串对象。内部使用自动扩容的数组操作字符串数据。StringBuilder和StringBuffer使

用相同的API。

构造方法:

StringBuilder() :构造一个空的StringBuilder容器

StringBuilder(String) :构造一个StringBuilder容器,并添加指定字符串

成员方法:

StringBuilder append(...) :将任意数据添加到StringBuilder容器中

String toString() :将当前StringBuilder容器转成字符串

/*      构造方法:
       StringBuilder() :构造一个空的StringBuilder容器
       StringBuilder(String) :构造一个StringBuilder容器,并添加指定字符串
       成员方法:
       StringBuilder append(...) :将任意数据添加到StringBuilder容器中
       String toString() :将当前StringBuilder容器转成字符串*/
public class Test4 {
   public static void main(String[] args) {
       //测试构造方法
       //StringBuilder() :构造一个空的StringBuilder容器,测试空参构造
       StringBuilder sb = new StringBuilder();
       StringBuilder sb1= sb.append("abc");
       System.out.println(sb);
       System.out.println(sb1);
       System.out.println("----------------");
       //需求:将String类型字符串转化成StringBuilder类型的对象
       StringBuilder sb3 = new StringBuilder("abc");
       System.out.println(sb3);
       System.out.println("-------------------");
       //测试成员方法
       //需求将三个字符拼接成一个字符串 小马   是个 大帅哥!
       StringBuilder sb4 = new StringBuilder();
       sb4.append("小马");
       sb4.append("是个");
       sb4.append("大帅哥!");
       System.out.println(sb4);
       System.out.println("----------------");
       //将StringBuilder类型转化成字符串形式
       String s = sb4.toString();
       System.out.println(s);

  }
}

日期获取:Date和Calendar

在java.base--java.util---Date和Calendar里

简介:

日期和日历类,用于操作日期相关信息。

构造方法:

Date() :构造一个日期对象,当前系统时间,精确到毫秒

Date(long) :构造一个日期对象,时间为自“1970年1月1日00:00:00 GMT”起,至指定参数的毫秒数

成员方法:

long getTime() :将日期对象转换成对应时间的毫秒值

日历类:

static Calendar getInstance() :根据当前系统时区和语言环境获取日历对象

int get(int field) :返回给定日历字段的值

void set(int field, int value) :将给定的日历字段设置为指定的值

import java.util.Date;

/*
日期类:
构造方法:
Date() :构造一个日期对象,当前系统时间,精确到毫秒
Date(long) :构造一个日期对象,时间为自“1970年1月1日00:00:00 GMT”起,至指定参数的毫秒数
成员方法:
long getTime() :将日期对象转换成对应时间的毫秒值
*/
public class Test5 {
   public static void main(String[] args) {
       //测试Date类
       //测试空参构造,采用当前系统默认的时间
       Date d1 = new Date();
       System.out.println(d1);
       //获取当前操作系统的毫秒值
       long l1 = d1.getTime();
       System.out.println(l1);
       //Fri Jan 22 19:14:36 CST 2021-->1611314076072
       //创建一个指定的时间
       Date d2 = new Date(1611314076072L);
       System.out.println(d2);
  }
}
/*
日历类
成员方法:
static Calendar getInstance() :根据当前系统时区和语言环境获取日历对象
int get(int field) :返回给定日历字段的值
void set(int field, int value) :将给定的日历字段设置为指定的值
*/
public class Test6 {
   public static void main(String[] args) {
      //创建Calendar类型的对象
       Calendar c1 = Calendar.getInstance();
//       System.out.println(c1);
       //获取年月日的信息
//       int year= c1.get(Calendar.YEAR);
//       int month = c1.get(Calendar.MONTH);//Java中0-11数字表示月份,对应1-12月
//       int day = c1.get(Calendar.DATE);
//       System.out.println(year+"年"+(month+1)+"月"+day+"日");
       //设置指定时间

       c1.set(2022,4,1);
       //重新获取年月日的值
       int year= c1.get(Calendar.YEAR);
       int month = c1.get(Calendar.MONTH);//Java中0-11数字表示月份,对应1-12月
       int day = c1.get(Calendar.DATE);
       System.out.println(year+"年"+(month+1)+"月"+day+"日");

  }
}

基本类型的包装类

在java.base--java.lang---包装类

简介:

基本数据类型不是对象,所以Java针对基本类型提供了对应的包装类,以对象的形式来使用。

装箱:基本类型转包装类型(对象类型)

拆箱:包装类型(对象类型)转基本类型

成员方法:

static基本类型parseXxx(String) :将字符串类型的数据转换成对应的基本类型

 

基本类型 包装类型(可以理解引用类型)

byte Byte

short Short

int Integer

long Long

char Character

float Float

double Double

boolean Boolean

//成员方法:
//static 基本类型 parseXxx(String) :将字符串类型的数据转换成对应的基本类型
//注意:
//除了Character类以外,其他的7种包装类都有parseXXX()方法
//因为如果字符串想转换成char类型的数据,可以通过:String类中的方法toCharArray(), charAt();
public class Test {
   public static void main(String[] args) {

       //因为变量a是基本类型,不能通过对象名. 的形式调用
       //解决方案:将其转换成对应的包装类
       int a = 10;
       //装箱
       Integer i1 = new Integer(a);
       //拆箱
       int b = i1.intValue();
       System.out.println(i1);
       System.out.println(b);
       System.out.println("---------------------------");
       //JDK5新特性,自动拆装箱
       Integer i2 = 50;//装箱
       int c = i2;//拆箱
       //将字符串转换成对应的基本类型
       int d = Integer.parseInt("123");
       System.out.println(d);
       System.out.println("d + 10="+(d+10));//133
  }
}

 

posted @ 2021-01-22 23:15  MWTYING  阅读(112)  评论(0)    收藏  举报