day13

方法重写

对于一个方法而言： 区分方法 通过方法名找方法 通过参数列表来确定方法

• 方法重写：

  ​ 发生继承关系、实现关系 父类不满足子类的需求 子类重写父类中的方法

什么情况下会发生：

1：发生继承

​ 2：方法名同名

​ 3：参数列表要一模一样 (顺序 个数 类型)

​ 4：子类的返回值类型<=父类的返回值类型(引用) 基本类型一模一样

​ 5：子类的修饰符>=父类的修饰符 (父类中的修饰符不能是private)

​ 6：子类抛出的异常<=父类抛出的异常 (理解：可以认为任意一个方法都会对外抛出运行时异常)

​ 参一反小修大异小

main()

1. public：保证能够调用到
2. static：保证外界调用无需创建对象
3. void: jvm无需返回值
4. String[] args： 可以传入 调用main方法时 可以传入实际参数

常用类

Scanner

学习使用Scanner

1. hasNextXXX 获取扫描到的数据是否是XXX类型
2. nextXXX 获取下一个扫描到的内容转为XXX类型(转换过程中有可能存在问题)

重新创建Scanner对象 指定文件作为输入源
Scanner sc = new Scanner(new File(“C:\Users\wawjy\Desktop\a.txt”));

String

String：

字符串： 一组字符序列 (不可变的串)

创建String对象：

1. new String();
2. new String(“abc”);
3. "love";
4. new String(buf,2,2);//通过字节数组创建

常见方法

public class Test02 {
public static void main(String[] args) {

// 创建一个String对象
String str = "ilovejavaandlaoxue";

//charAt(int index);
char ch = str.charAt(3);
System.out.println("返回当前索引位置上的指定字符："+ch);

//codePointAt(index)
int num = str.codePointAt(0);
System.out.println("返回指定索引位置上元素的代码点："+num);

//compareTo(String)
String cStr = "ilovejavaandlaoxu";
num = str.compareTo(cStr);
System.out.println("比较两个字符串的大小："+num);

//compareToIgronCase(String)
cStr = "ILOVEJAVAANDLAOXUE";
num = str.compareToIgnoreCase(cStr);
System.out.println("比较两个字符串的大小（忽略大小写）："+num);

//concat(String)
cStr = "andgirl";
str = str.concat(cStr);
System.out.println("拼接之后的结果是："+str);

//copyValueOf(char[])
char[] chs = new char[] {'i','l','o','v','e'};
str = String.copyValueOf(chs);
System.out.println("创建新的字符串："+str);

str = String.copyValueOf(chs,1,4);
System.out.println("创建新的字符串："+str);

str = "憨憨.avi";
boolean flag = str.endsWith(".avi");
System.out.println("str是否是.avi格式："+flag);

//getBytes
byte[] buf = str.getBytes();
System.out.println("获取字符串的字节数组："+Arrays.toString(buf));

//getChars();
chs = new char[10];
//  从str的2索引处开始  到str的第5个索引结束(不包含)  复制到chs字符数组中 从第1个位置开始
str.getChars(2,6, chs, 1);
System.out.println("获取字符串的字符数组："+Arrays.toString(chs));

//indexOf  返回负数代表未找到
str = "hehe.avi.png";
int index = str.indexOf(".");
System.out.println(".在string中第一次出现的位置是："+index);

index = str.indexOf(100);
System.out.println("e在string中第一次出现的位置是："+index);

index = str.indexOf(".",5);
System.out.println(".在string中第5个索引位置开始计算，第一次出现的位置是："+index);

index = str.lastIndexOf(".");
System.out.println(".在string中最后一次出现的位置是："+index);

//isEmpty()
System.out.println("查看数组是否为null:"+str.isEmpty());

//repleace
str = "hehe.avi.png";
str = str.replace(".", "+");
System.out.println("替换之后的结果："+str);

//splite:
str = "login?unme=zs&pwd=zs";

String[] strs = str.split("\\?");
for(String string:strs) {
System.out.println(string);
}
System.out.println("======");
String parms = strs[1];
strs = parms.split("&");
for(String string:strs) {
String[] ss = string.split("=");
System.out.println(ss[1]);
}

//subString
str = "login?unme=zs&pwd=zs";
str = str.substring(4);// 从4索引开始截取到结束
System.out.println("截取字符串："+str);

str = str.substring(2, 7);//从2索引开始截取 到索引为7结束不包含7
System.out.println("截取字符串："+str);

//大小写转换
str = "login?unme=zs&pwd=zs";
str = str.toUpperCase();
System.out.println("转为大写："+str);

str = str.toLowerCase();
System.out.println("转为小写："+str);

//通过静态方法创建String对象
String str1 = String.valueOf(123);
System.out.println(str1);

//对象转字符串 其实就是调用当前对象的toString方法
User u = new User(10);
String str2 = String.valueOf(u);
System.out.println(str2);
}
}

