day13方法重写、String、StringBuffer

最新推荐文章于 2021-02-21 16:05:51 发布

指尖灬流年

最新推荐文章于 2021-02-21 16:05:51 发布

阅读量303

点赞数

本文链接：https://blog.csdn.net/AO915442988/article/details/97289056

版权

内容概括

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);
		
	}
}

结果: 在这里插入图片描述

指尖灬流年

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
day13方法重写、String、StringBuffer

1.方法重写1.发生条件：1.发生继承关系、实现关系2.父类不安组子类的需求3.子类重写父类中的方法2.注意事项：1.方法同名2.参数列表一模一样3.子类的返回值类型<=父类的返回值类型（引用数据类型）在基本数据类型中，子类的返回类型要和父类相同4.子类的修饰符>=父类（父类的修饰符不能是private）5.子类抛出的异常<=父类（可以理解为任意...
复制链接

扫一扫