JDK常用的类

String

//字符串的定义和初始化
String str1 = "abc";//不创建对象，常量池中的常量
String str2 = new String("abc");//创建一个实例对象
System.out.println(str1 == str2);//false
System.out.println(str1.equals(str2));//true

//字符串相关的方法
char c = str1.charAt(2);//返回指定下标的字符
System.out.println(c);

byte[] bytes = str1.getBytes();//获取字符串的字节
System.out.println(Arrays.toString(bytes));

String str3 = str1.toUpperCase(); //字符串转大写字母
str1.toLowerCase();//字符串转小写字母
System.out.println(str3);

str3 = str1.concat(str2);//拼接两个字符串
str3 = str1 + str2;//字符串拼接
System.out.println(str3);

/**
 * 字符串创建之后不能改变长度，所以字符串的拼接不会创建新对象，性能不高的
 *如果遇到大量的字符串拼接，换用StringBuffer(线程安全)或者StringBuilder（线程不安全）
 */
long start = System.currentTimeMillis();
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(str1);
stringBuffer.append(str2);
str3 = stringBuffer.toString();
long end = System.currentTimeMillis();
System.out.println(str3);
System.out.println(end - start);//用来调试程序执行的时间，单位为毫秒

StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(str1);
stringBuffer.append(str2);
str3 = stringBuilder.toString();
System.out.println(str3);

boolean b = str1.endsWith("bc");
//判断一个字符串是不是以某个字符串结尾
System.out.println(b);
boolean b1 = str1.startsWith("a");
//判断一个字符串是不是以某个字符串开头
System.out.println(b1);

boolean b2 = str1.contains("bc");//true
//判断一个字符串中是否包含一个字符串
System.out.println(b2);

str1 = "this is a string";

int i = str1.indexOf("string");
//返回指定字符串第一次出现的起始下标
System.out.println(i);//10
i = str1.indexOf("is");
System.out.println(i);//2
//第一个is下标是2

i = str1.lastIndexOf("is");
//返回指定字符串最后一次出现的起始下标
System.out.println(i);//5

i = str1.indexOf("is",3);
//从下标指定位置(3)开始，找第一次出现指定字符串下标
System.out.println(i);//5

i = str1.indexOf("was");
//如果没有找到指定字符串，返回-1
System.out.println(i);//-1


 // 数组的length是属性，字符串的length是方法
int length = str1.length();//字符串的长度（有多少个字符串）
System.out.println(length);//16

String substring = str1.substring(10);
//一个参数，从这个字符串开始，截取字符串结束
System.out.println(substring);
String subs = str1.substring(10,13);
//两个参数，截取从指定位置开始到指定位置结束的字符串
System.out.println(subs);

str2 = "             abc             ";
str3 = str2.trim();//去掉字符串的前后空格
System.out.println(str3 + "=");

str3 = str1.replace("is","was");
//替换字符串
System.out.println(str3);

String[] arr = str1.split(" ");
//按指定的符号拆分字符串为数组
System.out.println(Arrays.toString(arr));
arr = str2.split("");
//用空字符串做split，相当于返回字符串的字符数组
System.out.println(Arrays.toString(arr));

Math

• Math.random() 产生0到1的随机数（小数）
• Math.floor() 取小数的最大整数（向下取整）
• Math.ceil() 取小数的最小整数（向上取整）
• Math.round() 四舍五入取整

Date

• 日期对象Date

• 日期格式化对象SimpleDateFormat

  Date date = new Date();
  System.out.println(date);
  /*
  y     年，yyyy是四位的年份
  M     月份。跟后面的分钟区分，月的M是大写
  d     日
  H     大写的4表示24小时制的小时。小写的h表示12小时制的小时
  m     分钟
  s     秒
  日期(-)和时间(：)之间的连接符号可以随便定义
   */
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  String formate = sdf.format(date);
  System.out.println(formate);
  

抽象关键字abstract

抽象的作用是如果子类都会重写（不一样）的方法，定义为抽象方法，节省代码量

抽象类里面也可以有非抽象的方法，所有子类代码都一样的方法就在父类中定义，代码重用

abstract可用于修饰方法和类

• abstract用于修饰方法，该方法是抽象方法；如果用于修饰类，该类就是抽象类
• 一个类如果有抽象的方法，类必须要定义为抽象类
• 抽象类不能直接被实例化
• 如果继承抽象类，必须要重新（实现implements）父类中所有的抽象方法，否则这个类也只能定义成抽象类
• 抽象类中可以有非抽象类的方法
• 抽象类可以有构造方法，子类实例化时会调父类的构造方法
• 构造方法不能用abstract修饰
• 静态方法不能用abstract修饰

动物的抽象类，有一个抽象方法叫shout()

public abstract class Animal {

    public Animal(){
        System.out.println("Animal的构造方法");
    }

    public abstract void shout();

    public void breathe(){
        System.out.println("在呼吸");
    }
}

动物的子类Cat，重写父类的抽象方法

public class Cat extends Animal  {

    public void shout(){
        System.out.println("喵喵喵");
    }
}

抽象的面试题

• 抽象类中有构造方法吗？

  有抽象类的构造方法在子类中可以调用

• 执行构造方法的时候一定会创建出实例对象？

  不一定，子类创建对象时，如果默认构造方法，父类（不管是抽象类还是具体类）的默认构造方法也会被调用

接口interface

接口中的方法都是未实现的的方法，可以理解为全是抽象方法

接口一般定义规范（方法名，参数，返回类型），它的实现类必须按接口的方法的定义去实现方法

接口还用于框架或设计模式中，利用多态的特性，便于程序的拓展

接口可以实现多接口，弥补类的继承只能单继承的缺点

• 定义接口的语法：

[修饰符] interface 接口名{

}

• 接口实现语法：

[修饰符] [abstract] 类名implements 接口名{

}

接口的实现类可以是抽象类，如果是抽象类就不要求实现每一个方法；具体类就必须实现所有方法

Usb interface

public interface Usb {

    void init();//初始化usb接口
    void send();//发送数据
    void reject();//弹出usb设备
}

实现类Usb2

public class Usb2 implements Usb{


    @Override
    public void init() {
        System.out.println("USB2.0初始化");
    }

    @Override
    public void send() {
        System.out.println("USB2.0传输数据");
    }

    @Override
    public void reject() {
        System.out.println("USB2.0弹出设备");
    }
}

实现类Usb3

public class Usb3 implements Usb {
    @Override
    public void init() {
        System.out.println("USB3.0初始化");
    }

    @Override
    public void send() {
        System.out.println("USB3.0传输数据");
    }

    @Override
    public void reject() {
        System.out.println("USB3.0弹出设备");
    }
}

接口的特点

• 接口定义的关键字interface，接口实现的关键字是implemens

• 接口中的所有方法都只定义，不实现

• 接口的方法不写访问修饰符，默认是public

• 接口的属性默认是public static final的，相当于是常量

• 接口不能被实例化

• 接口没有构造方法

  public interface Usb {
      //接口的属性默认是oublic static final,接口中的属性就是常量
      //等效于pubtic static final String name "usb01";
      String name = "usb01";
  }