class User{
private int age;
public User() {
// TODO Auto-generated constructor stub
}
public User(int age) {
super();
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User [age=" + age + "]";
}
}

StringBuffer

之所以能够可变的原因，底层就是一个字符数组，动态数组。

public class Test04 {
public static void main(String[] args) {
// 创建StringBuffer
StringBuffer sb = new StringBuffer();
// 容量16
System.out.println("通过空构造器创建的StringBuffer的容量："+sb.capacity());

//添加元素
sb.append(true);
sb.append(false).append("123").append("134");// 链式编程

System.out.println(sb);
System.out.println("当前sb对象中的字符串长度："+sb.length());

//添加元素
sb.insert(1, "heihei");
System.out.println(sb);

}
}

StringBuilder

StringBuilder和StringBuffer 都继承了AbstractStringBuilder

StringBuffer效率低于StringBuilder
StringBuffer安全性要高于StringBuilder
一般情况下使用StringBuilder

jdk9之后  String中存储数据通过byte数组存储 + 变量
jdk中对于String存储时的内容消耗极大降低

包装类

8大基本数据类型 -> 8个包装类

byte->Byte short->Short long ->Long float->Float double->Double boolean->Boolean

char ->Character int ->Integer

jdk12 Integer中的所有构造器都过时 通过valueOf方法获取int对应的Integer对象

• String->int Integer.parseInt();// 可能报异常
• int ->String String.valueOf()

jdk1.5之后支持自动拆装箱，本质上就是调用了

装箱：Integer.valueOf()

拆箱：对象.intValue()

• 9**

  反之会重新创建一个新的Integer对象

public class Test02 {
public static void main(String[] args) {

Integer in1 = 123;//jdk1.5之后支持自动装箱  Integer.valueOf(123);
int num = in1;//jdk1.5之后支持自动拆箱 in1.intValue();

Integer in2 = 88;
Integer in3 = 88;
System.out.println(in2==in3);

in2 = 127;
in3 = 127;
System.out.println(in2==in3);
}
}

tips:

字面值创建Boolean对象时 只能指定true和false 并且创建的对象也是对应的true和false

字符串创建Boolean对象是 只要字符是true/false 无所谓大小写 得到对应的Boolean对象就是与之对应的true和false

其它所有字符串赋值都是false

时间Date

空构造器对象创建出的是当前系统时间对象

public class Test01 {
public static void main(String[] args) {
//创建Date对象
Date d = new Date();
System.out.println(d);

//通过带参构造器创建对象
Date date = new Date(1563960432618L);
System.out.println(date);

System.out.println(d.after(date));
System.out.println(d.before(date));

//获取毫秒数
long dateTime = System.currentTimeMillis();
System.out.println(dateTime);
}
}

格式化输出时间：

public class Test02 {

public static void main(String[] args) {

//创建时间对象
Date date = new Date();

//创SimpleDateFormat对象
SimpleDateFormat sd = new SimpleDateFormat();

//设置一下输出的内容格式
sd.applyPattern("yyyy年MM月dd日 HH时mm分ss秒 是一年中的第D天  W w");

//调用格式化方法格式化日期
String str = sd.format(date);
System.out.println(str);

//创建对象并且指定格式化的内容
SimpleDateFormat ss = new SimpleDateFormat("yy/MM/dd hh:mm:ss");
System.out.println(ss.format(date));
}

}