day13方法重写、String、StringBuffer
1.方法重写
1.发生条件：
1.发生继承关系、实现关系
2.父类不安组子类的需求
3.子类重写父类中的方法
2.注意事项：
1.方法同名
2.参数列表一模一样
3.子类的返回值类型<=父类的返回值类型（引用数据类型）
在基本数据类型中，子类的返回类型要和父类相同
4.子类的修饰符>=父类（父类的修饰符不能是private）
5.子类抛出的异常<=父类（可以理解为任意方法都会抛出runtimexception）
代码:
public class Test01 {
public static void main(String[] args) {
}
}
class F{
F fun(F s) {
System.out.println(1/0);
return null;
}
}
class S extends F{
@Override
public S fun(F s)throws NullPointerException{
return null;
}
}
3.main方法
public:保证能够调用到
static:保证外界调用无需创建对象
void:jvm无返回值
String[] args:可以传入 调用main方法时可以传入实际参数
2.scanner
hasNextXXX :获取扫描到的数据书否时XXX类型
nextXXX: 获取下一个扫描到的内容转为XXX类型（转换过程中可能存在问题）
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
/*
* 学习使用Scanner
* hasNextXXX 获取扫描到的数据是否是XXX类型
* nextXXX 获取下一个扫描到的内容转为XXX类型(转换过程中有可能存在问题)
*/
public class Test01 {
public static void main(String[] args)throws FileNotFoundException {
Scanner input = new Scanner(System.in);
/*
* if(input.hasNextInt()) { System.out.println(input.nextInt()); }
*/
if(input.hasNext()) {
System.out.println(input.next());
}
//重新创建Scanner对象 指定文件作为输入源
Scanner sc = new Scanner(new File("C:\\Users\\wawjy\\Desktop\\a.txt"));
System.out.println(sc.next());
}
}
3.String
创建String对象:
new String();
new String(“abc”);
“love”;
new String(buf,2,2);//通过字节数组创建
代码:
public class Test01 {
public static void main(String[] args) throws UnsupportedEncodingException {
// String 构造器
String str1 = new String();//是一个""对象
System.out.println(str1);
// 通过双引号直接创建String对象
String str2 = "love";//通过字符串常量直接创建String对象
//通过字符串常量给str3赋值
String str3 = "";
//比较str1和str3
System.out.println(str1==str3);
//按照字节数组创建字符串对象
byte[] buf = new byte[] {65,66,67,68,69};
String str4 = new String(buf);
System.out.println("通过字节数组创建字符串："+str4);
str4 = new String(buf,2,2);
System.out.println("通过字节数组创建字符串："+str4);
str4 = new String(buf,2,2,"UTF-8");
System.out.println("通过字节数组创建字符串："+str4);
//按照字符数组创建字符串对象
char[] ch = new char[] {'啦','里','个','拉'};
str4 = new String(ch);
System.out.println("通过字符数组创建字符串："+str4);
str4 = new String(ch,0,2);
System.out.println("通过字符数组创建字符串："+str4);
//按照代码点创建字符串对象
int[] ins = new int[] {88,89,100,99};
str4 = new String(ins,0,4);
System.out.println("按照代码点创建字符串对象："+str4);
//按照字符串对象创建字符串对象
String str5 = new String("abc");
System.out.println(str5);
}
}
String的常见方法:
1.charAt(int index):返回当前索引位置上的指定字符
2.codePointAt(int index):返回指定索引位置上元素的代码点
3.compareTo(String):比较两个字符串的大小
4.compareToIgronCase(String):比较两个字符串的大小（忽略大小写）
5.concat(String):拼接字符
6.copyValueOf(char[]):查询指定位置上的字符
7.getBytes：获取字符串的字节数组
8.getChars()：获取字符串的字符数组
9.indexOf()：查询指定字符出现的位置
10.isEmpty()：查看数组是否为空
11.repleace(“str”,“str”):替换指定字符
12.splite():按照指定字符分割字符串
13.subString():截取指定位置字符串
14.toUpperCase():转为大写
15.toLowerCase():转为小写
16.String str1 = String.valueOf(123);//通过静态方法创建String对象
import java.util.Arrays;
/*
* String 的常见方法：
*
*
*
*/
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 + "]";
}
}
4.StringBuffer和StringBuilder
1.StringBuilder和StringBuffer都继承了AbstractStringBuilder
2.StringBuffer效率低于StringBuilder
3.StringBuffer安全性要高于StringBuilder
4.一般情况下使用StringBuilder
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);
}
}
调用关系:
5.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);
import java.text.SimpleDateFormat;
import java.util.Date;
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));
}
6.八大基本数据类型的包装类
1.八个包装类
byte->Byte
short->Short
char ->Character
int ->Integer
long ->Long
float->Float
double->Double
boolean->Boolean
注意:jdk12 Integer中的所有构造器都过时 通过valueOf方法获取int对应的Integer对象
public class Test01 {
public static void main(String[] args) {
//静态成员变量
System.out.println("BYTES:"+Integer.BYTES);
System.out.println("MAXVALUE:"+Integer.MAX_VALUE);
System.out.println("MINVALUE:"+Integer.MIN_VALUE);
System.out.println("SIZE:"+Integer.SIZE);
System.out.println("CLASS:"+Integer.TYPE);
//构造器
Integer in1 = new Integer(12);
System.out.println(in1);
Integer in2 = new Integer("123");// 可能出现数字格式化异常
System.out.println(in2);
System.out.println(Integer.max(12, 20));
//parseInt(String)
System.out.println("字符串转为int："+Integer.parseInt("1234"));
System.out.println("字符串转为int："+Integer.parseInt("1100",2));// 将一个对应进制的数值变为对应十进制的字符串
//System.out.println(""+Integer.reverse(Integer.MAX_VALUE));//将当前数值在计算机中存储的补码进行翻转得到的十进制的数
System.out.println("2进制:"+Integer.toBinaryString(Integer.MAX_VALUE));
System.out.println("8进制:"+Integer.toOctalString(12));
//获取Integer对象
Integer in3 = Integer.valueOf(12);
System.out.println(in3);
Integer in4 = Integer.valueOf("12");
System.out.println(in4);
}
}
2.拆箱和装箱:
装箱：Integer.valueOf()
拆箱：对象.intValue()
其中：自动装箱时，首先会判定当前的值是否在缓冲区中[-128,127],如果再改区间中，直接从缓冲区中获取对应的Integer对象。反之会重新创建一个新的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 = 130;
in3 = 130;
System.out.println(in2==in3);
}
}
结果:
3.相关
1.字面值创建Boolean对象时 只能指定true和false 并且创建的对象也是对应的true和false
2.字符串创建Boolean对象是 只要字符是true/false 无所谓大小写 得到对应的Boolean对象就是与之对应的true和false
3.其它所有字符串赋值都是false
public class Test03 {
public static void main(String[] args) {
// 创建Boolean对象
Boolean f1 = new Boolean(true);
System.out.println(f1);
f1 = new Boolean(false);
System.out.println(f1);
f1 = new Boolean("1");
System.out.println(f1);
f1 = new Boolean("0");
System.out.println(f1);
f1 = new Boolean("TRue");
System.out.println(f1);
f1 = new Boolean("False");
System.out.println(f1);
f1 = new Boolean("123");
System.out.println(f1);
}
}
public class Test03 {
public static void main(String[] args) {
// 创建Boolean对象
Boolean f1 = new Boolean(true);
System.out.println(f1);
f1 = new Boolean(false);
System.out.println(f1);
f1 = new Boolean("1");
System.out.println(f1);
f1 = new Boolean("0");
System.out.println(f1);
f1 = new Boolean("TRue");
System.out.println(f1);
f1 = new Boolean("False");
System.out.println(f1);
f1 = new Boolean("123");
System.out.println(f1);
}
}
结果: